@open-loyalty/mcp-server 1.7.0 → 1.12.0

package/dist/tools/reward/index.d.ts

@@ -1,6 +1,12 @@
-export { RewardListInputSchema, RewardCreateInputSchema, RewardGetInputSchema, RewardUpdateInputSchema, RewardIdInputSchema, RewardBuyInputSchema, RewardRedeemInputSchema, RewardCategoryListInputSchema, } from "./schemas.js";
-export { rewardList, rewardCreate, rewardGet, rewardUpdate, rewardActivate, rewardDeactivate, rewardBuy, rewardRedeem, rewardCategoryList, } from "./handlers.js";
-import { rewardList, rewardCreate, rewardGet, rewardUpdate, rewardActivate, rewardDeactivate, rewardBuy, rewardRedeem, rewardCategoryList } from "./handlers.js";
+export { RewardListInputSchema, RewardCreateInputSchema, RewardGetInputSchema, RewardUpdateInputSchema, RewardIdInputSchema, RewardBuyInputSchema, RewardRedeemInputSchema, RewardCategoryListInputSchema, RewardCategoryCreateInputSchema, RewardCategoryUpdateInputSchema, RewardGetIssuedRewardsInputSchema, RewardPhotoUploadInputSchema, RewardPhotoDeleteInputSchema, } from "./schemas.js";
+export { rewardList, rewardCreate, rewardGet, rewardUpdate, rewardActivate, rewardDeactivate, rewardBuy, rewardRedeem, } from "./handlers.js";
+export { rewardCategoryList, rewardCategoryCreate, rewardCategoryUpdate, } from "./category-handlers.js";
+export { rewardGetIssuedRewards, } from "./redemption-handlers.js";
+export { rewardPhotoUpload, rewardPhotoDelete, } from "./photo-handlers.js";
+import { rewardList, rewardCreate, rewardGet, rewardUpdate, rewardActivate, rewardDeactivate, rewardBuy, rewardRedeem } from "./handlers.js";
+import { rewardCategoryList, rewardCategoryCreate, rewardCategoryUpdate } from "./category-handlers.js";
+import { rewardGetIssuedRewards } from "./redemption-handlers.js";
+import { rewardPhotoUpload, rewardPhotoDelete } from "./photo-handlers.js";
 export declare const rewardToolDefinitions: readonly [{
     readonly name: "ol_reward_list";
     readonly title: "Browse Rewards";
@@ -176,4 +182,71 @@ export declare const rewardToolDefinitions: readonly [{
         active: import("zod").ZodOptional<import("zod").ZodBoolean>;
     };
     readonly handler: typeof rewardCategoryList;
+}, {
+    readonly name: "ol_reward_category_create";
+    readonly title: "Create Reward Category";
+    readonly description: string;
+    readonly readOnly: false;
+    readonly idempotent: false;
+    readonly inputSchema: {
+        storeCode: import("zod").ZodOptional<import("zod").ZodString>;
+        name: import("zod").ZodString;
+        active: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        sortOrder: import("zod").ZodOptional<import("zod").ZodNumber>;
+    };
+    readonly handler: typeof rewardCategoryCreate;
+}, {
+    readonly name: "ol_reward_category_update";
+    readonly title: "Update Reward Category";
+    readonly description: string;
+    readonly readOnly: false;
+    readonly idempotent: true;
+    readonly inputSchema: {
+        storeCode: import("zod").ZodOptional<import("zod").ZodString>;
+        categoryId: import("zod").ZodString;
+        name: import("zod").ZodString;
+        active: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        sortOrder: import("zod").ZodOptional<import("zod").ZodNumber>;
+    };
+    readonly handler: typeof rewardCategoryUpdate;
+}, {
+    readonly name: "ol_member_get_issued_rewards";
+    readonly title: "Get Member's Issued Rewards";
+    readonly description: string;
+    readonly readOnly: true;
+    readonly idempotent: true;
+    readonly inputSchema: {
+        storeCode: import("zod").ZodOptional<import("zod").ZodString>;
+        memberId: import("zod").ZodString;
+        page: import("zod").ZodOptional<import("zod").ZodNumber>;
+        perPage: import("zod").ZodOptional<import("zod").ZodNumber>;
+        status: import("zod").ZodOptional<import("zod").ZodString>;
+        rewardType: import("zod").ZodOptional<import("zod").ZodString>;
+    };
+    readonly handler: typeof rewardGetIssuedRewards;
+}, {
+    readonly name: "ol_reward_photo_upload";
+    readonly title: "Upload Reward Photo";
+    readonly description: string;
+    readonly readOnly: false;
+    readonly idempotent: false;
+    readonly inputSchema: {
+        storeCode: import("zod").ZodOptional<import("zod").ZodString>;
+        rewardId: import("zod").ZodString;
+        photoUrl: import("zod").ZodString;
+    };
+    readonly handler: typeof rewardPhotoUpload;
+}, {
+    readonly name: "ol_reward_photo_delete";
+    readonly title: "Delete Reward Photo (Permanent)";
+    readonly description: string;
+    readonly readOnly: false;
+    readonly destructive: true;
+    readonly idempotent: true;
+    readonly inputSchema: {
+        storeCode: import("zod").ZodOptional<import("zod").ZodString>;
+        rewardId: import("zod").ZodString;
+        photoId: import("zod").ZodString;
+    };
+    readonly handler: typeof rewardPhotoDelete;
 }];

package/dist/tools/reward/index.js

@@ -1,10 +1,16 @@
 // Re-export schemas
-export { RewardListInputSchema, RewardCreateInputSchema, RewardGetInputSchema, RewardUpdateInputSchema, RewardIdInputSchema, RewardBuyInputSchema, RewardRedeemInputSchema, RewardCategoryListInputSchema, } from "./schemas.js";
+export { RewardListInputSchema, RewardCreateInputSchema, RewardGetInputSchema, RewardUpdateInputSchema, RewardIdInputSchema, RewardBuyInputSchema, RewardRedeemInputSchema, RewardCategoryListInputSchema, RewardCategoryCreateInputSchema, RewardCategoryUpdateInputSchema, RewardGetIssuedRewardsInputSchema, RewardPhotoUploadInputSchema, RewardPhotoDeleteInputSchema, } from "./schemas.js";
 // Re-export handlers
-export { rewardList, rewardCreate, rewardGet, rewardUpdate, rewardActivate, rewardDeactivate, rewardBuy, rewardRedeem, rewardCategoryList, } from "./handlers.js";
+export { rewardList, rewardCreate, rewardGet, rewardUpdate, rewardActivate, rewardDeactivate, rewardBuy, rewardRedeem, } from "./handlers.js";
+export { rewardCategoryList, rewardCategoryCreate, rewardCategoryUpdate, } from "./category-handlers.js";
+export { rewardGetIssuedRewards, } from "./redemption-handlers.js";
+export { rewardPhotoUpload, rewardPhotoDelete, } from "./photo-handlers.js";
 // Imports for tool definitions
-import { RewardListInputSchema, RewardCreateInputSchema, RewardGetInputSchema, RewardUpdateInputSchema, RewardIdInputSchema, RewardBuyInputSchema, RewardRedeemInputSchema, RewardCategoryListInputSchema, } from "./schemas.js";
-import { rewardList, rewardCreate, rewardGet, rewardUpdate, rewardActivate, rewardDeactivate, rewardBuy, rewardRedeem, rewardCategoryList, } from "./handlers.js";
+import { RewardListInputSchema, RewardCreateInputSchema, RewardGetInputSchema, RewardUpdateInputSchema, RewardIdInputSchema, RewardBuyInputSchema, RewardRedeemInputSchema, RewardCategoryListInputSchema, RewardCategoryCreateInputSchema, RewardCategoryUpdateInputSchema, RewardGetIssuedRewardsInputSchema, RewardPhotoUploadInputSchema, RewardPhotoDeleteInputSchema, } from "./schemas.js";
+import { rewardList, rewardCreate, rewardGet, rewardUpdate, rewardActivate, rewardDeactivate, rewardBuy, rewardRedeem, } from "./handlers.js";
+import { rewardCategoryList, rewardCategoryCreate, rewardCategoryUpdate, } from "./category-handlers.js";
+import { rewardGetIssuedRewards } from "./redemption-handlers.js";
+import { rewardPhotoUpload, rewardPhotoDelete, } from "./photo-handlers.js";
 // Tool definitions
 export const rewardToolDefinitions = [
     {
@@ -103,4 +109,57 @@ export const rewardToolDefinitions = [
         inputSchema: RewardCategoryListInputSchema,
         handler: rewardCategoryList,
     },
+    {
+        name: "ol_reward_category_create",
+        title: "Create Reward Category",
+        description: "Create a new reward category for organizing rewards. " +
+            "REQUIRED: name (English). Use ol_reward_update to assign rewards to this category after creation.",
+        readOnly: false,
+        idempotent: false,
+        inputSchema: RewardCategoryCreateInputSchema,
+        handler: rewardCategoryCreate,
+    },
+    {
+        name: "ol_reward_category_update",
+        title: "Update Reward Category",
+        description: "Update a reward category's name, active status, or sort order. " +
+            "Use ol_reward_category_list to find the categoryId.",
+        readOnly: false,
+        idempotent: true,
+        inputSchema: RewardCategoryUpdateInputSchema,
+        handler: rewardCategoryUpdate,
+    },
+    {
+        name: "ol_member_get_issued_rewards",
+        title: "Get Member's Issued Rewards",
+        description: "List rewards redeemed/issued to a specific member. " +
+            "Returns issuedRewardId, name, status, costInPoints, rewardType, token (coupon code), redemptionDate. " +
+            "Use to answer 'what has member X redeemed?', check coupon codes, or audit reward history. " +
+            "Filter by status: 'pending', 'fulfilled', 'cancelled'. Filter by rewardType: 'material', 'static_coupon', etc.",
+        readOnly: true,
+        idempotent: true,
+        inputSchema: RewardGetIssuedRewardsInputSchema,
+        handler: rewardGetIssuedRewards,
+    },
+    {
+        name: "ol_reward_photo_upload",
+        title: "Upload Reward Photo",
+        description: "Attach a photo to a reward. Provide a publicly accessible photoUrl — the handler fetches and uploads it automatically. " +
+            "Allowed types: PNG, JPEG, GIF. Max: 2MB. Use ol_reward_get to see existing photos on the reward.",
+        readOnly: false,
+        idempotent: false,
+        inputSchema: RewardPhotoUploadInputSchema,
+        handler: rewardPhotoUpload,
+    },
+    {
+        name: "ol_reward_photo_delete",
+        title: "Delete Reward Photo (Permanent)",
+        description: "Permanently delete a photo from a reward. " +
+            "Use ol_reward_get to find existing photoIds on the reward.",
+        readOnly: false,
+        destructive: true,
+        idempotent: true,
+        inputSchema: RewardPhotoDeleteInputSchema,
+        handler: rewardPhotoDelete,
+    },
 ];

package/dist/tools/reward/photo-handlers.d.ts

@@ -0,0 +1,10 @@
+export declare function rewardPhotoUpload(input: {
+    storeCode?: string;
+    rewardId: string;
+    photoUrl: string;
+}): Promise<void>;
+export declare function rewardPhotoDelete(input: {
+    storeCode?: string;
+    rewardId: string;
+    photoId: string;
+}): Promise<void>;

package/dist/tools/reward/photo-handlers.js

@@ -0,0 +1,97 @@
+import { apiDelete } from "../../client/http.js";
+import { formatApiError, OpenLoyaltyError } from "../../utils/errors.js";
+import { getConfig, getStoreCode } from "../../config.js";
+import axios from "axios";
+import FormDataNode from "form-data";
+export async function rewardPhotoUpload(input) {
+    const config = getConfig();
+    const storeCode = getStoreCode(input.storeCode);
+    // Fetch the image from the provided URL
+    let imageBuffer;
+    let contentType;
+    let fileName;
+    try {
+        const imageResponse = await axios.get(input.photoUrl, {
+            responseType: "arraybuffer",
+            timeout: 30000,
+        });
+        imageBuffer = Buffer.from(imageResponse.data);
+        contentType = imageResponse.headers["content-type"] || "image/jpeg";
+        // Extract file name from URL or use default
+        const urlPath = new URL(input.photoUrl).pathname;
+        fileName = urlPath.split("/").pop() || "photo.jpg";
+    }
+    catch {
+        throw new OpenLoyaltyError({
+            code: "PHOTO_FETCH_FAILED",
+            message: `Failed to fetch image from URL: ${input.photoUrl}`,
+            hint: "Ensure the URL is publicly accessible and points to a valid image (PNG, JPEG, or GIF). Max size: 2MB.",
+            relatedTool: "ol_reward_photo_upload",
+        });
+    }
+    // Validate content type
+    const allowed = ["image/png", "image/gif", "image/jpeg", "image/jpg"];
+    if (!allowed.some(t => contentType.startsWith(t.split("/")[0] + "/" + t.split("/")[1]))) {
+        const normalizedType = contentType.toLowerCase();
+        if (!allowed.includes(normalizedType)) {
+            throw new OpenLoyaltyError({
+                code: "INVALID_PHOTO_TYPE",
+                message: `Image type '${contentType}' is not allowed`,
+                hint: "Only PNG, JPEG, and GIF images are accepted. Ensure the URL points to a valid image file.",
+                relatedTool: "ol_reward_photo_upload",
+            });
+        }
+    }
+    // Upload as multipart form data — field name: photo[file]
+    const formData = new FormDataNode();
+    formData.append("photo[file]", imageBuffer, {
+        filename: fileName,
+        contentType: contentType,
+    });
+    try {
+        await axios.post(`${config.apiUrl}/${storeCode}/reward/${input.rewardId}/photo`, formData, {
+            headers: {
+                "X-AUTH-TOKEN": config.apiToken,
+                ...formData.getHeaders(),
+            },
+        });
+    }
+    catch (error) {
+        if (axios.isAxiosError(error)) {
+            if (error.response?.status === 404) {
+                throw new OpenLoyaltyError({
+                    code: "NOT_FOUND",
+                    message: `Reward '${input.rewardId}' not found`,
+                    hint: "Use ol_reward_list() to find existing rewards and their IDs.",
+                    relatedTool: "ol_reward_photo_upload",
+                });
+            }
+            if (error.response?.status === 413) {
+                throw new OpenLoyaltyError({
+                    code: "PHOTO_TOO_LARGE",
+                    message: "The photo exceeds the 2MB size limit",
+                    hint: "Compress or resize the image before uploading. Maximum allowed size is 2MB.",
+                    relatedTool: "ol_reward_photo_upload",
+                });
+            }
+        }
+        throw formatApiError(error, "ol_reward_photo_upload");
+    }
+}
+export async function rewardPhotoDelete(input) {
+    const storeCode = getStoreCode(input.storeCode);
+    try {
+        await apiDelete(`/${storeCode}/reward/${input.rewardId}/photo/${input.photoId}`);
+    }
+    catch (error) {
+        if (axios.isAxiosError(error) && error.response?.status === 404) {
+            throw new OpenLoyaltyError({
+                code: "NOT_FOUND",
+                message: `Reward photo not found (rewardId: ${input.rewardId}, photoId: ${input.photoId})`,
+                hint: "Use ol_reward_get() to see the reward's current photos and their photoIds.",
+                relatedTool: "ol_reward_photo_delete",
+            });
+        }
+        throw formatApiError(error, "ol_reward_photo_delete");
+    }
+}

package/dist/tools/reward/redemption-handlers.d.ts

@@ -0,0 +1,23 @@
+export declare function rewardGetIssuedRewards(input: {
+    storeCode?: string;
+    memberId: string;
+    page?: number;
+    perPage?: number;
+    status?: string;
+    rewardType?: string;
+}): Promise<{
+    issuedRewards: Array<{
+        issuedRewardId: string;
+        name?: string;
+        status?: string;
+        costInPoints?: number;
+        rewardType?: string;
+        token?: string;
+        redemptionDate?: string;
+        cancelledAt?: string;
+    }>;
+    total: {
+        all?: number;
+        filtered?: number;
+    };
+}>;

package/dist/tools/reward/redemption-handlers.js

@@ -0,0 +1,50 @@
+import { apiGet } from "../../client/http.js";
+import { formatApiError, OpenLoyaltyError } from "../../utils/errors.js";
+import { getStoreCode } from "../../config.js";
+export async function rewardGetIssuedRewards(input) {
+    const storeCode = getStoreCode(input.storeCode);
+    const params = new URLSearchParams();
+    params.append("customerId", input.memberId);
+    if (input.page)
+        params.append("_page", String(input.page));
+    if (input.perPage)
+        params.append("_itemsOnPage", String(input.perPage));
+    if (input.status)
+        params.append("status", input.status);
+    if (input.rewardType)
+        params.append("rewardType", input.rewardType);
+    const url = `/${storeCode}/redemption?${params.toString()}`;
+    try {
+        const response = await apiGet(url);
+        const issuedRewards = (response.items || []).map((item) => ({
+            issuedRewardId: item.issuedRewardId,
+            name: item.name,
+            status: item.status,
+            costInPoints: item.costInPoints,
+            rewardType: item.rewardType,
+            token: item.token,
+            redemptionDate: item.redemptionDate,
+            cancelledAt: item.cancelledAt,
+        }));
+        const total = response.total || {};
+        return {
+            issuedRewards,
+            total: {
+                all: typeof total.all === "number" ? total.all : undefined,
+                filtered: typeof total.filtered === "number" ? total.filtered : undefined,
+            },
+        };
+    }
+    catch (error) {
+        const axiosError = error;
+        if (axiosError.response?.status === 404) {
+            throw new OpenLoyaltyError({
+                code: "NOT_FOUND",
+                message: `Member '${input.memberId}' not found`,
+                hint: "Use ol_member_list() to find the member by email, name, or phone.",
+                relatedTool: "ol_member_get_issued_rewards",
+            });
+        }
+        throw formatApiError(error, "ol_member_get_issued_rewards");
+    }
+}

package/dist/tools/reward/schemas.d.ts

@@ -107,3 +107,34 @@ export declare const RewardCategoryListInputSchema: {
     perPage: z.ZodOptional<z.ZodNumber>;
     active: z.ZodOptional<z.ZodBoolean>;
 };
+export declare const RewardCategoryCreateInputSchema: {
+    storeCode: z.ZodOptional<z.ZodString>;
+    name: z.ZodString;
+    active: z.ZodOptional<z.ZodBoolean>;
+    sortOrder: z.ZodOptional<z.ZodNumber>;
+};
+export declare const RewardCategoryUpdateInputSchema: {
+    storeCode: z.ZodOptional<z.ZodString>;
+    categoryId: z.ZodString;
+    name: z.ZodString;
+    active: z.ZodOptional<z.ZodBoolean>;
+    sortOrder: z.ZodOptional<z.ZodNumber>;
+};
+export declare const RewardGetIssuedRewardsInputSchema: {
+    storeCode: z.ZodOptional<z.ZodString>;
+    memberId: z.ZodString;
+    page: z.ZodOptional<z.ZodNumber>;
+    perPage: z.ZodOptional<z.ZodNumber>;
+    status: z.ZodOptional<z.ZodString>;
+    rewardType: z.ZodOptional<z.ZodString>;
+};
+export declare const RewardPhotoUploadInputSchema: {
+    storeCode: z.ZodOptional<z.ZodString>;
+    rewardId: z.ZodString;
+    photoUrl: z.ZodString;
+};
+export declare const RewardPhotoDeleteInputSchema: {
+    storeCode: z.ZodOptional<z.ZodString>;
+    rewardId: z.ZodString;
+    photoId: z.ZodString;
+};

package/dist/tools/reward/schemas.js

@@ -105,3 +105,36 @@ export const RewardCategoryListInputSchema = {
     perPage: z.number().optional().describe("Items per page (default: 10)."),
     active: z.boolean().optional().describe("Filter by active status."),
 };
+export const RewardCategoryCreateInputSchema = {
+    storeCode: z.string().optional().describe("INTERNAL: Auto-configured from server settings. NEVER ask the user for this value. Only set if the user explicitly requests a different store."),
+    name: z.string().describe("Category name in English (required)."),
+    active: z.boolean().optional().describe("Whether category is active (default: true)."),
+    sortOrder: z.number().optional().describe("Display sort order (0 = first, higher = later). Default: 0."),
+};
+export const RewardCategoryUpdateInputSchema = {
+    storeCode: z.string().optional().describe("INTERNAL: Auto-configured from server settings. NEVER ask the user for this value. Only set if the user explicitly requests a different store."),
+    categoryId: z.string().describe("The reward category ID (UUID) to update."),
+    name: z.string().describe("Category name in English (required)."),
+    active: z.boolean().optional().describe("Whether category is active."),
+    sortOrder: z.number().optional().describe("Display sort order (0 = first)."),
+};
+export const RewardGetIssuedRewardsInputSchema = {
+    storeCode: z.string().optional().describe("INTERNAL: Auto-configured from server settings. NEVER ask the user for this value. Only set if the user explicitly requests a different store."),
+    memberId: z.string().describe("Member ID (UUID) whose issued/redeemed rewards to list."),
+    page: z.number().optional().describe("Page number (default: 1)."),
+    perPage: z.number().optional().describe("Items per page (default: 10)."),
+    status: z.string().optional().describe("Filter by status (e.g., 'pending', 'fulfilled', 'cancelled')."),
+    rewardType: z.string().optional().describe("Filter by reward type (e.g., 'material', 'static_coupon')."),
+};
+export const RewardPhotoUploadInputSchema = {
+    storeCode: z.string().optional().describe("INTERNAL: Auto-configured from server settings. NEVER ask the user for this value. Only set if the user explicitly requests a different store."),
+    rewardId: z.string().describe("Reward ID (UUID) to attach the photo to."),
+    photoUrl: z.string().describe("Publicly accessible URL of the image to upload. " +
+        "Allowed types: PNG, JPEG, GIF. Max size: 2MB. " +
+        "The handler will fetch and upload the image automatically."),
+};
+export const RewardPhotoDeleteInputSchema = {
+    storeCode: z.string().optional().describe("INTERNAL: Auto-configured from server settings. NEVER ask the user for this value. Only set if the user explicitly requests a different store."),
+    rewardId: z.string().describe("Reward ID (UUID) the photo belongs to."),
+    photoId: z.string().describe("Photo ID (UUID) to delete. Use ol_reward_get to find existing photoIds."),
+};

package/dist/tools/segment/handlers.js

@@ -1,21 +1,25 @@
 import { apiGet, apiPost, apiPut, apiDelete } from "../../client/http.js";
 import { formatApiError, OpenLoyaltyError } from "../../utils/errors.js";
 import { getStoreCode } from "../../config.js";
-const DEFAULT_TRANSACTION_COUNT_MAX = 999999;
-function normalizeSegmentParts(parts) {
+function validateSegmentParts(parts, toolName) {
     return parts.map((part) => ({
         ...part,
         criteria: part.criteria.map((criterion) => {
             if (!criterion || typeof criterion !== "object") {
                 return criterion;
             }
-            const normalized = { ...criterion };
-            if (normalized.type === "transaction_count" &&
-                normalized.min !== undefined &&
-                normalized.max === undefined) {
-                normalized.max = DEFAULT_TRANSACTION_COUNT_MAX;
+            if (criterion.type === "transaction_count" &&
+                criterion.min !== undefined &&
+                criterion.max === undefined) {
+                throw new OpenLoyaltyError({
+                    code: "MISSING_MAX_VALUE",
+                    message: "transaction_count criterion requires both min and max values",
+                    hint: "Provide an explicit max to define the upper bound. Use max: 999999 for 'min or more' behavior. " +
+                        "Example: { type: 'transaction_count', min: 5, max: 999999 } for '5 or more purchases'.",
+                    relatedTool: toolName,
+                });
             }
-            return normalized;
+            return criterion;
         }),
     }));
 }
@@ -59,7 +63,7 @@ export async function segmentCreate(input) {
     const storeCode = getStoreCode(input.storeCode);
     const segmentPayload = {
         name: input.name,
-        parts: normalizeSegmentParts(input.parts),
+        parts: validateSegmentParts(input.parts, "ol_segment_create"),
     };
     if (input.description)
         segmentPayload.description = input.description;
@@ -116,7 +120,7 @@ export async function segmentUpdate(input) {
     const storeCode = getStoreCode(input.storeCode);
     const segmentPayload = {
         name: input.name,
-        parts: normalizeSegmentParts(input.parts),
+        parts: validateSegmentParts(input.parts, "ol_segment_update"),
     };
     if (input.description !== undefined)
         segmentPayload.description = input.description;

package/dist/tools/segment/index.js

@@ -26,7 +26,7 @@ export const segmentToolDefinitions = [
             "3. Intended use -- campaign targeting (activate immediately) or analytics only (can stay inactive)? " +
             "REQUIRED: name, parts array with criteria. Parts use OR logic, criteria within parts use AND logic. " +
             "CRITERION FIELDS BY TYPE: " +
-            "transaction_count: { type: 'transaction_count', min: N, max: N } (both required, MCP auto-fills max=999999 if omitted). " +
+            "transaction_count: { type: 'transaction_count', min: N, max: N } (BOTH required; use max: 999999 for 'min or more' behavior). " +
             "purchase_in_period: { type: 'purchase_in_period', days: N, min: N, max: N }. " +
             "average_transaction_value: { type: 'average_transaction_value', min: N, max: N }. " +
             "NOTE: 'tier' and 'points_balance' types are REJECTED by the API despite being documented.",

package/dist/tools/segment/schemas.js

@@ -9,17 +9,17 @@ export const SegmentListInputSchema = {
 };
 // Criterion input schema - flexible to support all criterion types
 // NOTE: Only certain criterion types are supported by the API.
-// WORKING: transaction_count (requires both min AND max; MCP will auto-fill max if omitted)
+// WORKING: transaction_count (requires BOTH min AND max — omitting max throws MISSING_MAX_VALUE error)
 // NOT WORKING: tier, points_balance (rejected by API despite being documented)
 const SegmentCriterionInputSchema = z.object({
-    type: z.string().describe("Criterion type. WORKING: 'transaction_count' (requires both min AND max; MCP auto-fills max if omitted). NOT WORKING: 'tier', 'points_balance' are rejected by the API."),
+    type: z.string().describe("Criterion type. 'transaction_count' requires BOTH min AND max (omitting max is an error). NOT WORKING: 'tier', 'points_balance' are rejected by the API."),
     criterionId: z.string().optional().describe("Criterion ID (optional, generated if not provided)."),
     // Common criterion data fields
     days: z.number().optional().describe("Days for time-based criteria (e.g., 'in the last N days'). Used with transaction_count, purchase_period criteria."),
     fromDate: z.string().optional().describe("Start date (ISO format)."),
     toDate: z.string().optional().describe("End date (ISO format)."),
     min: z.number().optional().describe("Minimum value (e.g., min=5 for 'at least 5 transactions'). Required for transaction_count type. BUSINESS IMPACT: Too low a threshold (e.g., min=2 transactions) captures most members -- segment becomes too broad, wasting campaign budget."),
-    max: z.number().optional().describe("Maximum value. Required for transaction_count type (MCP auto-fills max=999999 if omitted). BUSINESS IMPACT: Too narrow a range (e.g., max=3 with min=3) captures very few members -- limited campaign impact."),
+    max: z.number().optional().describe("Maximum value. REQUIRED for transaction_count type (omitting max throws an error). Use max: 999999 for 'min or more' behavior. BUSINESS IMPACT: Too narrow a range (e.g., max=3 with min=3) captures very few members -- limited campaign impact."),
     posIds: z.array(z.string()).optional().describe("POS IDs."),
     skus: z.array(z.string()).optional().describe("SKU codes."),
     makers: z.array(z.string()).optional().describe("Maker/brand names."),

package/dist/tools/store/handlers.d.ts

@@ -23,3 +23,27 @@ export declare function storeUpdate(input: {
     active?: boolean;
     currency?: string;
 }): Promise<void>;
+export declare function storeGetSettings(input: {
+    storeCode?: string;
+}): Promise<Record<string, unknown>>;
+export declare function storeUpdateSettings(input: {
+    storeCode?: string;
+    programName?: string;
+    allowCustomersProfileEdits?: boolean;
+    tierAssignType?: "points" | "transactions";
+    tierWalletCode?: string;
+    excludeDeliveryCostsFromTierAssignment?: boolean;
+    excludedLevelCategories?: string[];
+    levelDowngradeMode?: "none" | "automatic" | "after_x_days";
+    levelDowngradeDays?: number;
+    levelDowngradeBase?: "none" | "active_points" | "earned_points" | "earned_points_since_last_level_change";
+    levelResetPointsOnDowngrade?: boolean;
+    accountActivationRequired?: boolean;
+    identificationMethod?: "email" | "phone" | "loyaltyCardNumber";
+    timezone?: string;
+    timezoneStrategy?: "none" | "default" | "localtime";
+    rewardWalletCode?: string;
+    expirePointsNotificationDays?: number;
+    expireCouponsNotificationDays?: number;
+    expireLevelsNotificationDays?: number;
+}): Promise<Record<string, unknown>>;

package/dist/tools/store/handlers.js

@@ -1,6 +1,7 @@
-import { apiGet, apiPost, apiPut } from "../../client/http.js";
+import { apiGet, apiPost, apiPut, apiPatch } from "../../client/http.js";
 import { formatApiError, OpenLoyaltyError } from "../../utils/errors.js";
 import axios from "axios";
+import { getStoreCode } from "../../config.js";
 export async function storeList(input) {
     const params = new URLSearchParams();
     if (input.page)
@@ -87,3 +88,30 @@ export async function storeUpdate(input) {
         throw formatApiError(error, "ol_store_update");
     }
 }
+export async function storeGetSettings(input) {
+    const storeCode = getStoreCode(input.storeCode);
+    try {
+        const response = await apiGet(`/${storeCode}/settings`);
+        return response.settings ?? response;
+    }
+    catch (error) {
+        throw formatApiError(error, "ol_store_get_settings");
+    }
+}
+export async function storeUpdateSettings(input) {
+    const storeCode = getStoreCode(input.storeCode);
+    const { storeCode: _sc, ...fields } = input;
+    const settings = {};
+    for (const [key, value] of Object.entries(fields)) {
+        if (value !== undefined) {
+            settings[key] = value;
+        }
+    }
+    try {
+        const response = await apiPatch(`/${storeCode}/settings`, { settings });
+        return response?.settings ?? response;
+    }
+    catch (error) {
+        throw formatApiError(error, "ol_store_update_settings");
+    }
+}

package/dist/tools/store/index.d.ts

@@ -1,7 +1,7 @@
-export { StoreListInputSchema, StoreCreateInputSchema, StoreGetInputSchema, StoreUpdateInputSchema, } from "./schemas.js";
+export { StoreListInputSchema, StoreCreateInputSchema, StoreGetInputSchema, StoreUpdateInputSchema, StoreGetSettingsInputSchema, StoreUpdateSettingsInputSchema, } from "./schemas.js";
 export type { Store, StoreListResponse } from "./schemas.js";
-export { storeList, storeCreate, storeGet, storeUpdate, } from "./handlers.js";
-import { storeList, storeCreate, storeGet, storeUpdate } from "./handlers.js";
+export { storeList, storeCreate, storeGet, storeUpdate, storeGetSettings, storeUpdateSettings, } from "./handlers.js";
+import { storeList, storeCreate, storeGet, storeUpdate, storeGetSettings, storeUpdateSettings } from "./handlers.js";
 export declare const storeToolDefinitions: readonly [{
     readonly name: "ol_store_list";
     readonly title: "List Stores";
@@ -52,4 +52,42 @@ export declare const storeToolDefinitions: readonly [{
         currency: import("zod").ZodOptional<import("zod").ZodString>;
     };
     readonly handler: typeof storeUpdate;
+}, {
+    readonly name: "ol_store_get_settings";
+    readonly title: "Get Store Settings";
+    readonly description: string;
+    readonly readOnly: true;
+    readonly idempotent: true;
+    readonly inputSchema: {
+        storeCode: import("zod").ZodOptional<import("zod").ZodString>;
+    };
+    readonly handler: typeof storeGetSettings;
+}, {
+    readonly name: "ol_store_update_settings";
+    readonly title: "Update Store Settings";
+    readonly description: string;
+    readonly readOnly: false;
+    readonly idempotent: true;
+    readonly inputSchema: {
+        storeCode: import("zod").ZodOptional<import("zod").ZodString>;
+        programName: import("zod").ZodOptional<import("zod").ZodString>;
+        allowCustomersProfileEdits: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        tierAssignType: import("zod").ZodOptional<import("zod").ZodEnum<["points", "transactions"]>>;
+        tierWalletCode: import("zod").ZodOptional<import("zod").ZodString>;
+        excludeDeliveryCostsFromTierAssignment: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        excludedLevelCategories: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+        levelDowngradeMode: import("zod").ZodOptional<import("zod").ZodEnum<["none", "automatic", "after_x_days"]>>;
+        levelDowngradeDays: import("zod").ZodOptional<import("zod").ZodNumber>;
+        levelDowngradeBase: import("zod").ZodOptional<import("zod").ZodEnum<["none", "active_points", "earned_points", "earned_points_since_last_level_change"]>>;
+        levelResetPointsOnDowngrade: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        accountActivationRequired: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        identificationMethod: import("zod").ZodOptional<import("zod").ZodEnum<["email", "phone", "loyaltyCardNumber"]>>;
+        timezone: import("zod").ZodOptional<import("zod").ZodString>;
+        timezoneStrategy: import("zod").ZodOptional<import("zod").ZodEnum<["none", "default", "localtime"]>>;
+        rewardWalletCode: import("zod").ZodOptional<import("zod").ZodString>;
+        expirePointsNotificationDays: import("zod").ZodOptional<import("zod").ZodNumber>;
+        expireCouponsNotificationDays: import("zod").ZodOptional<import("zod").ZodNumber>;
+        expireLevelsNotificationDays: import("zod").ZodOptional<import("zod").ZodNumber>;
+    };
+    readonly handler: typeof storeUpdateSettings;
 }];