@open-loyalty/mcp-server 1.0.0

package/dist/tools/reward.d.ts

@@ -0,0 +1,261 @@
+import { z } from "zod";
+import { Reward } from "../types/schemas/reward.js";
+export declare const RewardListInputSchema: {
+    storeCode: z.ZodOptional<z.ZodString>;
+    page: z.ZodOptional<z.ZodNumber>;
+    perPage: z.ZodOptional<z.ZodNumber>;
+    active: z.ZodOptional<z.ZodBoolean>;
+    type: z.ZodOptional<z.ZodEnum<["static_coupon", "dynamic_coupon", "conversion_coupon", "material", "fortune_wheel"]>>;
+    categoryId: z.ZodOptional<z.ZodString>;
+};
+export declare const RewardCreateInputSchema: {
+    storeCode: z.ZodOptional<z.ZodString>;
+    name: z.ZodString;
+    type: z.ZodEnum<["static_coupon", "dynamic_coupon", "conversion_coupon", "material", "fortune_wheel"]>;
+    costInPoints: z.ZodOptional<z.ZodNumber>;
+    description: z.ZodOptional<z.ZodString>;
+    usageInstruction: z.ZodOptional<z.ZodString>;
+    active: z.ZodOptional<z.ZodBoolean>;
+    categories: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    levels: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    segments: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    target: z.ZodOptional<z.ZodNullable<z.ZodEnum<["level", "segment"]>>>;
+    couponValue: z.ZodOptional<z.ZodNumber>;
+    couponValueType: z.ZodOptional<z.ZodEnum<["Money", "Percentage"]>>;
+    daysValid: z.ZodOptional<z.ZodNumber>;
+};
+export declare const RewardGetInputSchema: {
+    storeCode: z.ZodOptional<z.ZodString>;
+    rewardId: z.ZodString;
+};
+export declare const RewardUpdateInputSchema: {
+    storeCode: z.ZodOptional<z.ZodString>;
+    rewardId: z.ZodString;
+    name: z.ZodOptional<z.ZodString>;
+    costInPoints: z.ZodOptional<z.ZodNumber>;
+    description: z.ZodOptional<z.ZodString>;
+    active: z.ZodOptional<z.ZodBoolean>;
+    categories: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    levels: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    segments: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+};
+export declare const RewardIdInputSchema: {
+    storeCode: z.ZodOptional<z.ZodString>;
+    rewardId: z.ZodString;
+};
+export declare const RewardBuyInputSchema: {
+    storeCode: z.ZodOptional<z.ZodString>;
+    rewardId: z.ZodString;
+    memberId: z.ZodString;
+    quantity: z.ZodOptional<z.ZodNumber>;
+    couponValue: z.ZodOptional<z.ZodNumber>;
+    withoutPoints: z.ZodOptional<z.ZodBoolean>;
+};
+export declare const RewardRedeemInputSchema: {
+    storeCode: z.ZodOptional<z.ZodString>;
+    memberId: z.ZodString;
+    couponCode: z.ZodString;
+};
+export declare const RewardCategoryListInputSchema: {
+    storeCode: z.ZodOptional<z.ZodString>;
+    page: z.ZodOptional<z.ZodNumber>;
+    perPage: z.ZodOptional<z.ZodNumber>;
+    active: z.ZodOptional<z.ZodBoolean>;
+};
+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;
+    name: string;
+    type: string;
+    costInPoints?: number;
+    description?: string;
+    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;
+    }>;
+}>;
+export declare const rewardToolDefinitions: readonly [{
+    readonly name: "openloyalty_reward_list";
+    readonly description: string;
+    readonly inputSchema: {
+        storeCode: z.ZodOptional<z.ZodString>;
+        page: z.ZodOptional<z.ZodNumber>;
+        perPage: z.ZodOptional<z.ZodNumber>;
+        active: z.ZodOptional<z.ZodBoolean>;
+        type: z.ZodOptional<z.ZodEnum<["static_coupon", "dynamic_coupon", "conversion_coupon", "material", "fortune_wheel"]>>;
+        categoryId: z.ZodOptional<z.ZodString>;
+    };
+    readonly handler: typeof rewardList;
+}, {
+    readonly name: "openloyalty_reward_create";
+    readonly description: string;
+    readonly inputSchema: {
+        storeCode: z.ZodOptional<z.ZodString>;
+        name: z.ZodString;
+        type: z.ZodEnum<["static_coupon", "dynamic_coupon", "conversion_coupon", "material", "fortune_wheel"]>;
+        costInPoints: z.ZodOptional<z.ZodNumber>;
+        description: z.ZodOptional<z.ZodString>;
+        usageInstruction: z.ZodOptional<z.ZodString>;
+        active: z.ZodOptional<z.ZodBoolean>;
+        categories: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        levels: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        segments: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        target: z.ZodOptional<z.ZodNullable<z.ZodEnum<["level", "segment"]>>>;
+        couponValue: z.ZodOptional<z.ZodNumber>;
+        couponValueType: z.ZodOptional<z.ZodEnum<["Money", "Percentage"]>>;
+        daysValid: z.ZodOptional<z.ZodNumber>;
+    };
+    readonly handler: typeof rewardCreate;
+}, {
+    readonly name: "openloyalty_reward_get";
+    readonly description: "Get full reward details including configuration, targeting, and coupon settings.";
+    readonly inputSchema: {
+        storeCode: z.ZodOptional<z.ZodString>;
+        rewardId: z.ZodString;
+    };
+    readonly handler: typeof rewardGet;
+}, {
+    readonly name: "openloyalty_reward_update";
+    readonly description: "Update reward configuration. Cannot change reward type after creation.";
+    readonly inputSchema: {
+        storeCode: z.ZodOptional<z.ZodString>;
+        rewardId: z.ZodString;
+        name: z.ZodOptional<z.ZodString>;
+        costInPoints: z.ZodOptional<z.ZodNumber>;
+        description: z.ZodOptional<z.ZodString>;
+        active: z.ZodOptional<z.ZodBoolean>;
+        categories: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        levels: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        segments: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    };
+    readonly handler: typeof rewardUpdate;
+}, {
+    readonly name: "openloyalty_reward_activate";
+    readonly description: "Activate a reward, making it available for members to redeem.";
+    readonly inputSchema: {
+        storeCode: z.ZodOptional<z.ZodString>;
+        rewardId: z.ZodString;
+    };
+    readonly handler: typeof rewardActivate;
+}, {
+    readonly name: "openloyalty_reward_deactivate";
+    readonly description: "Deactivate a reward, hiding it from members. Already purchased rewards remain valid.";
+    readonly inputSchema: {
+        storeCode: z.ZodOptional<z.ZodString>;
+        rewardId: z.ZodString;
+    };
+    readonly handler: typeof rewardDeactivate;
+}, {
+    readonly name: "openloyalty_reward_buy";
+    readonly description: string;
+    readonly inputSchema: {
+        storeCode: z.ZodOptional<z.ZodString>;
+        rewardId: z.ZodString;
+        memberId: z.ZodString;
+        quantity: z.ZodOptional<z.ZodNumber>;
+        couponValue: z.ZodOptional<z.ZodNumber>;
+        withoutPoints: z.ZodOptional<z.ZodBoolean>;
+    };
+    readonly handler: typeof rewardBuy;
+}, {
+    readonly name: "openloyalty_reward_redeem";
+    readonly description: string;
+    readonly inputSchema: {
+        storeCode: z.ZodOptional<z.ZodString>;
+        memberId: z.ZodString;
+        couponCode: z.ZodString;
+    };
+    readonly handler: typeof rewardRedeem;
+}, {
+    readonly name: "openloyalty_reward_category_list";
+    readonly description: "List reward categories. Use categoryId when creating or filtering rewards.";
+    readonly inputSchema: {
+        storeCode: z.ZodOptional<z.ZodString>;
+        page: z.ZodOptional<z.ZodNumber>;
+        perPage: z.ZodOptional<z.ZodNumber>;
+        active: z.ZodOptional<z.ZodBoolean>;
+    };
+    readonly handler: typeof rewardCategoryList;
+}];

