@open-loyalty/mcp-server 1.0.3 → 1.3.1

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

@@ -0,0 +1,110 @@
+import { Reward } from "../../types/schemas/reward.js";
+export declare function rewardList(input: {
+    storeCode?: string;
+    page?: number;
+    perPage?: number;
+    active?: boolean;
+    type?: string;
+    categoryId?: string;
+}): Promise<{
+    rewards: Array<{
+        rewardId: string;
+        name: string;
+        type: string;
+        costInPoints?: number;
+        active: boolean;
+    }>;
+    total: {
+        all?: number;
+        filtered?: number;
+    };
+}>;
+export declare function rewardCreate(input: {
+    storeCode?: string;
+    translations: {
+        en: {
+            name: string;
+        };
+    };
+    reward: string;
+    activity: {
+        from: string;
+        to: string;
+    };
+    visibility: {
+        from: string;
+        to: string;
+    };
+    usageLimit: {
+        perUser: number;
+        general?: number;
+    };
+    costInPoints?: number;
+    usageInstruction?: string;
+    active?: boolean;
+    categories?: string[];
+    levels?: string[];
+    segments?: string[];
+    target?: string | null;
+    couponValue?: number;
+    couponValueType?: string;
+    daysValid?: number;
+}): Promise<{
+    rewardId: string;
+    name: string;
+    costInPoints?: number;
+}>;
+export declare function rewardGet(input: {
+    storeCode?: string;
+    rewardId: string;
+}): Promise<Reward>;
+export declare function rewardUpdate(input: {
+    storeCode?: string;
+    rewardId: string;
+    name?: string;
+    costInPoints?: number;
+    description?: string;
+    active?: boolean;
+    categories?: string[];
+    levels?: string[];
+    segments?: string[];
+}): Promise<void>;
+export declare function rewardActivate(input: {
+    storeCode?: string;
+    rewardId: string;
+}): Promise<void>;
+export declare function rewardDeactivate(input: {
+    storeCode?: string;
+    rewardId: string;
+}): Promise<void>;
+export declare function rewardBuy(input: {
+    storeCode?: string;
+    rewardId: string;
+    memberId: string;
+    quantity?: number;
+    couponValue?: number;
+    withoutPoints?: boolean;
+}): Promise<{
+    issuedRewardId: string;
+    couponCode?: string;
+}>;
+export declare function rewardRedeem(input: {
+    storeCode?: string;
+    memberId: string;
+    couponCode: string;
+}): Promise<{
+    code: string;
+    used: boolean;
+}>;
+export declare function rewardCategoryList(input: {
+    storeCode?: string;
+    page?: number;
+    perPage?: number;
+    active?: boolean;
+}): Promise<{
+    categories: Array<{
+        categoryId: string;
+        name: string;
+        active: boolean;
+    }>;
+}>;

package/dist/tools/reward/handlers.js

