brinkcommerce-dev-mcp 0.1.0-beta.1

package/dist/tools/order-tools.js

@@ -0,0 +1,3588 @@
+import { createOrderManagementClient } 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, cancel, refund operations)
+const destructiveAnnotations = {
+    readOnlyHint: false,
+    destructiveHint: true,
+    openWorldHint: true,
+};
+/**
+ * Helper function to format order data for display
+ * @param order - The order object to format
+ * @returns Formatted order details string
+ */
+function formatOrderResponse(order) {
+    return (`Order Details:\n\n` +
+        `Order ID: ${order.id}\n` +
+        `Reference: ${order.reference}\n` +
+        `Date: ${order.date}\n` +
+        `Currency: ${order.currencyCode}\n` +
+        `Store Group: ${order.storeGroupId}\n` +
+        `Channel: ${order.channelType}\n` +
+        `Status: ${JSON.stringify(order.status, null, 2)}\n\n` +
+        `Order Lines: ${order.orderLines.length}\n` +
+        `Shipping Fees: ${order.shippingFees.length}\n\n` +
+        `Full order data:\n${JSON.stringify(order, null, 2)}`);
+}
+/**
+ * Helper function to validate order lines
+ * @param orderLines - Array of order line items to validate
+ * @returns Error message if validation fails, undefined if valid
+ */
+function validateOrderLines(orderLines) {
+    for (let i = 0; i < orderLines.length; i++) {
+        const line = orderLines[i];
+        if (!line.orderLineId || typeof line.orderLineId !== "string" || line.orderLineId.trim() === "") {
+            return `Error: Invalid order line at index ${i}. 'orderLineId' must be a non-empty string.`;
+        }
+        if (typeof line.quantity !== "number" || line.quantity < 1 || !Number.isInteger(line.quantity)) {
+            return `Error: Invalid order line at index ${i}. 'quantity' must be an integer >= 1 (got: ${line.quantity}).`;
+        }
+    }
+    return undefined;
+}
+/**
+ * Helper function to validate gifts
+ * @param gifts - Array of gift items to validate
+ * @returns Error message if validation fails, undefined if valid
+ */
+function validateGifts(gifts) {
+    for (let i = 0; i < gifts.length; i++) {
+        const gift = gifts[i];
+        if (!gift.giftId || typeof gift.giftId !== "string" || gift.giftId.trim() === "") {
+            return `Error: Invalid gift at index ${i}. 'giftId' must be a non-empty string.`;
+        }
+        if (typeof gift.quantity !== "number" || gift.quantity < 1 || !Number.isInteger(gift.quantity)) {
+            return `Error: Invalid gift at index ${i}. 'quantity' must be an integer >= 1 (got: ${gift.quantity}).`;
+        }
+    }
+    return undefined;
+}
+/**
+ * Helper function to validate refund fee
+ * @param fee - Refund fee object to validate
+ * @returns Error message if validation fails, undefined if valid
+ */
+function validateRefundFee(fee) {
+    if (!fee.name || typeof fee.name !== "string" || fee.name.trim() === "") {
+        return "Error: Fee 'name' must be a non-empty string.";
+    }
+    if (typeof fee.amount !== "number" || fee.amount < 1 || !Number.isInteger(fee.amount)) {
+        return `Error: Fee 'amount' must be an integer >= 1 (got: ${fee.amount}).`;
+    }
+    if (typeof fee.taxPercentage !== "number" ||
+        fee.taxPercentage < 0 ||
+        fee.taxPercentage > 100000 ||
+        !Number.isInteger(fee.taxPercentage)) {
+        return `Error: Fee 'taxPercentage' must be an integer between 0 and 100000 (got: ${fee.taxPercentage}).`;
+    }
+    if (fee.taxPercentageDecimals !== undefined &&
+        (typeof fee.taxPercentageDecimals !== "number" ||
+            (fee.taxPercentageDecimals !== 2 && fee.taxPercentageDecimals !== 3))) {
+        return `Error: Fee 'taxPercentageDecimals' must be 2 or 3 (got: ${fee.taxPercentageDecimals}).`;
+    }
+    return undefined;
+}
+/**
+ * Helper function to validate import order request
+ * @param request - Import order request to validate
+ * @returns Error message if validation fails, undefined if valid
+ */
+function validateImportOrderRequest(request) {
+    // Validate required string fields
+    if (!request.importId || typeof request.importId !== "string" || request.importId.trim() === "") {
+        return "Error: 'importId' is required and must be a non-empty string.";
+    }
+    if (request.importId.length > 100) {
+        return "Error: 'importId' must be at most 100 characters.";
+    }
+    if (!request.countryCode || typeof request.countryCode !== "string") {
+        return "Error: 'countryCode' is required and must be a string.";
+    }
+    if (!/^[A-Z]{2}$/.test(request.countryCode)) {
+        return `Error: 'countryCode' must be a 2-character ISO country code (e.g., 'SE', 'NO'). Got: ${request.countryCode}`;
+    }
+    if (!request.languageCode || typeof request.languageCode !== "string" || request.languageCode.trim() === "") {
+        return "Error: 'languageCode' is required and must be a non-empty string.";
+    }
+    if (!request.currencyCode || typeof request.currencyCode !== "string") {
+        return "Error: 'currencyCode' is required and must be a string.";
+    }
+    if (!/^[A-Z]{3}$/.test(request.currencyCode)) {
+        return `Error: 'currencyCode' must be a 3-character ISO currency code (e.g., 'SEK', 'EUR'). Got: ${request.currencyCode}`;
+    }
+    if (!request.taxationCountry || typeof request.taxationCountry !== "string") {
+        return "Error: 'taxationCountry' is required and must be a string.";
+    }
+    if (!/^[A-Z]{2}$/.test(request.taxationCountry)) {
+        return `Error: 'taxationCountry' must be a 2-character ISO country code. Got: ${request.taxationCountry}`;
+    }
+    // Validate boolean fields
+    if (typeof request.isTaxIncludedInPrice !== "boolean") {
+        return "Error: 'isTaxIncludedInPrice' is required and must be a boolean.";
+    }
+    if (typeof request.isTaxExemptionEligible !== "boolean") {
+        return "Error: 'isTaxExemptionEligible' is required and must be a boolean.";
+    }
+    if (typeof request.isTaxExempt !== "boolean") {
+        return "Error: 'isTaxExempt' is required and must be a boolean.";
+    }
+    // Validate channelType
+    if (!request.channelType || (request.channelType !== "B2C" && request.channelType !== "B2B")) {
+        return `Error: 'channelType' must be either 'B2C' or 'B2B'. Got: ${request.channelType}`;
+    }
+    // Validate payment object
+    if (!request.payment || typeof request.payment !== "object") {
+        return "Error: 'payment' is required and must be an object.";
+    }
+    if (!request.payment.providerId || typeof request.payment.providerId !== "string" || request.payment.providerId.trim() === "") {
+        return "Error: 'payment.providerId' is required and must be a non-empty string.";
+    }
+    if (!request.payment.providerName || typeof request.payment.providerName !== "string" || request.payment.providerName.trim() === "") {
+        return "Error: 'payment.providerName' is required and must be a non-empty string.";
+    }
+    // Validate payment provider name is from allowed enum
+    const validPaymentProviders = [
+        "Adyen",
+        "Avarda",
+        "CustomPayment",
+        "KlarnaCheckout",
+        "Ledyer",
+        "QliroOne",
+        "SveaCheckout",
+        "WalleyCheckout",
+        "Zaver",
+        "BrinkZeroPayment",
+    ];
+    if (!validPaymentProviders.includes(request.payment.providerName)) {
+        return `Error: 'payment.providerName' must be one of: ${validPaymentProviders.join(", ")}. Got: '${request.payment.providerName}'`;
+    }
+    if (!request.payment.reference || typeof request.payment.reference !== "string" || request.payment.reference.trim() === "") {
+        return "Error: 'payment.reference' is required and must be a non-empty string.";
+    }
+    if (!request.payment.method || typeof request.payment.method !== "string" || request.payment.method.trim() === "") {
+        return "Error: 'payment.method' is required and must be a non-empty string.";
+    }
+    // Validate shipping object (optional, but if provided, must have required fields)
+    if (request.shipping) {
+        if (typeof request.shipping !== "object") {
+            return "Error: 'shipping' must be an object.";
+        }
+        if (!request.shipping.providerId || typeof request.shipping.providerId !== "string" || request.shipping.providerId.trim() === "") {
+            return "Error: 'shipping.providerId' is required and must be a non-empty string when shipping object is provided.";
+        }
+        if (!request.shipping.providerName || typeof request.shipping.providerName !== "string" || request.shipping.providerName.trim() === "") {
+            return "Error: 'shipping.providerName' is required and must be a non-empty string when shipping object is provided.";
+        }
+        // Validate shipping provider name is from allowed enum
+        const validShippingProviders = [
+            "Ingrid",
+            "KlarnaShippingAssistant",
+            "Nshift",
+            "QliroIntegratedShipping",
+            "WalleyDeliveryModule",
+            "AvardaShippingBroker",
+        ];
+        if (!validShippingProviders.includes(request.shipping.providerName)) {
+            return `Error: 'shipping.providerName' must be one of: ${validShippingProviders.join(", ")}. Got: '${request.shipping.providerName}'`;
+        }
+        if (!request.shipping.reference || typeof request.shipping.reference !== "string" || request.shipping.reference.trim() === "") {
+            return "Error: 'shipping.reference' is required and must be a non-empty string when shipping object is provided.";
+        }
+    }
+    // Validate addresses
+    if (!request.shippingAddress || typeof request.shippingAddress !== "object") {
+        return "Error: 'shippingAddress' is required and must be an object.";
+    }
+    const shippingAddressError = validateAddress(request.shippingAddress, "shippingAddress");
+    if (shippingAddressError) {
+        return shippingAddressError;
+    }
+    if (!request.billingAddress || typeof request.billingAddress !== "object") {
+        return "Error: 'billingAddress' is required and must be an object.";
+    }
+    const billingAddressError = validateAddress(request.billingAddress, "billingAddress");
+    if (billingAddressError) {
+        return billingAddressError;
+    }
+    // Validate orderLines array
+    if (!request.orderLines || !Array.isArray(request.orderLines)) {
+        return "Error: 'orderLines' is required and must be an array.";
+    }
+    if (request.orderLines.length < 1) {
+        return "Error: 'orderLines' must contain at least 1 item.";
+    }
+    if (request.orderLines.length > 200) {
+        return "Error: 'orderLines' must contain at most 200 items.";
+    }
+    // Validate each order line
+    for (let i = 0; i < request.orderLines.length; i++) {
+        const line = request.orderLines[i];
+        if (!line.id || typeof line.id !== "string" || line.id.trim() === "") {
+            return `Error: orderLines[${i}].id is required and must be a non-empty string.`;
+        }
+        if (!line.name || typeof line.name !== "string" || line.name.trim() === "") {
+            return `Error: orderLines[${i}].name is required and must be a non-empty string.`;
+        }
+        if (!line.imageUrl || typeof line.imageUrl !== "string" || line.imageUrl.trim() === "") {
+            return `Error: orderLines[${i}].imageUrl is required and must be a non-empty string.`;
+        }
+        if (typeof line.quantity !== "number" || line.quantity < 1 || !Number.isInteger(line.quantity)) {
+            return `Error: orderLines[${i}].quantity must be an integer >= 1.`;
+        }
+        if (typeof line.taxPercentage !== "number" || !Number.isInteger(line.taxPercentage)) {
+            return `Error: orderLines[${i}].taxPercentage must be an integer.`;
+        }
+        if (typeof line.taxPercentageDecimals !== "number" || (line.taxPercentageDecimals !== 2 && line.taxPercentageDecimals !== 3)) {
+            return `Error: orderLines[${i}].taxPercentageDecimals must be 2 or 3.`;
+        }
+        if (typeof line.basePriceAmount !== "number" || line.basePriceAmount < 0 || !Number.isInteger(line.basePriceAmount)) {
+            return `Error: orderLines[${i}].basePriceAmount must be a non-negative integer.`;
+        }
+        if (typeof line.salePriceAmount !== "number" || line.salePriceAmount < 0 || !Number.isInteger(line.salePriceAmount)) {
+            return `Error: orderLines[${i}].salePriceAmount must be a non-negative integer.`;
+        }
+        if (typeof line.totalDiscountAmount !== "number" || line.totalDiscountAmount < 0 || !Number.isInteger(line.totalDiscountAmount)) {
+            return `Error: orderLines[${i}].totalDiscountAmount must be a non-negative integer.`;
+        }
+        if (typeof line.totalPriceAmount !== "number" || line.totalPriceAmount < 0 || !Number.isInteger(line.totalPriceAmount)) {
+            return `Error: orderLines[${i}].totalPriceAmount must be a non-negative integer.`;
+        }
+        if (typeof line.totalTaxAmount !== "number" || line.totalTaxAmount < 0 || !Number.isInteger(line.totalTaxAmount)) {
+            return `Error: orderLines[${i}].totalTaxAmount must be a non-negative integer.`;
+        }
+    }
+    return undefined;
+}
+/**
+ * Helper function to validate address object
+ * @param address - Address object to validate
+ * @param fieldName - Name of the field for error messages
+ * @returns Error message if validation fails, undefined if valid
+ */
+function validateAddress(address, fieldName) {
+    // NOTE: ALL fields must be non-empty strings, including streetAddress2 and stateOrProvince
+    // which are often optional in other systems
+    const requiredFields = ["country", "telephoneNumber", "stateOrProvince", "streetAddress", "city", "givenName", "postalCode", "streetAddress2", "email"];
+    for (const field of requiredFields) {
+        if (!address[field] || typeof address[field] !== "string" || address[field].trim() === "") {
+            // Provide helpful context for commonly-optional fields
+            if (field === "streetAddress2") {
+                return `Error: '${fieldName}.streetAddress2' is required and must be a non-empty string (use a placeholder like 'N/A' or '-' if not applicable).`;
+            }
+            if (field === "stateOrProvince") {
+                return `Error: '${fieldName}.stateOrProvince' is required and must be a non-empty string (use a placeholder like 'N/A' or '-' if not applicable).`;
+            }
+            return `Error: '${fieldName}.${field}' is required and must be a non-empty string.`;
+        }
+    }
+    // Validate country is 2-character ISO code
+    if (!/^[A-Z]{2}$/.test(address.country)) {
+        return `Error: '${fieldName}.country' must be a 2-character ISO country code. Got: ${address.country}`;
+    }
+    return undefined;
+}
+/**
+ * MCP Tool Definitions for Order Management
+ */
+export const orderTools = {
+    get_order: {
+        name: "get_order",
+        description: "Retrieve order details by order ID from BrinkCommerce. Returns complete order information including lines, totals, status, and customer data.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                orderId: {
+                    type: "string",
+                    description: "The order ID to retrieve (UUID format)",
+                },
+            },
+            required: ["orderId"],
+        },
+        annotations: readOnlyAnnotations,
+    },
+    get_order_by_reference: {
+        name: "get_order_by_reference",
+        description: "Retrieve order details by order reference from BrinkCommerce. The reference is the shorter, human-readable order identifier.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                reference: {
+                    type: "string",
+                    description: "The order reference (e.g., 'ORD-12345')",
+                },
+            },
+            required: ["reference"],
+        },
+        annotations: readOnlyAnnotations,
+    },
+    cancel_order: {
+        name: "cancel_order",
+        description: "Cancel an order in BrinkCommerce. Creates a cancellation request for the entire order. " +
+            "WHY CONFIRMATION MATTERS: Canceling orders affects real customer transactions, inventory reservations, and may trigger payment reversals. " +
+            "This operation cannot be easily undone and has financial implications.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                orderId: {
+                    type: "string",
+                    description: "The order ID to cancel (UUID format)",
+                },
+                reason: {
+                    type: "object",
+                    description: "Optional reason for the cancellation (useful for BI tracking and customer communication)",
+                    properties: {
+                        code: {
+                            type: "string",
+                            description: "Optional code for the reason (e.g., 'OUT_OF_STOCK', 'CUSTOMER_REQUEST'). Max 100 characters.",
+                        },
+                        cause: {
+                            type: "string",
+                            description: "Optional human-readable cause for the cancellation (e.g., 'Customer requested cancellation via phone'). Max 300 characters.",
+                        },
+                    },
+                },
+            },
+            required: ["orderId"],
+        },
+        annotations: destructiveAnnotations,
+    },
+    refund_order: {
+        name: "refund_order",
+        description: "Create a refund for an order in BrinkCommerce. Refunds can only be created after deliveries exist. " +
+            "WHY CONFIRMATION MATTERS: Refunds process real money back to customers and affect inventory, accounting, and payment provider balances. " +
+            "Incorrect refunds can lead to financial losses and customer confusion. This operation has irreversible financial consequences.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                orderId: {
+                    type: "string",
+                    description: "The order ID to refund (UUID format)",
+                },
+                orderLines: {
+                    type: "array",
+                    description: "Optional: Specific order lines to refund. If not provided, entire order may be refunded based on what's available.",
+                    items: {
+                        type: "object",
+                        properties: {
+                            orderLineId: {
+                                type: "string",
+                                description: "The order line ID (UUID format)",
+                            },
+                            quantity: {
+                                type: "integer",
+                                description: "Quantity to refund (must be >= 1)",
+                                minimum: 1,
+                            },
+                            reason: {
+                                type: "object",
+                                description: "Optional reason specific to this order line",
+                                properties: {
+                                    code: {
+                                        type: "string",
+                                        description: "Reason code (max 100 characters)",
+                                    },
+                                    cause: {
+                                        type: "string",
+                                        description: "Human-readable cause (max 300 characters)",
+                                    },
+                                },
+                            },
+                        },
+                        required: ["orderLineId", "quantity"],
+                    },
+                },
+                shippingFees: {
+                    type: "array",
+                    description: "Optional: Shipping fee IDs to refund",
+                    items: {
+                        type: "string",
+                        description: "Shipping fee ID (UUID format)",
+                    },
+                },
+                gifts: {
+                    type: "array",
+                    description: "Optional: Order gifts to refund",
+                    items: {
+                        type: "object",
+                        properties: {
+                            giftId: {
+                                type: "string",
+                                description: "Gift ID (UUID format)",
+                            },
+                            quantity: {
+                                type: "integer",
+                                description: "Quantity to refund (must be >= 1)",
+                                minimum: 1,
+                            },
+                        },
+                        required: ["giftId", "quantity"],
+                    },
+                },
+                giftCardProducts: {
+                    type: "array",
+                    description: "Optional: Gift card products to refund",
+                    items: {
+                        type: "object",
+                        properties: {
+                            giftCardProductId: {
+                                type: "string",
+                                description: "Gift card product ID (UUID format)",
+                            },
+                        },
+                        required: ["giftCardProductId"],
+                    },
+                },
+                fee: {
+                    type: "object",
+                    description: "Optional refund fee. Only applies to amount sent to payment provider (not gift cards or bonus points). " +
+                        "Supported by: Adyen, KlarnaCheckout, WalleyCheckout. If fee exceeds total refund, uses total refund amount.",
+                    properties: {
+                        name: {
+                            type: "string",
+                            description: "Descriptive name for the refund fee (e.g., 'Restocking fee')",
+                        },
+                        taxPercentage: {
+                            type: "integer",
+                            description: "Tax percentage in basis points. Example: taxPercentage=2500 with taxPercentageDecimals=2 means 25.00% tax. Range: 0-100000.",
+                            minimum: 0,
+                            maximum: 100000,
+                        },
+                        taxPercentageDecimals: {
+                            type: "integer",
+                            description: "Number of decimals in tax percentage (2 or 3). Default: 2",
+                            minimum: 2,
+                            maximum: 3,
+                            default: 2,
+                        },
+                        amount: {
+                            type: "integer",
+                            description: "Refund fee amount in minor currency units (e.g., cents). Must be >= 1.",
+                            minimum: 1,
+                        },
+                    },
+                    required: ["name", "taxPercentage", "amount"],
+                },
+                reason: {
+                    type: "object",
+                    description: "Optional reason for the refund (useful for BI tracking and customer communication)",
+                    properties: {
+                        code: {
+                            type: "string",
+                            description: "Optional code for the reason (e.g., 'DAMAGED_GOODS', 'CUSTOMER_RETURN'). Max 100 characters.",
+                        },
+                        cause: {
+                            type: "string",
+                            description: "Optional human-readable cause (e.g., 'Item arrived damaged, customer returned'). Max 300 characters.",
+                        },
+                    },
+                },
+            },
+            required: ["orderId"],
+        },
+        annotations: destructiveAnnotations,
+    },
+    import_order: {
+        name: "import_order",
+        description: "Import an external order into BrinkCommerce. This endpoint allows importing orders from external systems without creating a Shopper Session first. " +
+            "WHY CONFIRMATION MATTERS: Importing orders creates real order records in the system with financial implications. " +
+            "This operation should be used carefully during migration or integration scenarios.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                importId: {
+                    type: "string",
+                    description: "The external import ID for this order (1-100 characters). Brink order ID & reference will be generated on successful import.",
+                },
+                request: {
+                    type: "object",
+                    description: "Complete order import request with all required fields",
+                    properties: {
+                        importId: {
+                            type: "string",
+                            description: "The external import ID (must match the top-level importId parameter)",
+                        },
+                        date: {
+                            type: "string",
+                            description: "Optional: The external date time the order was completed (ISO 8601 format)",
+                        },
+                        countryCode: {
+                            type: "string",
+                            description: "ISO 3166-1 alpha-2 country code (e.g., 'SE', 'NO', 'DK')",
+                        },
+                        languageCode: {
+                            type: "string",
+                            description: "Language code (e.g., 'sv', 'en', 'no')",
+                        },
+                        currencyCode: {
+                            type: "string",
+                            description: "ISO 4217 currency code (e.g., 'SEK', 'NOK', 'EUR')",
+                        },
+                        channelType: {
+                            type: "string",
+                            description: "Channel type: 'B2C' or 'B2B'",
+                            enum: ["B2C", "B2B"],
+                        },
+                        isTaxIncludedInPrice: {
+                            type: "boolean",
+                            description: "Whether tax is included in the price. Can only be true for B2C channel types.",
+                        },
+                        isTaxExemptionEligible: {
+                            type: "boolean",
+                            description: "Whether the order is eligible for tax exemption (typically true for B2B except merchant's home market)",
+                        },
+                        isTaxExempt: {
+                            type: "boolean",
+                            description: "Whether the order is tax exempt",
+                        },
+                        taxationCountry: {
+                            type: "string",
+                            description: "ISO 3166-1 alpha-2 country code for taxation",
+                        },
+                        storeGroupId: {
+                            type: "string",
+                            description: "Optional: Store group ID",
+                        },
+                        payment: {
+                            type: "object",
+                            description: "Payment provider information (required). " +
+                                "IMPORTANT: providerName must be one of the valid enum values: " +
+                                "Adyen, Avarda, CustomPayment, KlarnaCheckout, Ledyer, QliroOne, SveaCheckout, WalleyCheckout, Zaver, BrinkZeroPayment",
+                            properties: {
+                                providerId: {
+                                    type: "string",
+                                    description: "Payment provider ID",
+                                },
+                                providerName: {
+                                    type: "string",
+                                    description: "Payment provider name - MUST be one of: Adyen, Avarda, CustomPayment, KlarnaCheckout, Ledyer, QliroOne, SveaCheckout, WalleyCheckout, Zaver, BrinkZeroPayment",
+                                    enum: ["Adyen", "Avarda", "CustomPayment", "KlarnaCheckout", "Ledyer", "QliroOne", "SveaCheckout", "WalleyCheckout", "Zaver", "BrinkZeroPayment"],
+                                },
+                                reference: {
+                                    type: "string",
+                                    description: "Payment reference from the provider",
+                                },
+                                method: {
+                                    type: "string",
+                                    description: "Payment method (e.g., 'card', 'invoice', 'direct_debit')",
+                                },
+                            },
+                            required: ["providerId", "providerName", "reference", "method"],
+                        },
+                        shipping: {
+                            type: "object",
+                            description: "Shipping provider information (optional, but commonly required for imports). " +
+                                "IMPORTANT: If provided, all fields are required. providerName must be one of: " +
+                                "Ingrid, KlarnaShippingAssistant, Nshift, QliroIntegratedShipping, WalleyDeliveryModule, AvardaShippingBroker",
+                            properties: {
+                                providerId: {
+                                    type: "string",
+                                    description: "Shipping provider ID",
+                                },
+                                providerName: {
+                                    type: "string",
+                                    description: "Shipping provider name - MUST be one of: Ingrid, KlarnaShippingAssistant, Nshift, QliroIntegratedShipping, WalleyDeliveryModule, AvardaShippingBroker",
+                                    enum: ["Ingrid", "KlarnaShippingAssistant", "Nshift", "QliroIntegratedShipping", "WalleyDeliveryModule", "AvardaShippingBroker"],
+                                },
+                                reference: {
+                                    type: "string",
+                                    description: "Shipping reference from the provider",
+                                },
+                            },
+                            required: ["providerId", "providerName", "reference"],
+                        },
+                        shippingAddress: {
+                            type: "object",
+                            description: "Shipping address (required). " +
+                                "IMPORTANT: ALL fields are required including streetAddress2 and stateOrProvince (use 'N/A' or '-' if not applicable)",
+                            properties: {
+                                country: {
+                                    type: "string",
+                                    description: "ISO 3166-1 alpha-2 country code",
+                                },
+                                telephoneNumber: {
+                                    type: "string",
+                                    description: "Phone number",
+                                },
+                                stateOrProvince: {
+                                    type: "string",
+                                    description: "State or province - REQUIRED (use 'N/A' or '-' if not applicable)",
+                                },
+                                streetAddress: {
+                                    type: "string",
+                                    description: "Street address line 1",
+                                },
+                                streetAddress2: {
+                                    type: "string",
+                                    description: "Street address line 2 - REQUIRED (use 'N/A' or '-' if not applicable)",
+                                },
+                                city: {
+                                    type: "string",
+                                    description: "City",
+                                },
+                                givenName: {
+                                    type: "string",
+                                    description: "First name",
+                                },
+                                familyName: {
+                                    type: "string",
+                                    description: "Last name (required for B2C, optional for B2B)",
+                                },
+                                postalCode: {
+                                    type: "string",
+                                    description: "Postal/ZIP code",
+                                },
+                                email: {
+                                    type: "string",
+                                    description: "Email address",
+                                },
+                            },
+                            required: ["country", "telephoneNumber", "stateOrProvince", "streetAddress", "city", "givenName", "postalCode", "streetAddress2", "email"],
+                        },
+                        billingAddress: {
+                            type: "object",
+                            description: "Billing address (required, same structure as shippingAddress). " +
+                                "IMPORTANT: ALL fields are required including streetAddress2 and stateOrProvince (use 'N/A' or '-' if not applicable)",
+                        },
+                        orderLines: {
+                            type: "array",
+                            description: "Order lines (1-200 items required)",
+                            minItems: 1,
+                            maxItems: 200,
+                            items: {
+                                type: "object",
+                                properties: {
+                                    id: {
+                                        type: "string",
+                                        description: "Order line ID",
+                                    },
+                                    productParentId: {
+                                        type: "string",
+                                        description: "Optional: Product parent ID",
+                                    },
+                                    productVariantId: {
+                                        type: "string",
+                                        description: "Optional: Product variant ID",
+                                    },
+                                    taxGroupId: {
+                                        type: "string",
+                                        description: "Optional: Tax group ID",
+                                    },
+                                    name: {
+                                        type: "string",
+                                        description: "Product name",
+                                    },
+                                    description: {
+                                        type: "string",
+                                        description: "Optional: Product description",
+                                    },
+                                    imageUrl: {
+                                        type: "string",
+                                        description: "Product image URL",
+                                    },
+                                    quantity: {
+                                        type: "integer",
+                                        description: "Quantity (must be >= 1)",
+                                        minimum: 1,
+                                    },
+                                    basePriceAmount: {
+                                        type: "integer",
+                                        description: "Base price per unit in minor currency units (e.g., cents)",
+                                        minimum: 0,
+                                    },
+                                    salePriceAmount: {
+                                        type: "integer",
+                                        description: "Sale price per unit in minor currency units (must be <= basePriceAmount)",
+                                        minimum: 0,
+                                    },
+                                    taxPercentage: {
+                                        type: "integer",
+                                        description: "Tax percentage in basis points",
+                                    },
+                                    taxPercentageDecimals: {
+                                        type: "integer",
+                                        description: "Number of decimals in tax percentage (2 or 3)",
+                                        minimum: 2,
+                                        maximum: 3,
+                                    },
+                                },
+                                required: ["id", "name", "imageUrl", "quantity", "basePriceAmount", "salePriceAmount", "taxPercentage", "taxPercentageDecimals"],
+                            },
+                        },
+                        shippingFees: {
+                            type: "array",
+                            description: "Optional: Shipping fees",
+                        },
+                        gifts: {
+                            type: "array",
+                            description: "Optional: Order gifts",
+                        },
+                        totals: {
+                            type: "object",
+                            description: "Optional: Order totals",
+                        },
+                    },
+                    required: ["importId", "countryCode", "languageCode", "currencyCode", "channelType", "isTaxIncludedInPrice", "isTaxExemptionEligible", "isTaxExempt", "taxationCountry", "payment", "shippingAddress", "billingAddress", "orderLines"],
+                },
+            },
+            required: ["importId", "request"],
+        },
+        annotations: writeAnnotations,
+    },
+    get_imported_order: {
+        name: "get_imported_order",
+        description: "Get an imported order by import ID from BrinkCommerce. Returns the complete order information for an order that was previously imported using the import_order tool.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                importId: {
+                    type: "string",
+                    description: "The import ID that was used when importing the order",
+                },
+            },
+            required: ["importId"],
+        },
+        annotations: readOnlyAnnotations,
+    },
+    // ==================== DELIVERY TOOLS ====================
+    create_delivery: {
+        name: "create_delivery",
+        description: "Create a delivery for an order in BrinkCommerce. Deliveries track the fulfillment of order items. " +
+            "This operation creates a delivery record that can later be started to trigger fulfillment workflows.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                orderId: {
+                    type: "string",
+                    description: "The order ID to create delivery for (UUID format)",
+                },
+                orderLines: {
+                    type: "array",
+                    description: "Order lines to include in the delivery (at least 1 required)",
+                    minItems: 1,
+                    items: {
+                        type: "object",
+                        properties: {
+                            orderLineId: {
+                                type: "string",
+                                description: "The order line ID (UUID format)",
+                            },
+                            quantity: {
+                                type: "integer",
+                                description: "Quantity to deliver (must be >= 1)",
+                                minimum: 1,
+                            },
+                        },
+                        required: ["orderLineId", "quantity"],
+                    },
+                },
+                shippingFees: {
+                    type: "array",
+                    description: "Optional: Shipping fee IDs to include in delivery",
+                    items: {
+                        type: "string",
+                        description: "Shipping fee ID (UUID format)",
+                    },
+                },
+                gifts: {
+                    type: "array",
+                    description: "Optional: Order gifts to include in delivery",
+                    items: {
+                        type: "object",
+                        properties: {
+                            giftId: {
+                                type: "string",
+                                description: "Gift ID (UUID format)",
+                            },
+                            quantity: {
+                                type: "integer",
+                                description: "Quantity to deliver (must be >= 1)",
+                                minimum: 1,
+                            },
+                        },
+                        required: ["giftId", "quantity"],
+                    },
+                },
+                giftCardProducts: {
+                    type: "array",
+                    description: "Optional: Gift card products to include in delivery",
+                    items: {
+                        type: "object",
+                        properties: {
+                            giftCardProductId: {
+                                type: "string",
+                                description: "Gift card product ID (UUID format)",
+                            },
+                        },
+                        required: ["giftCardProductId"],
+                    },
+                },
+            },
+            required: ["orderId", "orderLines"],
+        },
+        annotations: writeAnnotations,
+    },
+    get_delivery: {
+        name: "get_delivery",
+        description: "Retrieve delivery details by delivery ID from BrinkCommerce. Returns complete delivery information including items, status, and tracking data.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                deliveryId: {
+                    type: "string",
+                    description: "The delivery ID to retrieve (UUID format)",
+                },
+            },
+            required: ["deliveryId"],
+        },
+        annotations: readOnlyAnnotations,
+    },
+    update_delivery: {
+        name: "update_delivery",
+        description: "Update a delivery in BrinkCommerce. Allows modifying delivery contents before it has been started. " +
+            "Cannot update a delivery that has already been started.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                deliveryId: {
+                    type: "string",
+                    description: "The delivery ID to update (UUID format)",
+                },
+                orderLines: {
+                    type: "array",
+                    description: "Updated order lines for the delivery (at least 1 required)",
+                    minItems: 1,
+                    items: {
+                        type: "object",
+                        properties: {
+                            orderLineId: {
+                                type: "string",
+                                description: "The order line ID (UUID format)",
+                            },
+                            quantity: {
+                                type: "integer",
+                                description: "Quantity to deliver (must be >= 1)",
+                                minimum: 1,
+                            },
+                        },
+                        required: ["orderLineId", "quantity"],
+                    },
+                },
+                shippingFees: {
+                    type: "array",
+                    description: "Optional: Updated shipping fee IDs",
+                    items: {
+                        type: "string",
+                        description: "Shipping fee ID (UUID format)",
+                    },
+                },
+                gifts: {
+                    type: "array",
+                    description: "Optional: Updated order gifts",
+                    items: {
+                        type: "object",
+                        properties: {
+                            giftId: {
+                                type: "string",
+                                description: "Gift ID (UUID format)",
+                            },
+                            quantity: {
+                                type: "integer",
+                                description: "Quantity to deliver (must be >= 1)",
+                                minimum: 1,
+                            },
+                        },
+                        required: ["giftId", "quantity"],
+                    },
+                },
+                giftCardProducts: {
+                    type: "array",
+                    description: "Optional: Updated gift card products",
+                    items: {
+                        type: "object",
+                        properties: {
+                            giftCardProductId: {
+                                type: "string",
+                                description: "Gift card product ID (UUID format)",
+                            },
+                        },
+                        required: ["giftCardProductId"],
+                    },
+                },
+            },
+            required: ["deliveryId", "orderLines"],
+        },
+        annotations: writeAnnotations,
+    },
+    delete_delivery: {
+        name: "delete_delivery",
+        description: "Delete a delivery in BrinkCommerce. Can only delete deliveries that have not been started. " +
+            "WHY CONFIRMATION MATTERS: Deleting deliveries affects fulfillment workflows and inventory reservations. " +
+            "This operation cannot be undone.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                deliveryId: {
+                    type: "string",
+                    description: "The delivery ID to delete (UUID format)",
+                },
+            },
+            required: ["deliveryId"],
+        },
+        annotations: destructiveAnnotations,
+    },
+    start_delivery: {
+        name: "start_delivery",
+        description: "Start a delivery in BrinkCommerce. This triggers the fulfillment workflow and notifies shipping providers. " +
+            "Once started, the delivery cannot be modified or deleted. " +
+            "By default, all actions (payment capture, shipping notification, etc.) are handled automatically. " +
+            "Use the action parameters to skip or manually handle specific actions.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                deliveryId: {
+                    type: "string",
+                    description: "The delivery ID to start (UUID format)",
+                },
+                reasonCode: {
+                    type: "string",
+                    description: "Optional reason code for the delivery (max 100 characters)",
+                },
+                reasonCause: {
+                    type: "string",
+                    description: "Optional human-readable cause for the delivery (max 300 characters)",
+                },
+                paymentAction: {
+                    type: "string",
+                    enum: ["AUTO", "MANUAL", "SKIP"],
+                    description: "How to handle payment capture. AUTO (default): capture via payment provider. " +
+                        "MANUAL: provide captureReference. SKIP: don't capture payment.",
+                },
+                captureReference: {
+                    type: "string",
+                    description: "Required when paymentAction is MANUAL. The external capture reference.",
+                },
+                shippingAction: {
+                    type: "string",
+                    enum: ["AUTO", "MANUAL", "SKIP"],
+                    description: "How to handle shipping notification. AUTO (default): notify via shipping provider. " +
+                        "MANUAL: provide tracking details. SKIP: don't notify shipping provider.",
+                },
+                trackingReference: {
+                    type: "string",
+                    description: "Required when shippingAction is MANUAL. The tracking reference/number.",
+                },
+                trackingUrl: {
+                    type: "string",
+                    description: "Required when shippingAction is MANUAL. URL to track the shipment.",
+                },
+                shippingMethod: {
+                    type: "string",
+                    description: "Required when shippingAction is MANUAL. The shipping method name.",
+                },
+                shippingCompany: {
+                    type: "string",
+                    description: "Optional when shippingAction is MANUAL. The shipping company name.",
+                },
+                giftCardAction: {
+                    type: "string",
+                    enum: ["AUTO", "MANUAL", "SKIP"],
+                    description: "How to handle gift card redemption. AUTO (default): redeem via gift card provider. " +
+                        "MANUAL: provide gift card details. SKIP: don't redeem gift cards.",
+                },
+                bonusAction: {
+                    type: "string",
+                    enum: ["AUTO", "MANUAL", "SKIP"],
+                    description: "How to handle bonus point redemption. AUTO (default): redeem via bonus provider. " +
+                        "MANUAL: provide transactionId. SKIP: don't redeem bonus points.",
+                },
+                bonusTransactionId: {
+                    type: "string",
+                    description: "Required when bonusAction is MANUAL. The bonus transaction ID.",
+                },
+            },
+            required: ["deliveryId"],
+        },
+        annotations: writeAnnotations,
+    },
+    restart_delivery: {
+        name: "restart_delivery",
+        description: "Restart a failed delivery in BrinkCommerce. Use this when a delivery has failed and needs to be retried. " +
+            "This will re-trigger the fulfillment workflow.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                deliveryId: {
+                    type: "string",
+                    description: "The delivery ID to restart (UUID format)",
+                },
+            },
+            required: ["deliveryId"],
+        },
+        annotations: writeAnnotations,
+    },
+    // ==================== CANCELLATION TOOLS ====================
+    get_cancellation: {
+        name: "get_cancellation",
+        description: "Retrieve cancellation details by cancellation ID from BrinkCommerce. Returns complete cancellation information including status and reason.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                cancellationId: {
+                    type: "string",
+                    description: "The cancellation ID to retrieve (UUID format)",
+                },
+            },
+            required: ["cancellationId"],
+        },
+        annotations: readOnlyAnnotations,
+    },
+    delete_cancellation: {
+        name: "delete_cancellation",
+        description: "Delete a cancellation in BrinkCommerce. Can only delete cancellations that have not been started. " +
+            "WHY CONFIRMATION MATTERS: Deleting cancellations affects order status and inventory reservations. " +
+            "This operation cannot be undone.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                cancellationId: {
+                    type: "string",
+                    description: "The cancellation ID to delete (UUID format)",
+                },
+            },
+            required: ["cancellationId"],
+        },
+        annotations: destructiveAnnotations,
+    },
+    start_cancellation: {
+        name: "start_cancellation",
+        description: "Start a cancellation in BrinkCommerce. This triggers the cancellation workflow, releases inventory, and may process payment reversals. " +
+            "Once started, the cancellation cannot be deleted. " +
+            "By default, all actions (payment release, gift card release, etc.) are handled automatically. " +
+            "Use the action parameters to skip or manually handle specific actions.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                cancellationId: {
+                    type: "string",
+                    description: "The cancellation ID to start (UUID format)",
+                },
+                paymentAction: {
+                    type: "string",
+                    enum: ["AUTO", "MANUAL", "SKIP"],
+                    description: "How to handle payment release. AUTO (default): release via payment provider. " +
+                        "MANUAL: handle payment release externally. SKIP: don't release payment.",
+                },
+                giftCardAction: {
+                    type: "string",
+                    enum: ["AUTO", "MANUAL", "SKIP"],
+                    description: "How to handle gift card release. AUTO (default): release via gift card provider. " +
+                        "MANUAL: handle gift card release externally. SKIP: don't release gift cards.",
+                },
+                giftCardProductAction: {
+                    type: "string",
+                    enum: ["AUTO", "MANUAL", "SKIP"],
+                    description: "How to handle gift card product release. AUTO (default): release via provider. " +
+                        "MANUAL: handle externally. SKIP: don't release gift card products.",
+                },
+                bonusAction: {
+                    type: "string",
+                    enum: ["AUTO", "MANUAL", "SKIP"],
+                    description: "How to handle bonus point release. AUTO (default): release via bonus provider. " +
+                        "MANUAL: handle bonus release externally. SKIP: don't release bonus points.",
+                },
+            },
+            required: ["cancellationId"],
+        },
+        annotations: writeAnnotations,
+    },
+    restart_cancellation: {
+        name: "restart_cancellation",
+        description: "Restart a failed cancellation in BrinkCommerce. Use this when a cancellation has failed and needs to be retried. " +
+            "This will re-trigger the cancellation workflow. " +
+            "Use the action parameters to control how each provider action is handled.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                cancellationId: {
+                    type: "string",
+                    description: "The cancellation ID to restart (UUID format)",
+                },
+                paymentAction: {
+                    type: "string",
+                    enum: ["AUTO", "MANUAL", "SKIP"],
+                    description: "How to handle payment release. AUTO (default): release via payment provider. " +
+                        "MANUAL: handle payment release externally. SKIP: don't release payment.",
+                },
+                giftCardAction: {
+                    type: "string",
+                    enum: ["AUTO", "MANUAL", "SKIP"],
+                    description: "How to handle gift card release. AUTO (default): release via gift card provider. " +
+                        "MANUAL: handle gift card release externally. SKIP: don't release gift cards.",
+                },
+                giftCardProductAction: {
+                    type: "string",
+                    enum: ["AUTO", "MANUAL", "SKIP"],
+                    description: "How to handle gift card product release. AUTO (default): release via provider. " +
+                        "MANUAL: handle externally. SKIP: don't release gift card products.",
+                },
+                bonusAction: {
+                    type: "string",
+                    enum: ["AUTO", "MANUAL", "SKIP"],
+                    description: "How to handle bonus point release. AUTO (default): release via bonus provider. " +
+                        "MANUAL: handle bonus release externally. SKIP: don't release bonus points.",
+                },
+            },
+            required: ["cancellationId"],
+        },
+        annotations: writeAnnotations,
+    },
+    // ==================== REFUND TOOLS ====================
+    get_refund: {
+        name: "get_refund",
+        description: "Retrieve refund details by refund ID from BrinkCommerce. Returns complete refund information including status, amount, and payment details.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                refundId: {
+                    type: "string",
+                    description: "The refund ID to retrieve (UUID format)",
+                },
+            },
+            required: ["refundId"],
+        },
+        annotations: readOnlyAnnotations,
+    },
+    update_refund: {
+        name: "update_refund",
+        description: "Update a refund in BrinkCommerce. Allows modifying refund contents before it has been started. " +
+            "Cannot update a refund that has already been started.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                refundId: {
+                    type: "string",
+                    description: "The refund ID to update (UUID format)",
+                },
+                orderLines: {
+                    type: "array",
+                    description: "Optional: Updated order lines to refund",
+                    items: {
+                        type: "object",
+                        properties: {
+                            orderLineId: {
+                                type: "string",
+                                description: "The order line ID (UUID format)",
+                            },
+                            quantity: {
+                                type: "integer",
+                                description: "Quantity to refund (must be >= 1)",
+                                minimum: 1,
+                            },
+                            reason: {
+                                type: "object",
+                                description: "Optional reason specific to this order line",
+                                properties: {
+                                    code: {
+                                        type: "string",
+                                        description: "Reason code (max 100 characters)",
+                                    },
+                                    cause: {
+                                        type: "string",
+                                        description: "Human-readable cause (max 300 characters)",
+                                    },
+                                },
+                            },
+                        },
+                        required: ["orderLineId", "quantity"],
+                    },
+                },
+                shippingFees: {
+                    type: "array",
+                    description: "Optional: Updated shipping fee IDs to refund",
+                    items: {
+                        type: "string",
+                        description: "Shipping fee ID (UUID format)",
+                    },
+                },
+                gifts: {
+                    type: "array",
+                    description: "Optional: Updated order gifts to refund",
+                    items: {
+                        type: "object",
+                        properties: {
+                            giftId: {
+                                type: "string",
+                                description: "Gift ID (UUID format)",
+                            },
+                            quantity: {
+                                type: "integer",
+                                description: "Quantity to refund (must be >= 1)",
+                                minimum: 1,
+                            },
+                        },
+                        required: ["giftId", "quantity"],
+                    },
+                },
+                giftCardProducts: {
+                    type: "array",
+                    description: "Optional: Updated gift card products to refund",
+                    items: {
+                        type: "object",
+                        properties: {
+                            giftCardProductId: {
+                                type: "string",
+                                description: "Gift card product ID (UUID format)",
+                            },
+                        },
+                        required: ["giftCardProductId"],
+                    },
+                },
+                fee: {
+                    type: "object",
+                    description: "Optional updated refund fee. Only applies to amount sent to payment provider (not gift cards or bonus points). " +
+                        "Supported by: Adyen, KlarnaCheckout, WalleyCheckout.",
+                    properties: {
+                        name: {
+                            type: "string",
+                            description: "Descriptive name for the refund fee",
+                        },
+                        taxPercentage: {
+                            type: "integer",
+                            description: "Tax percentage in basis points. Range: 0-100000.",
+                            minimum: 0,
+                            maximum: 100000,
+                        },
+                        taxPercentageDecimals: {
+                            type: "integer",
+                            description: "Number of decimals in tax percentage (2 or 3). Default: 2",
+                            minimum: 2,
+                            maximum: 3,
+                            default: 2,
+                        },
+                        amount: {
+                            type: "integer",
+                            description: "Refund fee amount in minor currency units. Must be >= 1.",
+                            minimum: 1,
+                        },
+                    },
+                    required: ["name", "taxPercentage", "amount"],
+                },
+                reason: {
+                    type: "object",
+                    description: "Optional updated reason for the refund",
+                    properties: {
+                        code: {
+                            type: "string",
+                            description: "Optional code for the reason (max 100 characters)",
+                        },
+                        cause: {
+                            type: "string",
+                            description: "Optional human-readable cause (max 300 characters)",
+                        },
+                    },
+                },
+            },
+            required: ["refundId"],
+        },
+        annotations: writeAnnotations,
+    },
+    delete_refund: {
+        name: "delete_refund",
+        description: "Delete a refund in BrinkCommerce. Can only delete refunds that have not been started. " +
+            "WHY CONFIRMATION MATTERS: Deleting refunds affects financial records and payment provider balances. " +
+            "This operation cannot be undone.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                refundId: {
+                    type: "string",
+                    description: "The refund ID to delete (UUID format)",
+                },
+            },
+            required: ["refundId"],
+        },
+        annotations: destructiveAnnotations,
+    },
+    start_refund: {
+        name: "start_refund",
+        description: "Start a refund in BrinkCommerce. This triggers the refund workflow and processes payment reversals with the payment provider. " +
+            "Once started, the refund cannot be modified or deleted. " +
+            "By default, all actions (payment refund, gift card refund, etc.) are handled automatically. " +
+            "Use the action parameters to skip or manually handle specific actions.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                refundId: {
+                    type: "string",
+                    description: "The refund ID to start (UUID format)",
+                },
+                paymentAction: {
+                    type: "string",
+                    enum: ["AUTO", "MANUAL", "SKIP"],
+                    description: "How to handle payment refund. AUTO (default): refund via payment provider. " +
+                        "MANUAL: handle payment refund externally. SKIP: don't refund payment.",
+                },
+                giftCardAction: {
+                    type: "string",
+                    enum: ["AUTO", "MANUAL", "SKIP"],
+                    description: "How to handle gift card refund. AUTO (default): refund via gift card provider. " +
+                        "MANUAL: handle gift card refund externally. SKIP: don't refund gift cards.",
+                },
+                giftCardProductAction: {
+                    type: "string",
+                    enum: ["AUTO", "MANUAL", "SKIP"],
+                    description: "How to handle gift card product refund. AUTO (default): refund via provider. " +
+                        "MANUAL: handle externally. SKIP: don't refund gift card products.",
+                },
+                bonusAction: {
+                    type: "string",
+                    enum: ["AUTO", "MANUAL", "SKIP"],
+                    description: "How to handle bonus point refund. AUTO (default): refund via bonus provider. " +
+                        "MANUAL: handle bonus refund externally. SKIP: don't refund bonus points.",
+                },
+            },
+            required: ["refundId"],
+        },
+        annotations: writeAnnotations,
+    },
+    restart_refund: {
+        name: "restart_refund",
+        description: "Restart a failed refund in BrinkCommerce. Use this when a refund has failed and needs to be retried. " +
+            "This will re-trigger the refund workflow and payment reversal. " +
+            "Use the action parameters to control how each provider action is handled.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                refundId: {
+                    type: "string",
+                    description: "The refund ID to restart (UUID format)",
+                },
+                paymentAction: {
+                    type: "string",
+                    enum: ["AUTO", "MANUAL", "SKIP"],
+                    description: "How to handle payment refund. AUTO (default): refund via payment provider. " +
+                        "MANUAL: handle payment refund externally. SKIP: don't refund payment.",
+                },
+                giftCardAction: {
+                    type: "string",
+                    enum: ["AUTO", "MANUAL", "SKIP"],
+                    description: "How to handle gift card refund. AUTO (default): refund via gift card provider. " +
+                        "MANUAL: handle gift card refund externally. SKIP: don't refund gift cards.",
+                },
+                giftCardProductAction: {
+                    type: "string",
+                    enum: ["AUTO", "MANUAL", "SKIP"],
+                    description: "How to handle gift card product refund. AUTO (default): refund via provider. " +
+                        "MANUAL: handle externally. SKIP: don't refund gift card products.",
+                },
+                bonusAction: {
+                    type: "string",
+                    enum: ["AUTO", "MANUAL", "SKIP"],
+                    description: "How to handle bonus point refund. AUTO (default): refund via bonus provider. " +
+                        "MANUAL: handle bonus refund externally. SKIP: don't refund bonus points.",
+                },
+            },
+            required: ["refundId"],
+        },
+        annotations: writeAnnotations,
+    },
+    // ==================== RELEASE TOOLS ====================
+    create_release: {
+        name: "create_release",
+        description: "Create a release for an order in BrinkCommerce. Releases free up inventory without canceling the order. " +
+            "Use this when you need to release inventory reservations but keep the order active.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                orderId: {
+                    type: "string",
+                    description: "The order ID to create release for (UUID format)",
+                },
+                orderLines: {
+                    type: "array",
+                    description: "Order lines to release (at least 1 required)",
+                    minItems: 1,
+                    items: {
+                        type: "object",
+                        properties: {
+                            orderLineId: {
+                                type: "string",
+                                description: "The order line ID (UUID format)",
+                            },
+                            quantity: {
+                                type: "integer",
+                                description: "Quantity to release (must be >= 1)",
+                                minimum: 1,
+                            },
+                        },
+                        required: ["orderLineId", "quantity"],
+                    },
+                },
+                gifts: {
+                    type: "array",
+                    description: "Optional: Order gifts to release",
+                    items: {
+                        type: "object",
+                        properties: {
+                            giftId: {
+                                type: "string",
+                                description: "Gift ID (UUID format)",
+                            },
+                            quantity: {
+                                type: "integer",
+                                description: "Quantity to release (must be >= 1)",
+                                minimum: 1,
+                            },
+                        },
+                        required: ["giftId", "quantity"],
+                    },
+                },
+                reason: {
+                    type: "object",
+                    description: "Optional reason for the release",
+                    properties: {
+                        code: {
+                            type: "string",
+                            description: "Optional code for the reason (max 100 characters)",
+                        },
+                        cause: {
+                            type: "string",
+                            description: "Optional human-readable cause (max 300 characters)",
+                        },
+                    },
+                },
+            },
+            required: ["orderId", "orderLines"],
+        },
+        annotations: writeAnnotations,
+    },
+    get_release: {
+        name: "get_release",
+        description: "Retrieve release details by release ID from BrinkCommerce. Returns complete release information including items and status.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                releaseId: {
+                    type: "string",
+                    description: "The release ID to retrieve (UUID format)",
+                },
+            },
+            required: ["releaseId"],
+        },
+        annotations: readOnlyAnnotations,
+    },
+    delete_release: {
+        name: "delete_release",
+        description: "Delete a release in BrinkCommerce. Can only delete releases that have not been started. " +
+            "WHY CONFIRMATION MATTERS: Deleting releases affects inventory reservations. " +
+            "This operation cannot be undone.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                releaseId: {
+                    type: "string",
+                    description: "The release ID to delete (UUID format)",
+                },
+            },
+            required: ["releaseId"],
+        },
+        annotations: destructiveAnnotations,
+    },
+    start_release: {
+        name: "start_release",
+        description: "Start a release in BrinkCommerce. This triggers the release workflow and frees up inventory reservations. " +
+            "Once started, the release cannot be deleted. " +
+            "By default, all actions (payment release, gift card release, etc.) are handled automatically. " +
+            "Use the action parameters to skip or manually handle specific actions.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                releaseId: {
+                    type: "string",
+                    description: "The release ID to start (UUID format)",
+                },
+                paymentAction: {
+                    type: "string",
+                    enum: ["AUTO", "MANUAL", "SKIP"],
+                    description: "How to handle payment release. AUTO (default): release via payment provider. " +
+                        "MANUAL: handle payment release externally. SKIP: don't release payment.",
+                },
+                giftCardAction: {
+                    type: "string",
+                    enum: ["AUTO", "MANUAL", "SKIP"],
+                    description: "How to handle gift card release. AUTO (default): release via gift card provider. " +
+                        "MANUAL: handle gift card release externally. SKIP: don't release gift cards.",
+                },
+                giftCardProductAction: {
+                    type: "string",
+                    enum: ["AUTO", "MANUAL", "SKIP"],
+                    description: "How to handle gift card product release. AUTO (default): release via provider. " +
+                        "MANUAL: handle externally. SKIP: don't release gift card products.",
+                },
+                bonusAction: {
+                    type: "string",
+                    enum: ["AUTO", "MANUAL", "SKIP"],
+                    description: "How to handle bonus point release. AUTO (default): release via bonus provider. " +
+                        "MANUAL: handle bonus release externally. SKIP: don't release bonus points.",
+                },
+            },
+            required: ["releaseId"],
+        },
+        annotations: writeAnnotations,
+    },
+    restart_release: {
+        name: "restart_release",
+        description: "Restart a failed release in BrinkCommerce. Use this when a release has failed and needs to be retried. " +
+            "This will re-trigger the release workflow. " +
+            "Use the action parameters to control how each provider action is handled.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                releaseId: {
+                    type: "string",
+                    description: "The release ID to restart (UUID format)",
+                },
+                paymentAction: {
+                    type: "string",
+                    enum: ["AUTO", "MANUAL", "SKIP"],
+                    description: "How to handle payment release. AUTO (default): release via payment provider. " +
+                        "MANUAL: handle payment release externally. SKIP: don't release payment.",
+                },
+                giftCardAction: {
+                    type: "string",
+                    enum: ["AUTO", "MANUAL", "SKIP"],
+                    description: "How to handle gift card release. AUTO (default): release via gift card provider. " +
+                        "MANUAL: handle gift card release externally. SKIP: don't release gift cards.",
+                },
+                giftCardProductAction: {
+                    type: "string",
+                    enum: ["AUTO", "MANUAL", "SKIP"],
+                    description: "How to handle gift card product release. AUTO (default): release via provider. " +
+                        "MANUAL: handle externally. SKIP: don't release gift card products.",
+                },
+                bonusAction: {
+                    type: "string",
+                    enum: ["AUTO", "MANUAL", "SKIP"],
+                    description: "How to handle bonus point release. AUTO (default): release via bonus provider. " +
+                        "MANUAL: handle bonus release externally. SKIP: don't release bonus points.",
+                },
+            },
+            required: ["releaseId"],
+        },
+        annotations: writeAnnotations,
+    },
+};
+/**
+ * Handle get_order tool call
+ */
+export async function handleGetOrder(params) {
+    try {
+        logger.info("Handling get_order tool call", {
+            orderId: params.orderId,
+        });
+        // Validate required parameters
+        if (!params.orderId) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: "Error: Missing required field 'orderId'",
+                    },
+                ],
+                isError: true,
+            };
+        }
+        const orderId = params.orderId;
+        // Create API client
+        const client = createOrderManagementClient();
+        // Call API
+        const result = await client.getOrder(orderId);
+        if (result.success && result.data) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: formatOrderResponse(result.data),
+                    },
+                ],
+            };
+        }
+        else {
+            let errorText = `Failed to get order: ${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 handleGetOrder", { error });
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Unexpected error: ${error instanceof Error ? error.message : "Unknown error"}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+}
+/**
+ * Handle get_order_by_reference tool call
+ */
+export async function handleGetOrderByReference(params) {
+    try {
+        logger.info("Handling get_order_by_reference tool call", {
+            reference: params.reference,
+        });
+        // Validate required parameters
+        if (!params.reference) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: "Error: Missing required field 'reference'",
+                    },
+                ],
+                isError: true,
+            };
+        }
+        const reference = params.reference;
+        // Create API client
+        const client = createOrderManagementClient();
+        // Call API
+        const result = await client.getOrderByReference(reference);
+        if (result.success && result.data) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: formatOrderResponse(result.data),
+                    },
+                ],
+            };
+        }
+        else {
+            let errorText = `Failed to get order by reference: ${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 handleGetOrderByReference", { error });
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Unexpected error: ${error instanceof Error ? error.message : "Unknown error"}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+}
+/**
+ * Handle cancel_order tool call
+ */
+export async function handleCancelOrder(params) {
+    try {
+        logger.info("Handling cancel_order tool call", {
+            orderId: params.orderId,
+        });
+        // Validate required parameters
+        if (!params.orderId) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: "Error: Missing required field 'orderId'",
+                    },
+                ],
+                isError: true,
+            };
+        }
+        const orderId = params.orderId;
+        // Create API client
+        const client = createOrderManagementClient();
+        // Build cancellation request
+        const request = {};
+        if (params.reason) {
+            request.reason = params.reason;
+        }
+        // Call API
+        const result = await client.cancelOrder(orderId, request);
+        if (result.success) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Successfully created cancellation for order: ${orderId}\n\nThe cancellation has been initiated and will be processed by the system.`,
+                    },
+                ],
+            };
+        }
+        else {
+            let errorText = `Failed to cancel order: ${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 handleCancelOrder", { error });
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Unexpected error: ${error instanceof Error ? error.message : "Unknown error"}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+}
+/**
+ * Handle refund_order tool call
+ */
+export async function handleRefundOrder(params) {
+    try {
+        logger.info("Handling refund_order tool call", {
+            orderId: params.orderId,
+        });
+        // Validate required parameters
+        if (!params.orderId) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: "Error: Missing required field 'orderId'",
+                    },
+                ],
+                isError: true,
+            };
+        }
+        const orderId = params.orderId;
+        // Validate complex request objects
+        if (params.orderLines && params.orderLines.length > 0) {
+            const orderLinesError = validateOrderLines(params.orderLines);
+            if (orderLinesError) {
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: orderLinesError,
+                        },
+                    ],
+                    isError: true,
+                };
+            }
+        }
+        if (params.gifts && params.gifts.length > 0) {
+            const giftsError = validateGifts(params.gifts);
+            if (giftsError) {
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: giftsError,
+                        },
+                    ],
+                    isError: true,
+                };
+            }
+        }
+        if (params.fee) {
+            const feeError = validateRefundFee(params.fee);
+            if (feeError) {
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: feeError,
+                        },
+                    ],
+                    isError: true,
+                };
+            }
+        }
+        // Create API client
+        const client = createOrderManagementClient();
+        // Build refund request
+        // Note: The generated types expect Set<string> for shippingFees, but we accept arrays for simpler API
+        const request = {};
+        if (params.reason) {
+            request.reason = params.reason;
+        }
+        if (params.orderLines) {
+            request.orderLines = params.orderLines;
+        }
+        if (params.shippingFees) {
+            // Convert array to Set as expected by the generated API
+            request.shippingFees = new Set(params.shippingFees);
+        }
+        if (params.gifts) {
+            request.gifts = params.gifts;
+        }
+        if (params.giftCardProducts) {
+            request.giftCardProducts = params.giftCardProducts;
+        }
+        if (params.fee) {
+            request.fee = params.fee;
+        }
+        // Call API
+        const result = await client.refundOrder(orderId, request);
+        if (result.success) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Successfully created refund for order: ${orderId}\n\nThe refund has been initiated and will be processed by the system.`,
+                    },
+                ],
+            };
+        }
+        else {
+            let errorText = `Failed to refund order: ${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 handleRefundOrder", { error });
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Unexpected error: ${error instanceof Error ? error.message : "Unknown error"}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+}
+/**
+ * Handle import_order tool call
+ */
+export async function handleImportOrder(params) {
+    try {
+        logger.info("Handling import_order tool call", {
+            importId: params.importId,
+        });
+        // Validate required parameters
+        if (!params.importId) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: "Error: Missing required field 'importId'",
+                    },
+                ],
+                isError: true,
+            };
+        }
+        if (!params.request) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: "Error: Missing required field 'request'",
+                    },
+                ],
+                isError: true,
+            };
+        }
+        const importId = params.importId;
+        const request = params.request;
+        // Validate import order request
+        const validationError = validateImportOrderRequest(request);
+        if (validationError) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: validationError,
+                    },
+                ],
+                isError: true,
+            };
+        }
+        // Ensure request.importId matches the top-level importId
+        if (request.importId !== importId) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Error: request.importId ('${request.importId}') must match the top-level importId parameter ('${importId}')`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+        // Create API client
+        const client = createOrderManagementClient();
+        // Call API
+        const result = await client.importOrder(importId, request);
+        if (result.success && result.data) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Successfully imported order!\n\n` +
+                            `Import ID: ${importId}\n` +
+                            `Order ID: ${result.data.orderId}\n` +
+                            `Order Reference: ${result.data.orderReference}\n` +
+                            `Finished: ${result.data.finished}\n\n` +
+                            `The order has been successfully imported into BrinkCommerce and can now be managed using the order ID or reference.`,
+                    },
+                ],
+            };
+        }
+        else {
+            let errorText = `Failed to import order: ${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 handleImportOrder", { error });
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Unexpected error: ${error instanceof Error ? error.message : "Unknown error"}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+}
+/**
+ * Handle get_imported_order tool call
+ */
+export async function handleGetImportedOrder(params) {
+    try {
+        logger.info("Handling get_imported_order tool call", {
+            importId: params.importId,
+        });
+        // Validate required parameters
+        if (!params.importId) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: "Error: Missing required field 'importId'",
+                    },
+                ],
+                isError: true,
+            };
+        }
+        const importId = params.importId;
+        // Create API client
+        const client = createOrderManagementClient();
+        // Call API
+        const result = await client.getImportedOrder(importId);
+        if (result.success && result.data) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: formatOrderResponse(result.data),
+                    },
+                ],
+            };
+        }
+        else {
+            let errorText = `Failed to get imported order: ${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 handleGetImportedOrder", { error });
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Unexpected error: ${error instanceof Error ? error.message : "Unknown error"}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+}
+// ==================== DELIVERY HANDLERS ====================
+/**
+ * Handle create_delivery tool call
+ */
+export async function handleCreateDelivery(params) {
+    try {
+        logger.info("Handling create_delivery tool call", {
+            orderId: params.orderId,
+        });
+        // Validate required parameters
+        if (!params.orderId) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: "Error: Missing required field 'orderId'",
+                    },
+                ],
+                isError: true,
+            };
+        }
+        if (!params.orderLines || !Array.isArray(params.orderLines) || params.orderLines.length === 0) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: "Error: Missing required field 'orderLines' (must be a non-empty array)",
+                    },
+                ],
+                isError: true,
+            };
+        }
+        const orderId = params.orderId;
+        // Build delivery request from parameters
+        const deliveryRequest = {
+            orderLines: params.orderLines,
+        };
+        if (params.shippingFees) {
+            deliveryRequest.shippingFees = new Set(params.shippingFees);
+        }
+        if (params.gifts) {
+            deliveryRequest.gifts = params.gifts;
+        }
+        if (params.giftCardProducts) {
+            deliveryRequest.giftCardProducts = params.giftCardProducts;
+        }
+        // Create API client
+        const client = createOrderManagementClient();
+        // Call API
+        const result = await client.createDelivery(orderId, deliveryRequest);
+        if (result.success && result.data) {
+            const delivery = result.data;
+            let responseText = `Successfully created delivery\n\n`;
+            responseText += `Delivery ID: ${delivery.id}\n`;
+            responseText += `Order ID: ${orderId}\n`;
+            responseText += `\n\nFull response:\n${JSON.stringify(delivery, null, 2)}`;
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: responseText,
+                    },
+                ],
+            };
+        }
+        else {
+            let errorText = `Failed to create delivery: ${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 handleCreateDelivery", { error });
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Unexpected error: ${error instanceof Error ? error.message : "Unknown error"}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+}
+/**
+ * Handle get_delivery tool call
+ */
+export async function handleGetDelivery(params) {
+    try {
+        logger.info("Handling get_delivery tool call", {
+            deliveryId: params.deliveryId,
+        });
+        // Validate required parameters
+        if (!params.deliveryId) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: "Error: Missing required field 'deliveryId'",
+                    },
+                ],
+                isError: true,
+            };
+        }
+        const deliveryId = params.deliveryId;
+        // Create API client
+        const client = createOrderManagementClient();
+        // Call API
+        const result = await client.getDelivery(deliveryId);
+        if (result.success && result.data) {
+            const delivery = result.data;
+            let responseText = `Delivery Details\n\n`;
+            responseText += `Delivery ID: ${delivery.id}\n`;
+            responseText += `\n\nFull response:\n${JSON.stringify(delivery, null, 2)}`;
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: responseText,
+                    },
+                ],
+            };
+        }
+        else {
+            let errorText = `Failed to get delivery: ${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 handleGetDelivery", { error });
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Unexpected error: ${error instanceof Error ? error.message : "Unknown error"}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+}
+/**
+ * Handle update_delivery tool call
+ */
+export async function handleUpdateDelivery(params) {
+    try {
+        logger.info("Handling update_delivery tool call", {
+            deliveryId: params.deliveryId,
+        });
+        // Validate required parameters
+        if (!params.deliveryId) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: "Error: Missing required field 'deliveryId'",
+                    },
+                ],
+                isError: true,
+            };
+        }
+        if (!params.orderLines || !Array.isArray(params.orderLines) || params.orderLines.length === 0) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: "Error: Missing required field 'orderLines' (must be a non-empty array)",
+                    },
+                ],
+                isError: true,
+            };
+        }
+        const deliveryId = params.deliveryId;
+        // Build delivery request from parameters
+        const deliveryRequest = {
+            orderLines: params.orderLines,
+        };
+        if (params.shippingFees) {
+            deliveryRequest.shippingFees = new Set(params.shippingFees);
+        }
+        if (params.gifts) {
+            deliveryRequest.gifts = params.gifts;
+        }
+        if (params.giftCardProducts) {
+            deliveryRequest.giftCardProducts = params.giftCardProducts;
+        }
+        // Create API client
+        const client = createOrderManagementClient();
+        // Call API
+        const result = await client.updateDelivery(deliveryId, deliveryRequest);
+        if (result.success && result.data) {
+            const delivery = result.data;
+            let responseText = `Successfully updated delivery\n\n`;
+            responseText += `Delivery ID: ${delivery.id}\n`;
+            responseText += `\n\nFull response:\n${JSON.stringify(delivery, null, 2)}`;
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: responseText,
+                    },
+                ],
+            };
+        }
+        else {
+            let errorText = `Failed to update delivery: ${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 handleUpdateDelivery", { error });
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Unexpected error: ${error instanceof Error ? error.message : "Unknown error"}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+}
+/**
+ * Handle delete_delivery tool call
+ */
+export async function handleDeleteDelivery(params) {
+    try {
+        logger.info("Handling delete_delivery tool call", {
+            deliveryId: params.deliveryId,
+        });
+        // Validate required parameters
+        if (!params.deliveryId) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: "Error: Missing required field 'deliveryId'",
+                    },
+                ],
+                isError: true,
+            };
+        }
+        const deliveryId = params.deliveryId;
+        // Create API client
+        const client = createOrderManagementClient();
+        // Call API
+        const result = await client.deleteDelivery(deliveryId);
+        if (result.success) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Successfully deleted delivery ${deliveryId}`,
+                    },
+                ],
+            };
+        }
+        else {
+            let errorText = `Failed to delete delivery: ${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 handleDeleteDelivery", { error });
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Unexpected error: ${error instanceof Error ? error.message : "Unknown error"}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+}
+/**
+ * Handle start_delivery tool call
+ */
+export async function handleStartDelivery(params) {
+    try {
+        logger.info("Handling start_delivery tool call", {
+            deliveryId: params.deliveryId,
+            paymentAction: params.paymentAction,
+            shippingAction: params.shippingAction,
+        });
+        // Validate required parameters
+        if (!params.deliveryId) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: "Error: Missing required field 'deliveryId'",
+                    },
+                ],
+                isError: true,
+            };
+        }
+        const deliveryId = params.deliveryId;
+        // Build options from params
+        const options = {
+            reasonCode: params.reasonCode,
+            reasonCause: params.reasonCause,
+            paymentAction: params.paymentAction,
+            captureReference: params.captureReference,
+            shippingAction: params.shippingAction,
+            trackingReference: params.trackingReference,
+            trackingUrl: params.trackingUrl,
+            shippingMethod: params.shippingMethod,
+            shippingCompany: params.shippingCompany,
+            giftCardAction: params.giftCardAction,
+            bonusAction: params.bonusAction,
+            bonusTransactionId: params.bonusTransactionId,
+        };
+        // Create API client
+        const client = createOrderManagementClient();
+        // Call API
+        const result = await client.startDelivery(deliveryId, options);
+        if (result.success) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Successfully started delivery ${deliveryId}`,
+                    },
+                ],
+            };
+        }
+        else {
+            let errorText = `Failed to start delivery: ${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 handleStartDelivery", { error });
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Unexpected error: ${error instanceof Error ? error.message : "Unknown error"}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+}
+/**
+ * Handle restart_delivery tool call
+ */
+export async function handleRestartDelivery(params) {
+    try {
+        logger.info("Handling restart_delivery tool call", {
+            deliveryId: params.deliveryId,
+            paymentAction: params.paymentAction,
+            shippingAction: params.shippingAction,
+        });
+        // Validate required parameters
+        if (!params.deliveryId) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: "Error: Missing required field 'deliveryId'",
+                    },
+                ],
+                isError: true,
+            };
+        }
+        const deliveryId = params.deliveryId;
+        // Build options from params
+        const options = {
+            reasonCode: params.reasonCode,
+            reasonCause: params.reasonCause,
+            paymentAction: params.paymentAction,
+            captureReference: params.captureReference,
+            shippingAction: params.shippingAction,
+            trackingReference: params.trackingReference,
+            trackingUrl: params.trackingUrl,
+            shippingMethod: params.shippingMethod,
+            shippingCompany: params.shippingCompany,
+            giftCardAction: params.giftCardAction,
+            bonusAction: params.bonusAction,
+            bonusTransactionId: params.bonusTransactionId,
+        };
+        // Create API client
+        const client = createOrderManagementClient();
+        // Call API
+        const result = await client.restartDelivery(deliveryId, options);
+        if (result.success) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Successfully restarted delivery ${deliveryId}`,
+                    },
+                ],
+            };
+        }
+        else {
+            let errorText = `Failed to restart delivery: ${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 handleRestartDelivery", { error });
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Unexpected error: ${error instanceof Error ? error.message : "Unknown error"}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+}
+// ==================== CANCELLATION HANDLERS ====================
+/**
+ * Handle get_cancellation tool call
+ */
+export async function handleGetCancellation(params) {
+    try {
+        logger.info("Handling get_cancellation tool call", {
+            cancellationId: params.cancellationId,
+        });
+        // Validate required parameters
+        if (!params.cancellationId) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: "Error: Missing required field 'cancellationId'",
+                    },
+                ],
+                isError: true,
+            };
+        }
+        const cancellationId = params.cancellationId;
+        // Create API client
+        const client = createOrderManagementClient();
+        // Call API
+        const result = await client.getCancellation(cancellationId);
+        if (result.success && result.data) {
+            const cancellation = result.data;
+            let responseText = `Cancellation Details\n\n`;
+            responseText += `Cancellation ID: ${cancellation.id}\n`;
+            responseText += `\n\nFull response:\n${JSON.stringify(cancellation, null, 2)}`;
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: responseText,
+                    },
+                ],
+            };
+        }
+        else {
+            let errorText = `Failed to get cancellation: ${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 handleGetCancellation", { error });
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Unexpected error: ${error instanceof Error ? error.message : "Unknown error"}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+}
+/**
+ * Handle delete_cancellation tool call
+ */
+export async function handleDeleteCancellation(params) {
+    try {
+        logger.info("Handling delete_cancellation tool call", {
+            cancellationId: params.cancellationId,
+        });
+        // Validate required parameters
+        if (!params.cancellationId) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: "Error: Missing required field 'cancellationId'",
+                    },
+                ],
+                isError: true,
+            };
+        }
+        const cancellationId = params.cancellationId;
+        // Create API client
+        const client = createOrderManagementClient();
+        // Call API
+        const result = await client.deleteCancellation(cancellationId);
+        if (result.success) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Successfully deleted cancellation ${cancellationId}`,
+                    },
+                ],
+            };
+        }
+        else {
+            let errorText = `Failed to delete cancellation: ${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 handleDeleteCancellation", { error });
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Unexpected error: ${error instanceof Error ? error.message : "Unknown error"}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+}
+/**
+ * Handle start_cancellation tool call
+ */
+export async function handleStartCancellation(params) {
+    try {
+        logger.info("Handling start_cancellation tool call", {
+            cancellationId: params.cancellationId,
+            paymentAction: params.paymentAction,
+            giftCardAction: params.giftCardAction,
+            giftCardProductAction: params.giftCardProductAction,
+            bonusAction: params.bonusAction,
+        });
+        // Validate required parameters
+        if (!params.cancellationId) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: "Error: Missing required field 'cancellationId'",
+                    },
+                ],
+                isError: true,
+            };
+        }
+        const cancellationId = params.cancellationId;
+        // Build options from params
+        const options = {
+            paymentAction: params.paymentAction,
+            giftCardAction: params.giftCardAction,
+            giftCardProductAction: params.giftCardProductAction,
+            bonusAction: params.bonusAction,
+        };
+        // Create API client
+        const client = createOrderManagementClient();
+        // Call API
+        const result = await client.startCancellation(cancellationId, options);
+        if (result.success) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Successfully started cancellation ${cancellationId}`,
+                    },
+                ],
+            };
+        }
+        else {
+            let errorText = `Failed to start cancellation: ${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 handleStartCancellation", { error });
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Unexpected error: ${error instanceof Error ? error.message : "Unknown error"}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+}
+/**
+ * Handle restart_cancellation tool call
+ */
+export async function handleRestartCancellation(params) {
+    try {
+        logger.info("Handling restart_cancellation tool call", {
+            cancellationId: params.cancellationId,
+            paymentAction: params.paymentAction,
+            giftCardAction: params.giftCardAction,
+            giftCardProductAction: params.giftCardProductAction,
+            bonusAction: params.bonusAction,
+        });
+        // Validate required parameters
+        if (!params.cancellationId) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: "Error: Missing required field 'cancellationId'",
+                    },
+                ],
+                isError: true,
+            };
+        }
+        const cancellationId = params.cancellationId;
+        // Build options from params
+        const options = {
+            paymentAction: params.paymentAction,
+            giftCardAction: params.giftCardAction,
+            giftCardProductAction: params.giftCardProductAction,
+            bonusAction: params.bonusAction,
+        };
+        // Create API client
+        const client = createOrderManagementClient();
+        // Call API
+        const result = await client.restartCancellation(cancellationId, options);
+        if (result.success) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Successfully restarted cancellation ${cancellationId}`,
+                    },
+                ],
+            };
+        }
+        else {
+            let errorText = `Failed to restart cancellation: ${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 handleRestartCancellation", { error });
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Unexpected error: ${error instanceof Error ? error.message : "Unknown error"}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+}
+// ==================== REFUND HANDLERS ====================
+/**
+ * Handle get_refund tool call
+ */
+export async function handleGetRefund(params) {
+    try {
+        logger.info("Handling get_refund tool call", {
+            refundId: params.refundId,
+        });
+        // Validate required parameters
+        if (!params.refundId) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: "Error: Missing required field 'refundId'",
+                    },
+                ],
+                isError: true,
+            };
+        }
+        const refundId = params.refundId;
+        // Create API client
+        const client = createOrderManagementClient();
+        // Call API
+        const result = await client.getRefund(refundId);
+        if (result.success && result.data) {
+            const refund = result.data;
+            let responseText = `Refund Details\n\n`;
+            responseText += `Refund ID: ${refund.id}\n`;
+            responseText += `\n\nFull response:\n${JSON.stringify(refund, null, 2)}`;
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: responseText,
+                    },
+                ],
+            };
+        }
+        else {
+            let errorText = `Failed to get refund: ${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 handleGetRefund", { error });
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Unexpected error: ${error instanceof Error ? error.message : "Unknown error"}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+}
+/**
+ * Handle update_refund tool call
+ */
+export async function handleUpdateRefund(params) {
+    try {
+        logger.info("Handling update_refund tool call", {
+            refundId: params.refundId,
+        });
+        // Validate required parameters
+        if (!params.refundId) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: "Error: Missing required field 'refundId'",
+                    },
+                ],
+                isError: true,
+            };
+        }
+        const refundId = params.refundId;
+        // Build refund request from parameters
+        const refundRequest = {};
+        if (params.reason) {
+            refundRequest.reason = params.reason;
+        }
+        if (params.orderLines) {
+            refundRequest.orderLines = params.orderLines;
+        }
+        if (params.shippingFees) {
+            refundRequest.shippingFees = new Set(params.shippingFees);
+        }
+        if (params.gifts) {
+            refundRequest.gifts = params.gifts;
+        }
+        if (params.giftCardProducts) {
+            refundRequest.giftCardProducts = params.giftCardProducts;
+        }
+        if (params.fee) {
+            refundRequest.fee = params.fee;
+        }
+        // Create API client
+        const client = createOrderManagementClient();
+        // Call API
+        const result = await client.updateRefund(refundId, refundRequest);
+        if (result.success && result.data) {
+            const refund = result.data;
+            let responseText = `Successfully updated refund\n\n`;
+            responseText += `Refund ID: ${refund.id}\n`;
+            responseText += `\n\nFull response:\n${JSON.stringify(refund, null, 2)}`;
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: responseText,
+                    },
+                ],
+            };
+        }
+        else {
+            let errorText = `Failed to update refund: ${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 handleUpdateRefund", { error });
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Unexpected error: ${error instanceof Error ? error.message : "Unknown error"}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+}
+/**
+ * Handle delete_refund tool call
+ */
+export async function handleDeleteRefund(params) {
+    try {
+        logger.info("Handling delete_refund tool call", {
+            refundId: params.refundId,
+        });
+        // Validate required parameters
+        if (!params.refundId) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: "Error: Missing required field 'refundId'",
+                    },
+                ],
+                isError: true,
+            };
+        }
+        const refundId = params.refundId;
+        // Create API client
+        const client = createOrderManagementClient();
+        // Call API
+        const result = await client.deleteRefund(refundId);
+        if (result.success) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Successfully deleted refund ${refundId}`,
+                    },
+                ],
+            };
+        }
+        else {
+            let errorText = `Failed to delete refund: ${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 handleDeleteRefund", { error });
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Unexpected error: ${error instanceof Error ? error.message : "Unknown error"}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+}
+/**
+ * Handle start_refund tool call
+ */
+export async function handleStartRefund(params) {
+    try {
+        logger.info("Handling start_refund tool call", {
+            refundId: params.refundId,
+            paymentAction: params.paymentAction,
+            giftCardAction: params.giftCardAction,
+            giftCardProductAction: params.giftCardProductAction,
+            bonusAction: params.bonusAction,
+        });
+        // Validate required parameters
+        if (!params.refundId) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: "Error: Missing required field 'refundId'",
+                    },
+                ],
+                isError: true,
+            };
+        }
+        const refundId = params.refundId;
+        // Build options from params
+        const options = {
+            paymentAction: params.paymentAction,
+            giftCardAction: params.giftCardAction,
+            giftCardProductAction: params.giftCardProductAction,
+            bonusAction: params.bonusAction,
+        };
+        // Create API client
+        const client = createOrderManagementClient();
+        // Call API
+        const result = await client.startRefund(refundId, options);
+        if (result.success) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Successfully started refund ${refundId}`,
+                    },
+                ],
+            };
+        }
+        else {
+            let errorText = `Failed to start refund: ${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 handleStartRefund", { error });
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Unexpected error: ${error instanceof Error ? error.message : "Unknown error"}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+}
+/**
+ * Handle restart_refund tool call
+ */
+export async function handleRestartRefund(params) {
+    try {
+        logger.info("Handling restart_refund tool call", {
+            refundId: params.refundId,
+            paymentAction: params.paymentAction,
+            giftCardAction: params.giftCardAction,
+            giftCardProductAction: params.giftCardProductAction,
+            bonusAction: params.bonusAction,
+        });
+        // Validate required parameters
+        if (!params.refundId) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: "Error: Missing required field 'refundId'",
+                    },
+                ],
+                isError: true,
+            };
+        }
+        const refundId = params.refundId;
+        // Build options from params
+        const options = {
+            paymentAction: params.paymentAction,
+            giftCardAction: params.giftCardAction,
+            giftCardProductAction: params.giftCardProductAction,
+            bonusAction: params.bonusAction,
+        };
+        // Create API client
+        const client = createOrderManagementClient();
+        // Call API
+        const result = await client.restartRefund(refundId, options);
+        if (result.success) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Successfully restarted refund ${refundId}`,
+                    },
+                ],
+            };
+        }
+        else {
+            let errorText = `Failed to restart refund: ${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 handleRestartRefund", { error });
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Unexpected error: ${error instanceof Error ? error.message : "Unknown error"}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+}
+// ==================== RELEASE HANDLERS ====================
+/**
+ * Handle create_release tool call
+ */
+export async function handleCreateRelease(params) {
+    try {
+        logger.info("Handling create_release tool call", {
+            orderId: params.orderId,
+        });
+        // Validate required parameters
+        if (!params.orderId) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: "Error: Missing required field 'orderId'",
+                    },
+                ],
+                isError: true,
+            };
+        }
+        if (!params.orderLines || !Array.isArray(params.orderLines) || params.orderLines.length === 0) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: "Error: Missing required field 'orderLines' (must be a non-empty array)",
+                    },
+                ],
+                isError: true,
+            };
+        }
+        const orderId = params.orderId;
+        // Build release request from parameters
+        const releaseRequest = {
+            orderLines: params.orderLines,
+        };
+        if (params.gifts) {
+            releaseRequest.gifts = params.gifts;
+        }
+        // Create API client
+        const client = createOrderManagementClient();
+        // Call API
+        const result = await client.createRelease(orderId, releaseRequest);
+        if (result.success && result.data) {
+            const release = result.data;
+            let responseText = `Successfully created release\n\n`;
+            responseText += `Release ID: ${release.id}\n`;
+            responseText += `Order ID: ${orderId}\n`;
+            responseText += `\n\nFull response:\n${JSON.stringify(release, null, 2)}`;
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: responseText,
+                    },
+                ],
+            };
+        }
+        else {
+            let errorText = `Failed to create release: ${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 handleCreateRelease", { error });
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Unexpected error: ${error instanceof Error ? error.message : "Unknown error"}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+}
+/**
+ * Handle get_release tool call
+ */
+export async function handleGetRelease(params) {
+    try {
+        logger.info("Handling get_release tool call", {
+            releaseId: params.releaseId,
+        });
+        // Validate required parameters
+        if (!params.releaseId) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: "Error: Missing required field 'releaseId'",
+                    },
+                ],
+                isError: true,
+            };
+        }
+        const releaseId = params.releaseId;
+        // Create API client
+        const client = createOrderManagementClient();
+        // Call API
+        const result = await client.getRelease(releaseId);
+        if (result.success && result.data) {
+            const release = result.data;
+            let responseText = `Release Details\n\n`;
+            responseText += `Release ID: ${release.id}\n`;
+            responseText += `\n\nFull response:\n${JSON.stringify(release, null, 2)}`;
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: responseText,
+                    },
+                ],
+            };
+        }
+        else {
+            let errorText = `Failed to get release: ${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 handleGetRelease", { error });
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Unexpected error: ${error instanceof Error ? error.message : "Unknown error"}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+}
+/**
+ * Handle delete_release tool call
+ */
+export async function handleDeleteRelease(params) {
+    try {
+        logger.info("Handling delete_release tool call", {
+            releaseId: params.releaseId,
+        });
+        // Validate required parameters
+        if (!params.releaseId) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: "Error: Missing required field 'releaseId'",
+                    },
+                ],
+                isError: true,
+            };
+        }
+        const releaseId = params.releaseId;
+        // Create API client
+        const client = createOrderManagementClient();
+        // Call API
+        const result = await client.deleteRelease(releaseId);
+        if (result.success) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Successfully deleted release ${releaseId}`,
+                    },
+                ],
+            };
+        }
+        else {
+            let errorText = `Failed to delete release: ${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 handleDeleteRelease", { error });
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Unexpected error: ${error instanceof Error ? error.message : "Unknown error"}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+}
+/**
+ * Handle start_release tool call
+ */
+export async function handleStartRelease(params) {
+    try {
+        logger.info("Handling start_release tool call", {
+            releaseId: params.releaseId,
+            paymentAction: params.paymentAction,
+            giftCardAction: params.giftCardAction,
+            giftCardProductAction: params.giftCardProductAction,
+            bonusAction: params.bonusAction,
+        });
+        // Validate required parameters
+        if (!params.releaseId) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: "Error: Missing required field 'releaseId'",
+                    },
+                ],
+                isError: true,
+            };
+        }
+        const releaseId = params.releaseId;
+        // Build options from params
+        const options = {
+            paymentAction: params.paymentAction,
+            giftCardAction: params.giftCardAction,
+            giftCardProductAction: params.giftCardProductAction,
+            bonusAction: params.bonusAction,
+        };
+        // Create API client
+        const client = createOrderManagementClient();
+        // Call API
+        const result = await client.startRelease(releaseId, options);
+        if (result.success) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Successfully started release ${releaseId}`,
+                    },
+                ],
+            };
+        }
+        else {
+            let errorText = `Failed to start release: ${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 handleStartRelease", { error });
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Unexpected error: ${error instanceof Error ? error.message : "Unknown error"}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+}
+/**
+ * Handle restart_release tool call
+ */
+export async function handleRestartRelease(params) {
+    try {
+        logger.info("Handling restart_release tool call", {
+            releaseId: params.releaseId,
+            paymentAction: params.paymentAction,
+            giftCardAction: params.giftCardAction,
+            giftCardProductAction: params.giftCardProductAction,
+            bonusAction: params.bonusAction,
+        });
+        // Validate required parameters
+        if (!params.releaseId) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: "Error: Missing required field 'releaseId'",
+                    },
+                ],
+                isError: true,
+            };
+        }
+        const releaseId = params.releaseId;
+        // Build options from params
+        const options = {
+            paymentAction: params.paymentAction,
+            giftCardAction: params.giftCardAction,
+            giftCardProductAction: params.giftCardProductAction,
+            bonusAction: params.bonusAction,
+        };
+        // Create API client
+        const client = createOrderManagementClient();
+        // Call API
+        const result = await client.restartRelease(releaseId, options);
+        if (result.success) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Successfully restarted release ${releaseId}`,
+                    },
+                ],
+            };
+        }
+        else {
+            let errorText = `Failed to restart release: ${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 handleRestartRelease", { error });
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Unexpected error: ${error instanceof Error ? error.message : "Unknown error"}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+}