package/dist/tools/reward.js

@@ -0,0 +1,371 @@
+import { z } from "zod";
+import { apiGet, apiPost, apiPut } from "../client/http.js";
+import { RewardSchema, } from "../types/schemas/reward.js";
+import { formatApiError, OpenLoyaltyError } from "../utils/errors.js";
+import { getConfig } from "../config.js";
+// Input Schemas
+export const RewardListInputSchema = {
+    storeCode: z.string().optional().describe("Store code. If not provided, uses the default store code from configuration."),
+    page: z.number().optional().describe("Page number (default: 1)."),
+    perPage: z.number().optional().describe("Items per page (default: 10)."),
+    active: z.boolean().optional().describe("Filter by active status."),
+    type: z.enum(["static_coupon", "dynamic_coupon", "conversion_coupon", "material", "fortune_wheel"]).optional().describe("Filter by reward type."),
+    categoryId: z.string().optional().describe("Filter by category ID."),
+};
+export const RewardCreateInputSchema = {
+    storeCode: z.string().optional().describe("Store code. If not provided, uses the default store code from configuration."),
+    name: z.string().describe("Reward name (required, max 255 chars)."),
+    type: z.enum(["static_coupon", "dynamic_coupon", "conversion_coupon", "material", "fortune_wheel"]).describe("Reward type: static_coupon (fixed discount), dynamic_coupon (variable value), " +
+        "conversion_coupon (converts points to coupon), material (physical goods), fortune_wheel (gamified)."),
+    costInPoints: z.number().optional().describe("Points required to redeem this reward."),
+    description: z.string().optional().describe("Reward description."),
+    usageInstruction: z.string().optional().describe("Instructions for using the reward."),
+    active: z.boolean().optional().describe("Whether reward is active (default: false)."),
+    categories: z.array(z.string()).optional().describe("Array of category UUIDs."),
+    levels: z.array(z.string()).optional().describe("Array of tier level UUIDs that can see/redeem."),
+    segments: z.array(z.string()).optional().describe("Array of segment UUIDs that can see/redeem."),
+    target: z.enum(["level", "segment"]).nullable().optional().describe("Target type for visibility: level (tier-based), segment (segment-based), or null (all)."),
+    couponValue: z.number().optional().describe("Coupon value (required for static_coupon)."),
+    couponValueType: z.enum(["Money", "Percentage"]).optional().describe("Coupon value type."),
+    daysValid: z.number().optional().describe("Days the coupon remains valid after purchase."),
+};
+export const RewardGetInputSchema = {
+    storeCode: z.string().optional().describe("Store code. If not provided, uses the default store code from configuration."),
+    rewardId: z.string().describe("The reward ID (UUID) to retrieve."),
+};
+export const RewardUpdateInputSchema = {
+    storeCode: z.string().optional().describe("Store code. If not provided, uses the default store code from configuration."),
+    rewardId: z.string().describe("The reward ID (UUID) to update."),
+    name: z.string().optional().describe("Reward name."),
+    costInPoints: z.number().optional().describe("Points required to redeem."),
+    description: z.string().optional().describe("Reward description."),
+    active: z.boolean().optional().describe("Whether reward is active."),
+    categories: z.array(z.string()).optional().describe("Array of category UUIDs."),
+    levels: z.array(z.string()).optional().describe("Array of tier level UUIDs."),
+    segments: z.array(z.string()).optional().describe("Array of segment UUIDs."),
+};
+export const RewardIdInputSchema = {
+    storeCode: z.string().optional().describe("Store code. If not provided, uses the default store code from configuration."),
+    rewardId: z.string().describe("The reward ID (UUID)."),
+};
+export const RewardBuyInputSchema = {
+    storeCode: z.string().optional().describe("Store code. If not provided, uses the default store code from configuration."),
+    rewardId: z.string().describe("The reward ID (UUID) to purchase."),
+    memberId: z.string().describe("The member ID (UUID) purchasing the reward."),
+    quantity: z.number().optional().describe("Number of rewards to purchase (1-32, default: 1)."),
+    couponValue: z.number().optional().describe("Coupon value (for dynamic coupons)."),
+    withoutPoints: z.boolean().optional().describe("Admin only: skip points deduction."),
+};
+export const RewardRedeemInputSchema = {
+    storeCode: z.string().optional().describe("Store code. If not provided, uses the default store code from configuration."),
+    memberId: z.string().describe("The member ID (UUID) redeeming the coupon."),
+    couponCode: z.string().describe("The coupon code to redeem."),
+};
+export const RewardCategoryListInputSchema = {
+    storeCode: z.string().optional().describe("Store code. If not provided, uses the default store code from configuration."),
+    page: z.number().optional().describe("Page number (default: 1)."),
+    perPage: z.number().optional().describe("Items per page (default: 10)."),
+    active: z.boolean().optional().describe("Filter by active status."),
+};
+// Handler functions
+export async function rewardList(input) {
+    const config = getConfig();
+    const storeCode = input.storeCode || config.defaultStoreCode;
+    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, "openloyalty_reward_list");
+    }
+}
+export async function rewardCreate(input) {
+    const config = getConfig();
+    const storeCode = input.storeCode || config.defaultStoreCode;
+    const payload = {
+        name: input.name,
+        type: input.type,
+    };
+    if (input.costInPoints !== undefined)
+        payload.costInPoints = input.costInPoints;
+    if (input.description)
+        payload.description = input.description;
+    if (input.usageInstruction)
+        payload.usageInstruction = input.usageInstruction;
+    if (input.active !== undefined)
+        payload.active = input.active;
+    if (input.categories)
+        payload.categories = input.categories;
+    if (input.levels)
+        payload.levels = input.levels;
+    if (input.segments)
+        payload.segments = input.segments;
+    if (input.target !== undefined)
+        payload.target = input.target;
+    if (input.couponValue !== undefined)
+        payload.couponValue = input.couponValue;
+    if (input.couponValueType)
+        payload.couponValueType = input.couponValueType;
+    if (input.daysValid !== undefined)
+        payload.daysValid = input.daysValid;
+    try {
+        const response = await apiPost(`/${storeCode}/reward`, { reward: payload });
+        return {
+            rewardId: response.rewardId,
+            name: input.name,
+            costInPoints: input.costInPoints,
+        };
+    }
+    catch (error) {
+        throw formatApiError(error, "openloyalty_reward_create");
+    }
+}
+export async function rewardGet(input) {
+    const config = getConfig();
+    const storeCode = input.storeCode || config.defaultStoreCode;
+    try {
+        const response = await apiGet(`/${storeCode}/reward/${input.rewardId}`);
+        return RewardSchema.parse(response);
+    }
+    catch (error) {
+        throw formatApiError(error, "openloyalty_reward_get");
+    }
+}
+export async function rewardUpdate(input) {
+    const config = getConfig();
+    const storeCode = input.storeCode || config.defaultStoreCode;
+    const payload = {};
+    if (input.name)
+        payload.name = input.name;
+    if (input.costInPoints !== undefined)
+        payload.costInPoints = input.costInPoints;
+    if (input.description)
+        payload.description = input.description;
+    if (input.active !== undefined)
+        payload.active = input.active;
+    if (input.categories)
+        payload.categories = input.categories;
+    if (input.levels)
+        payload.levels = input.levels;
+    if (input.segments)
+        payload.segments = input.segments;
+    try {
+        await apiPut(`/${storeCode}/reward/${input.rewardId}`, { reward: payload });
+    }
+    catch (error) {
+        throw formatApiError(error, "openloyalty_reward_update");
+    }
+}
+export async function rewardActivate(input) {
+    const config = getConfig();
+    const storeCode = input.storeCode || config.defaultStoreCode;
+    try {
+        await apiPost(`/${storeCode}/reward/${input.rewardId}/activate`);
+    }
+    catch (error) {
+        throw formatApiError(error, "openloyalty_reward_activate");
+    }
+}
+export async function rewardDeactivate(input) {
+    const config = getConfig();
+    const storeCode = input.storeCode || config.defaultStoreCode;
+    try {
+        await apiPost(`/${storeCode}/reward/${input.rewardId}/deactivate`);
+    }
+    catch (error) {
+        throw formatApiError(error, "openloyalty_reward_deactivate");
+    }
+}
+export async function rewardBuy(input) {
+    const config = getConfig();
+    const storeCode = input.storeCode || config.defaultStoreCode;
+    const payload = {
+        customerId: input.memberId,
+    };
+    if (input.quantity)
+        payload.quantity = input.quantity;
+    if (input.couponValue !== undefined)
+        payload.couponValue = input.couponValue;
+    if (input.withoutPoints !== undefined)
+        payload.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: "openloyalty_reward_buy",
+            });
+        }
+        throw formatApiError(error, "openloyalty_reward_buy");
+    }
+}
+export async function rewardRedeem(input) {
+    const config = getConfig();
+    const storeCode = input.storeCode || config.defaultStoreCode;
+    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: "openloyalty_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: "openloyalty_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: "openloyalty_reward_redeem",
+            });
+        }
+        throw formatApiError(error, "openloyalty_reward_redeem");
+    }
+}
+export async function rewardCategoryList(input) {
+    const config = getConfig();
+    const storeCode = input.storeCode || config.defaultStoreCode;
+    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, "openloyalty_reward_category_list");
+    }
+}
+// Tool definitions
+export const rewardToolDefinitions = [
+    {
+        name: "openloyalty_reward_list",
+        description: "List available rewards. Use reward_get for full details or reward_buy to redeem. " +
+            "Filter by type, active status, or category.",
+        inputSchema: RewardListInputSchema,
+        handler: rewardList,
+    },
+    {
+        name: "openloyalty_reward_create",
+        description: "Create a new reward that members can redeem with points. " +
+            "Types: static_coupon (fixed discount), dynamic_coupon (variable value set at purchase), " +
+            "material (physical goods), conversion_coupon (converts points), fortune_wheel (gamified). " +
+            "Returns rewardId.",
+        inputSchema: RewardCreateInputSchema,
+        handler: rewardCreate,
+    },
+    {
+        name: "openloyalty_reward_get",
+        description: "Get full reward details including configuration, targeting, and coupon settings.",
+        inputSchema: RewardGetInputSchema,
+        handler: rewardGet,
+    },
+    {
+        name: "openloyalty_reward_update",
+        description: "Update reward configuration. Cannot change reward type after creation.",
+        inputSchema: RewardUpdateInputSchema,
+        handler: rewardUpdate,
+    },
+    {
+        name: "openloyalty_reward_activate",
+        description: "Activate a reward, making it available for members to redeem.",
+        inputSchema: RewardIdInputSchema,
+        handler: rewardActivate,
+    },
+    {
+        name: "openloyalty_reward_deactivate",
+        description: "Deactivate a reward, hiding it from members. Already purchased rewards remain valid.",
+        inputSchema: RewardIdInputSchema,
+        handler: rewardDeactivate,
+    },
+    {
+        name: "openloyalty_reward_buy",
+        description: "Purchase reward for member, deducting points. Returns issuedRewardId and couponCode if applicable. " +
+            "Use reward_redeem to mark the coupon as used.",
+        inputSchema: RewardBuyInputSchema,
+        handler: rewardBuy,
+    },
+    {
+        name: "openloyalty_reward_redeem",
+        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.",
+        inputSchema: RewardRedeemInputSchema,
+        handler: rewardRedeem,
+    },
+    {
+        name: "openloyalty_reward_category_list",
+        description: "List reward categories. Use categoryId when creating or filtering rewards.",
+        inputSchema: RewardCategoryListInputSchema,
+        handler: rewardCategoryList,
+    },
+];

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

@@ -0,0 +1 @@
+export {};