@@ -0,0 +1,289 @@
+import { apiGet, apiPost, apiPut } from "../../client/http.js";
+import { RewardSchema } from "../../types/schemas/reward.js";
+import { formatApiError, OpenLoyaltyError } from "../../utils/errors.js";
+import { getStoreCode } from "../../config.js";
+import { omitUndefined } from "../../utils/payload.js";
+export async function rewardList(input) {
+    const storeCode = getStoreCode(input.storeCode);
+    const params = new URLSearchParams();
+    if (input.page)
+        params.append("_page", String(input.page));
+    if (input.perPage)
+        params.append("_itemsOnPage", String(input.perPage));
+    if (input.active !== undefined)
+        params.append("active", String(input.active));
+    if (input.type)
+        params.append("reward", input.type);
+    if (input.categoryId)
+        params.append("categoryId", input.categoryId);
+    const queryString = params.toString();
+    const url = `/${storeCode}/reward${queryString ? `?${queryString}` : ""}`;
+    try {
+        const response = await apiGet(url);
+        const items = response.items || [];
+        const rewards = items.map((r) => {
+            const reward = r;
+            return {
+                rewardId: reward.rewardId,
+                name: reward.name,
+                type: (reward.reward || reward.type),
+                costInPoints: reward.costInPoints,
+                active: (reward.active ?? false),
+            };
+        });
+        const total = response.total || {};
+        return {
+            rewards,
+            total: {
+                all: typeof total.all === 'number' ? total.all : undefined,
+                filtered: typeof total.filtered === 'number' ? total.filtered : undefined,
+            }
+        };
+    }
+    catch (error) {
+        throw formatApiError(error, "ol_reward_list");
+    }
+}
+export async function rewardCreate(input) {
+    const storeCode = getStoreCode(input.storeCode);
+    // API requires: translations (name only), reward (type), activity, visibility, usageLimit.perUser
+    // NOTE: description is NOT supported by the API at creation time
+    const payload = omitUndefined({
+        translations: input.translations,
+        reward: input.reward,
+        activity: input.activity,
+        visibility: input.visibility,
+        usageLimit: input.usageLimit,
+        costInPoints: input.costInPoints,
+        usageInstruction: input.usageInstruction,
+        active: input.active,
+        categories: input.categories,
+        levels: input.levels,
+        segments: input.segments,
+        target: input.target,
+        couponValue: input.couponValue,
+        couponValueType: input.couponValueType,
+        daysValid: input.daysValid,
+    });
+    try {
+        const response = await apiPost(`/${storeCode}/reward`, { reward: payload });
+        return {
+            rewardId: response.rewardId,
+            name: input.translations.en.name,
+            costInPoints: input.costInPoints,
+        };
+    }
+    catch (error) {
+        throw formatApiError(error, "ol_reward_create");
+    }
+}
+export async function rewardGet(input) {
+    const storeCode = getStoreCode(input.storeCode);
+    try {
+        const response = await apiGet(`/${storeCode}/reward/${input.rewardId}`);
+        return RewardSchema.parse(response);
+    }
+    catch (error) {
+        throw formatApiError(error, "ol_reward_get");
+    }
+}
+export async function rewardUpdate(input) {
+    const storeCode = getStoreCode(input.storeCode);
+    // API requires full reward object - fetch existing then merge
+    const existing = await apiGet(`/${storeCode}/reward/${input.rewardId}`);
+    // Extract only the fields that PUT accepts (API is strict about extra fields)
+    // Note: GET returns name at root level, but PUT expects it in translations.en.name
+    const existingName = existing.name;
+    const existingActivity = existing.activity;
+    const existingVisibility = existing.visibility;
+    const existingUsageLimit = existing.usageLimit;
+    // Build payload with only accepted fields - NEVER include undefined values
+    // Only include activity/visibility/usageLimit if they exist in GET response
+    const payload = {
+        // translations - only include name (GET returns name at root level)
+        translations: {
+            en: {
+                name: existingName || "",
+            },
+        },
+        // Other fields
+        active: existing.active,
+        costInPoints: existing.costInPoints,
+    };
+    // Activity: only include if present in GET response
+    if (existingActivity) {
+        const activityPayload = {
+            allTime: existingActivity.allTime ?? false,
+        };
+        if (existingActivity.from !== undefined)
+            activityPayload.from = existingActivity.from;
+        if (existingActivity.to !== undefined)
+            activityPayload.to = existingActivity.to;
+        payload.activity = activityPayload;
+    }
+    // Visibility: only include if present in GET response
+    if (existingVisibility) {
+        const visibilityPayload = {
+            allTime: existingVisibility.allTime ?? false,
+        };
+        if (existingVisibility.from !== undefined)
+            visibilityPayload.from = existingVisibility.from;
+        if (existingVisibility.to !== undefined)
+            visibilityPayload.to = existingVisibility.to;
+        payload.visibility = visibilityPayload;
+    }
+    // usageLimit: Required field, but only include perUser (API rejects extra fields)
+    // The GET response may include derived fields that PUT doesn't accept
+    payload.usageLimit = {
+        perUser: existingUsageLimit?.perUser ?? 1,
+    };
+    // Coupon-specific fields (required for static_coupon, dynamic_coupon, conversion_coupon)
+    if (existing.couponValue !== undefined)
+        payload.couponValue = existing.couponValue;
+    if (existing.couponValueType !== undefined)
+        payload.couponValueType = existing.couponValueType;
+    if (existing.daysValid !== undefined)
+        payload.daysValid = existing.daysValid;
+    // Add optional arrays only if they exist
+    if (existing.categories)
+        payload.categories = existing.categories;
+    if (existing.levels)
+        payload.levels = existing.levels;
+    if (existing.segments)
+        payload.segments = existing.segments;
+    if (existing.target)
+        payload.target = existing.target;
+    // Apply updates
+    if (input.name !== undefined) {
+        const translations = payload.translations;
+        translations.en.name = input.name;
+    }
+    if (input.costInPoints !== undefined)
+        payload.costInPoints = input.costInPoints;
+    if (input.active !== undefined)
+        payload.active = input.active;
+    if (input.categories !== undefined)
+        payload.categories = input.categories;
+    if (input.levels !== undefined)
+        payload.levels = input.levels;
+    if (input.segments !== undefined)
+        payload.segments = input.segments;
+    try {
+        await apiPut(`/${storeCode}/reward/${input.rewardId}`, { reward: payload });
+    }
+    catch (error) {
+        throw formatApiError(error, "ol_reward_update");
+    }
+}
+export async function rewardActivate(input) {
+    const storeCode = getStoreCode(input.storeCode);
+    try {
+        await apiPost(`/${storeCode}/reward/${input.rewardId}/activate`);
+    }
+    catch (error) {
+        throw formatApiError(error, "ol_reward_activate");
+    }
+}
+export async function rewardDeactivate(input) {
+    const storeCode = getStoreCode(input.storeCode);
+    try {
+        await apiPost(`/${storeCode}/reward/${input.rewardId}/deactivate`);
+    }
+    catch (error) {
+        throw formatApiError(error, "ol_reward_deactivate");
+    }
+}
+export async function rewardBuy(input) {
+    const storeCode = getStoreCode(input.storeCode);
+    // API requires quantity - default to 1 if not provided
+    const payload = omitUndefined({
+        customerId: input.memberId,
+        quantity: input.quantity ?? 1,
+        couponValue: input.couponValue,
+        withoutPoints: input.withoutPoints,
+    });
+    try {
+        const response = await apiPost(`/${storeCode}/reward/${input.rewardId}/buy`, payload);
+        // API returns array of issued rewards
+        const firstIssued = Array.isArray(response) ? response[0] : response;
+        return {
+            issuedRewardId: firstIssued?.issuedRewardId || "",
+            couponCode: firstIssued?.couponCode,
+        };
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        if (errorMessage.includes("NotEnoughPoints") || errorMessage.includes("insufficient")) {
+            throw new OpenLoyaltyError({
+                code: "INSUFFICIENT_BALANCE",
+                message: "Member does not have enough points to purchase this reward",
+                hint: `Use points_get_balance(memberId: "${input.memberId}") to check available balance. Then use reward_get(rewardId: "${input.rewardId}") to see the costInPoints required.`,
+                relatedTool: "ol_reward_buy",
+            });
+        }
+        throw formatApiError(error, "ol_reward_buy");
+    }
+}
+export async function rewardRedeem(input) {
+    const storeCode = getStoreCode(input.storeCode);
+    try {
+        const response = await apiPost(`/${storeCode}/member/${input.memberId}/reward/redeem`, { couponCode: input.couponCode });
+        return { code: response.code || input.couponCode, used: true };
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        if (errorMessage.includes("CouponDoesNotExist")) {
+            throw new OpenLoyaltyError({
+                code: "COUPON_NOT_FOUND",
+                message: `Coupon '${input.couponCode}' does not exist`,
+                hint: `Verify the coupon code is correct. Use reward_buy to purchase a reward and obtain a valid coupon code.`,
+                relatedTool: "ol_reward_redeem",
+            });
+        }
+        if (errorMessage.includes("CouponAlreadyUsed")) {
+            throw new OpenLoyaltyError({
+                code: "COUPON_ALREADY_USED",
+                message: `Coupon '${input.couponCode}' has already been redeemed`,
+                hint: `Each coupon can only be used once. The member may need to purchase another reward to get a new coupon.`,
+                relatedTool: "ol_reward_redeem",
+            });
+        }
+        if (errorMessage.includes("CouponIsExpired")) {
+            throw new OpenLoyaltyError({
+                code: "COUPON_EXPIRED",
+                message: `Coupon '${input.couponCode}' has expired`,
+                hint: `Coupons have a validity period. The member will need to purchase a new reward for a fresh coupon.`,
+                relatedTool: "ol_reward_redeem",
+            });
+        }
+        throw formatApiError(error, "ol_reward_redeem");
+    }
+}
+export async function rewardCategoryList(input) {
+    const storeCode = getStoreCode(input.storeCode);
+    const params = new URLSearchParams();
+    if (input.page)
+        params.append("_page", String(input.page));
+    if (input.perPage)
+        params.append("_itemsOnPage", String(input.perPage));
+    if (input.active !== undefined)
+        params.append("active", String(input.active));
+    const queryString = params.toString();
+    const url = `/${storeCode}/rewardCategory${queryString ? `?${queryString}` : ""}`;
+    try {
+        const response = await apiGet(url);
+        const items = response.items || response.categories || [];
+        const categories = items.map((c) => {
+            const cat = c;
+            return {
+                categoryId: (cat.rewardCategoryId || cat.categoryId),
+                name: cat.name,
+                active: (cat.active ?? false),
+            };
+        });
+        return { categories };
+    }
+    catch (error) {
+        throw formatApiError(error, "ol_reward_category_list");
+    }
+}

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

