@open-loyalty/mcp-server 1.8.0 → 1.13.0

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;
 }];

package/dist/tools/store/index.js

@@ -1,10 +1,10 @@
 // Re-export schemas and types
-export { StoreListInputSchema, StoreCreateInputSchema, StoreGetInputSchema, StoreUpdateInputSchema, } from "./schemas.js";
+export { StoreListInputSchema, StoreCreateInputSchema, StoreGetInputSchema, StoreUpdateInputSchema, StoreGetSettingsInputSchema, StoreUpdateSettingsInputSchema, } from "./schemas.js";
 // Re-export handlers
-export { storeList, storeCreate, storeGet, storeUpdate, } from "./handlers.js";
+export { storeList, storeCreate, storeGet, storeUpdate, storeGetSettings, storeUpdateSettings, } from "./handlers.js";
 // Imports for tool definitions
-import { StoreListInputSchema, StoreCreateInputSchema, StoreGetInputSchema, StoreUpdateInputSchema, } from "./schemas.js";
-import { storeList, storeCreate, storeGet, storeUpdate, } from "./handlers.js";
+import { StoreListInputSchema, StoreCreateInputSchema, StoreGetInputSchema, StoreUpdateInputSchema, StoreGetSettingsInputSchema, StoreUpdateSettingsInputSchema, } from "./schemas.js";
+import { storeList, storeCreate, storeGet, storeUpdate, storeGetSettings, storeUpdateSettings, } from "./handlers.js";
 // Tool definitions
 export const storeToolDefinitions = [
     {
@@ -43,4 +43,27 @@ export const storeToolDefinitions = [
         inputSchema: StoreUpdateInputSchema,
         handler: storeUpdate,
     },
+    {
+        name: "ol_store_get_settings",
+        title: "Get Store Settings",
+        description: "Get the loyalty program settings for the current store. Returns configuration such as tier assignment type, " +
+            "wallet codes, downgrade mode, account activation requirements, member identification method, timezone, " +
+            "notification settings, and active member criteria. Use before ol_store_update_settings to see current values.",
+        readOnly: true,
+        idempotent: true,
+        inputSchema: StoreGetSettingsInputSchema,
+        handler: storeGetSettings,
+    },
+    {
+        name: "ol_store_update_settings",
+        title: "Update Store Settings",
+        description: "Update loyalty program settings via PATCH (partial update — only provided fields are changed). " +
+            "KEY SETTINGS: tierAssignType ('points'|'transactions'), tierWalletCode, levelDowngradeMode ('none'|'automatic'|'after_x_days'), " +
+            "accountActivationRequired, identificationMethod ('email'|'phone'|'loyaltyCardNumber'), timezone. " +
+            "Use ol_store_get_settings first to see current values before making changes.",
+        readOnly: false,
+        idempotent: true,
+        inputSchema: StoreUpdateSettingsInputSchema,
+        handler: storeUpdateSettings,
+    },
 ];

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

@@ -36,3 +36,27 @@ export declare const StoreUpdateInputSchema: {
     active: z.ZodOptional<z.ZodBoolean>;
     currency: z.ZodOptional<z.ZodString>;
 };
+export declare const StoreGetSettingsInputSchema: {
+    storeCode: z.ZodOptional<z.ZodString>;
+};
+export declare const StoreUpdateSettingsInputSchema: {
+    storeCode: z.ZodOptional<z.ZodString>;
+    programName: z.ZodOptional<z.ZodString>;
+    allowCustomersProfileEdits: z.ZodOptional<z.ZodBoolean>;
+    tierAssignType: z.ZodOptional<z.ZodEnum<["points", "transactions"]>>;
+    tierWalletCode: z.ZodOptional<z.ZodString>;
+    excludeDeliveryCostsFromTierAssignment: z.ZodOptional<z.ZodBoolean>;
+    excludedLevelCategories: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    levelDowngradeMode: z.ZodOptional<z.ZodEnum<["none", "automatic", "after_x_days"]>>;
+    levelDowngradeDays: z.ZodOptional<z.ZodNumber>;
+    levelDowngradeBase: z.ZodOptional<z.ZodEnum<["none", "active_points", "earned_points", "earned_points_since_last_level_change"]>>;
+    levelResetPointsOnDowngrade: z.ZodOptional<z.ZodBoolean>;
+    accountActivationRequired: z.ZodOptional<z.ZodBoolean>;
+    identificationMethod: z.ZodOptional<z.ZodEnum<["email", "phone", "loyaltyCardNumber"]>>;
+    timezone: z.ZodOptional<z.ZodString>;
+    timezoneStrategy: z.ZodOptional<z.ZodEnum<["none", "default", "localtime"]>>;
+    rewardWalletCode: z.ZodOptional<z.ZodString>;
+    expirePointsNotificationDays: z.ZodOptional<z.ZodNumber>;
+    expireCouponsNotificationDays: z.ZodOptional<z.ZodNumber>;
+    expireLevelsNotificationDays: z.ZodOptional<z.ZodNumber>;
+};

package/dist/tools/store/schemas.js

@@ -21,3 +21,27 @@ export const StoreUpdateInputSchema = {
     active: z.boolean().optional().describe("Whether the store is active."),
     currency: z.string().optional().describe("Currency code."),
 };
+export const StoreGetSettingsInputSchema = {
+    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."),
+};
+export const StoreUpdateSettingsInputSchema = {
+    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."),
+    programName: z.string().optional().describe("Program/loyalty program name."),
+    allowCustomersProfileEdits: z.boolean().optional().describe("Whether members can edit their own profiles."),
+    tierAssignType: z.enum(["points", "transactions"]).optional().describe("How tier assignment is calculated: 'points' (based on wallet balance) or 'transactions' (based on purchase count)."),
+    tierWalletCode: z.string().optional().describe("Wallet used for tier assignment (wallet type code)."),
+    excludeDeliveryCostsFromTierAssignment: z.boolean().optional().describe("Exclude delivery costs from tier calculations."),
+    excludedLevelCategories: z.array(z.string()).optional().describe("Product categories excluded from tier assignment."),
+    levelDowngradeMode: z.enum(["none", "automatic", "after_x_days"]).optional().describe("Tier downgrade mode: 'none' (never downgrade), 'automatic' (downgrade when criteria unmet), 'after_x_days' (downgrade after N inactive days)."),
+    levelDowngradeDays: z.number().optional().describe("Days before tier downgrade (used with levelDowngradeMode: 'after_x_days')."),
+    levelDowngradeBase: z.enum(["none", "active_points", "earned_points", "earned_points_since_last_level_change"]).optional().describe("Point basis for downgrade recalculation."),
+    levelResetPointsOnDowngrade: z.boolean().optional().describe("Reset points when member is downgraded."),
+    accountActivationRequired: z.boolean().optional().describe("Whether new accounts require email activation before participating."),
+    identificationMethod: z.enum(["email", "phone", "loyaltyCardNumber"]).optional().describe("Primary member identification method."),
+    timezone: z.string().optional().describe("Store timezone (e.g., 'Europe/Warsaw', 'America/New_York')."),
+    timezoneStrategy: z.enum(["none", "default", "localtime"]).optional().describe("Timezone handling strategy."),
+    rewardWalletCode: z.string().optional().describe("Wallet used for reward purchases (wallet type code)."),
+    expirePointsNotificationDays: z.number().optional().describe("Days before point expiry to send notification email."),
+    expireCouponsNotificationDays: z.number().optional().describe("Days before coupon expiry to send notification email."),
+    expireLevelsNotificationDays: z.number().optional().describe("Days before tier expiry to send notification email."),
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@open-loyalty/mcp-server",
-  "version": "1.8.0",
+  "version": "1.13.0",
   "type": "module",
   "description": "MCP server for Open Loyalty API - enables AI agents to manage loyalty programs, members, points, rewards, and transactions",
   "author": "Marcin Dyguda <md@openloyalty.io>",
@@ -17,8 +17,7 @@
   ],
   "main": "dist/index.js",
   "bin": {
-    "openloyalty-mcp": "./dist/index.js",
-    "openloyalty-mcp-http": "./dist/http.js"
+    "openloyalty-mcp": "./dist/index.js"
   },
   "files": [
     "dist",
@@ -31,9 +30,7 @@
     "dev:ui": "node scripts/build-ui.mjs --watch",
     "prepublishOnly": "npm run build",
     "start": "node dist/index.js",
-    "start:http": "node dist/http.js",
     "dev": "tsx src/index.ts",
-    "dev:http": "tsx src/http.ts",
     "typecheck": "tsc --noEmit",
     "test": "vitest",
     "test:run": "vitest run",
@@ -47,19 +44,12 @@
     "@modelcontextprotocol/ext-apps": "^1.0.1",
     "@modelcontextprotocol/sdk": "^1.0.0",
     "axios": "^1.6.0",
-    "cors": "^2.8.5",
     "dotenv": "^17.2.3",
-    "express": "^5.2.1",
-    "express-rate-limit": "^8.2.1",
     "form-data": "^4.0.0",
-    "helmet": "^8.1.0",
-    "ioredis": "^5.9.2",
     "zod": "^3.22.0"
   },
   "devDependencies": {
     "@eslint/js": "^9.39.2",
-    "@types/cors": "^2.8.19",
-    "@types/express": "^5.0.6",
     "@types/node": "^20.10.0",
     "@vitest/coverage-v8": "^4.0.17",
     "axios-mock-adapter": "^2.1.0",

package/dist/auth/provider.d.ts

@@ -1,33 +0,0 @@
-import type { OAuthServerProvider } from "@modelcontextprotocol/sdk/server/auth/provider.js";
-/**
- * Open Loyalty API credentials stored per-client
- */
-export interface OpenLoyaltyConfig {
-    apiUrl: string;
-    apiToken: string;
-    storeCode: string;
-}
-/**
- * Creates the OAuth server provider
- */
-export declare function createOAuthProvider(issuerUrl: string): OAuthServerProvider;
-/**
- * Completes authorization after form submission
- */
-export declare function completeAuthorization(sessionId: string, config: OpenLoyaltyConfig): Promise<{
-    redirectUrl: string;
-} | {
-    error: string;
-}>;
-/**
- * Gets the Open Loyalty config for a client
- */
-export declare function getClientConfig(clientId: string): Promise<OpenLoyaltyConfig | undefined>;
-/**
- * Validates Open Loyalty credentials
- * Uses the member list endpoint to validate both API token and store code
- */
-export declare function validateOpenLoyaltyCredentials(config: OpenLoyaltyConfig): Promise<{
-    valid: boolean;
-    error?: string;
-}>;