@@ -0,0 +1,177 @@
+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 declare const rewardToolDefinitions: readonly [{
+    readonly name: "ol_reward_list";
+    readonly title: "Browse Rewards";
+    readonly description: string;
+    readonly readOnly: true;
+    readonly inputSchema: {
+        storeCode: import("zod").ZodOptional<import("zod").ZodString>;
+        page: import("zod").ZodOptional<import("zod").ZodNumber>;
+        perPage: import("zod").ZodOptional<import("zod").ZodNumber>;
+        active: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        type: import("zod").ZodOptional<import("zod").ZodEnum<["static_coupon", "dynamic_coupon", "conversion_coupon", "material", "fortune_wheel"]>>;
+        categoryId: import("zod").ZodOptional<import("zod").ZodString>;
+    };
+    readonly handler: typeof rewardList;
+}, {
+    readonly name: "ol_reward_create";
+    readonly title: "Create New Reward";
+    readonly description: string;
+    readonly readOnly: false;
+    readonly inputSchema: {
+        storeCode: import("zod").ZodOptional<import("zod").ZodString>;
+        translations: import("zod").ZodObject<{
+            en: import("zod").ZodObject<{
+                name: import("zod").ZodString;
+            }, "strip", import("zod").ZodTypeAny, {
+                name: string;
+            }, {
+                name: string;
+            }>;
+        }, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{
+            en: import("zod").ZodObject<{
+                name: import("zod").ZodString;
+            }, "strip", import("zod").ZodTypeAny, {
+                name: string;
+            }, {
+                name: string;
+            }>;
+        }, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{
+            en: import("zod").ZodObject<{
+                name: import("zod").ZodString;
+            }, "strip", import("zod").ZodTypeAny, {
+                name: string;
+            }, {
+                name: string;
+            }>;
+        }, import("zod").ZodTypeAny, "passthrough">>;
+        reward: import("zod").ZodEnum<["static_coupon", "dynamic_coupon", "conversion_coupon", "material", "fortune_wheel"]>;
+        activity: import("zod").ZodObject<{
+            from: import("zod").ZodString;
+            to: import("zod").ZodString;
+        }, "strip", import("zod").ZodTypeAny, {
+            from: string;
+            to: string;
+        }, {
+            from: string;
+            to: string;
+        }>;
+        visibility: import("zod").ZodObject<{
+            from: import("zod").ZodString;
+            to: import("zod").ZodString;
+        }, "strip", import("zod").ZodTypeAny, {
+            from: string;
+            to: string;
+        }, {
+            from: string;
+            to: string;
+        }>;
+        usageLimit: import("zod").ZodObject<{
+            perUser: import("zod").ZodNumber;
+            general: import("zod").ZodOptional<import("zod").ZodNumber>;
+        }, "strip", import("zod").ZodTypeAny, {
+            perUser: number;
+            general?: number | undefined;
+        }, {
+            perUser: number;
+            general?: number | undefined;
+        }>;
+        costInPoints: import("zod").ZodOptional<import("zod").ZodNumber>;
+        usageInstruction: import("zod").ZodOptional<import("zod").ZodString>;
+        active: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        categories: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+        levels: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+        segments: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+        target: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodEnum<["level", "segment"]>>>;
+        couponValue: import("zod").ZodOptional<import("zod").ZodNumber>;
+        couponValueType: import("zod").ZodOptional<import("zod").ZodEnum<["money", "percentage"]>>;
+        daysValid: import("zod").ZodOptional<import("zod").ZodNumber>;
+    };
+    readonly handler: typeof rewardCreate;
+}, {
+    readonly name: "ol_reward_get";
+    readonly title: "Get Reward Details";
+    readonly description: "Get full reward details including configuration, targeting, and coupon settings.";
+    readonly readOnly: true;
+    readonly inputSchema: {
+        storeCode: import("zod").ZodOptional<import("zod").ZodString>;
+        rewardId: import("zod").ZodString;
+    };
+    readonly handler: typeof rewardGet;
+}, {
+    readonly name: "ol_reward_update";
+    readonly title: "Update Reward";
+    readonly description: "Update reward configuration. Cannot change reward type after creation.";
+    readonly readOnly: false;
+    readonly inputSchema: {
+        storeCode: import("zod").ZodOptional<import("zod").ZodString>;
+        rewardId: import("zod").ZodString;
+        name: import("zod").ZodOptional<import("zod").ZodString>;
+        costInPoints: import("zod").ZodOptional<import("zod").ZodNumber>;
+        description: import("zod").ZodOptional<import("zod").ZodString>;
+        active: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        categories: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+        levels: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+        segments: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+    };
+    readonly handler: typeof rewardUpdate;
+}, {
+    readonly name: "ol_reward_activate";
+    readonly title: "Activate Reward";
+    readonly description: "Activate a reward, making it available for members to redeem.";
+    readonly readOnly: false;
+    readonly inputSchema: {
+        storeCode: import("zod").ZodOptional<import("zod").ZodString>;
+        rewardId: import("zod").ZodString;
+    };
+    readonly handler: typeof rewardActivate;
+}, {
+    readonly name: "ol_reward_deactivate";
+    readonly title: "Deactivate Reward";
+    readonly description: "Deactivate a reward, hiding it from members. Already purchased rewards remain valid.";
+    readonly readOnly: false;
+    readonly inputSchema: {
+        storeCode: import("zod").ZodOptional<import("zod").ZodString>;
+        rewardId: import("zod").ZodString;
+    };
+    readonly handler: typeof rewardDeactivate;
+}, {
+    readonly name: "ol_reward_buy";
+    readonly title: "Redeem Reward for Member";
+    readonly description: string;
+    readonly readOnly: false;
+    readonly inputSchema: {
+        storeCode: import("zod").ZodOptional<import("zod").ZodString>;
+        rewardId: import("zod").ZodString;
+        memberId: import("zod").ZodString;
+        quantity: import("zod").ZodOptional<import("zod").ZodNumber>;
+        couponValue: import("zod").ZodOptional<import("zod").ZodNumber>;
+        withoutPoints: import("zod").ZodOptional<import("zod").ZodBoolean>;
+    };
+    readonly handler: typeof rewardBuy;
+}, {
+    readonly name: "ol_reward_redeem";
+    readonly title: "Use Coupon Code";
+    readonly description: string;
+    readonly readOnly: false;
+    readonly inputSchema: {
+        storeCode: import("zod").ZodOptional<import("zod").ZodString>;
+        memberId: import("zod").ZodString;
+        couponCode: import("zod").ZodString;
+    };
+    readonly handler: typeof rewardRedeem;
+}, {
+    readonly name: "ol_reward_category_list";
+    readonly title: "List Reward Categories";
+    readonly description: "List reward categories. Use categoryId when creating or filtering rewards.";
+    readonly readOnly: true;
+    readonly inputSchema: {
+        storeCode: import("zod").ZodOptional<import("zod").ZodString>;
+        page: import("zod").ZodOptional<import("zod").ZodNumber>;
+        perPage: import("zod").ZodOptional<import("zod").ZodNumber>;
+        active: import("zod").ZodOptional<import("zod").ZodBoolean>;
+    };
+    readonly handler: typeof rewardCategoryList;
+}];

package/dist/tools/reward/index.js

@@ -0,0 +1,90 @@
+// Re-export schemas
+export { RewardListInputSchema, RewardCreateInputSchema, RewardGetInputSchema, RewardUpdateInputSchema, RewardIdInputSchema, RewardBuyInputSchema, RewardRedeemInputSchema, RewardCategoryListInputSchema, } from "./schemas.js";
+// Re-export handlers
+export { rewardList, rewardCreate, rewardGet, rewardUpdate, rewardActivate, rewardDeactivate, rewardBuy, rewardRedeem, rewardCategoryList, } from "./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";
+// Tool definitions
+export const rewardToolDefinitions = [
+    {
+        name: "ol_reward_list",
+        title: "Browse Rewards",
+        description: "List available rewards. Use reward_get for full details or reward_buy to redeem. " +
+            "Filter by type, active status, or category.",
+        readOnly: true,
+        inputSchema: RewardListInputSchema,
+        handler: rewardList,
+    },
+    {
+        name: "ol_reward_create",
+        title: "Create New Reward",
+        description: "Create a new reward that members can redeem with points. " +
+            "REQUIRED: translations.en.name, reward (type), activity {from,to}, visibility {from,to}. " +
+            "Coupon types should include usageLimit.perUser. " +
+            "Types: static_coupon (fixed discount), dynamic_coupon (variable value set at purchase), " +
+            "material (physical goods), conversion_coupon (converts points), fortune_wheel (gamified). " +
+            "Returns rewardId.",
+        readOnly: false,
+        inputSchema: RewardCreateInputSchema,
+        handler: rewardCreate,
+    },
+    {
+        name: "ol_reward_get",
+        title: "Get Reward Details",
+        description: "Get full reward details including configuration, targeting, and coupon settings.",
+        readOnly: true,
+        inputSchema: RewardGetInputSchema,
+        handler: rewardGet,
+    },
+    {
+        name: "ol_reward_update",
+        title: "Update Reward",
+        description: "Update reward configuration. Cannot change reward type after creation.",
+        readOnly: false,
+        inputSchema: RewardUpdateInputSchema,
+        handler: rewardUpdate,
+    },
+    {
+        name: "ol_reward_activate",
+        title: "Activate Reward",
+        description: "Activate a reward, making it available for members to redeem.",
+        readOnly: false,
+        inputSchema: RewardIdInputSchema,
+        handler: rewardActivate,
+    },
+    {
+        name: "ol_reward_deactivate",
+        title: "Deactivate Reward",
+        description: "Deactivate a reward, hiding it from members. Already purchased rewards remain valid.",
+        readOnly: false,
+        inputSchema: RewardIdInputSchema,
+        handler: rewardDeactivate,
+    },
+    {
+        name: "ol_reward_buy",
+        title: "Redeem Reward for Member",
+        description: "Purchase reward for member, deducting points. Returns issuedRewardId and couponCode if applicable. " +
+            "Use reward_redeem to mark the coupon as used.",
+        readOnly: false,
+        inputSchema: RewardBuyInputSchema,
+        handler: rewardBuy,
+    },
+    {
+        name: "ol_reward_redeem",
+        title: "Use Coupon Code",
+        description: "Mark coupon as used. Validates coupon exists, belongs to member, and is active. " +
+            "Fails if coupon is expired, already used, or doesn't exist.",
+        readOnly: false,
+        inputSchema: RewardRedeemInputSchema,
+        handler: rewardRedeem,
+    },
+    {
+        name: "ol_reward_category_list",
+        title: "List Reward Categories",
+        description: "List reward categories. Use categoryId when creating or filtering rewards.",
+        readOnly: true,
+        inputSchema: RewardCategoryListInputSchema,
+        handler: rewardCategoryList,
+    },
+];