mcp-prqx-pricer 1.0.12 → 1.0.13

package/README.md

@@ -0,0 +1,3 @@
+# prqx-mcp-pricer-poc
+
+A proof of concept for a ModelContextProtocol (MCP Server) to encapsulate the calls to the PRQX Pricer API.

package/build/index.js

@@ -13,25 +13,26 @@ const getProductionInventory_1 = require("./tools/getProductionInventory");
 const getPricingGroups_1 = require("./tools/getPricingGroups");
 const createPricingGroup_1 = require("./tools/createPricingGroup");
 const deletePricingGroups_1 = require("./tools/deletePricingGroups");
+const updatePricingGroup_1 = require("./tools/updatePricingGroup");
 class PrqxMcpServer {
     server;
     axiosInstance;
     tools = [];
     constructor() {
-        console.error('[Setup] Initializing MCP server...');
+        console.error("[Setup] Initializing MCP server...");
         this.server = new index_js_1.Server({
-            name: 'PrqxMcpServer',
-            version: '1.0.0',
+            name: "PrqxMcpServer",
+            version: "1.0.0",
         }, {
             capabilities: {
-                tools: {}
-            }
+                tools: {},
+            },
         });
         this.axiosInstance = axios_1.default.create({
-            baseURL: 'https://pricer-svc.dev.pricerqx.com/',
+            baseURL: "https://pricer-svc.dev.pricerqx.com/",
             headers: {
-                'Content-Type': 'application/json',
-                'Authorization': 'Bearer ' + process.env.TOKEN
+                "Content-Type": "application/json",
+                Authorization: "Bearer " + process.env.TOKEN,
             },
         });
         this.tools.push(new getProductions_1.GetProductionsTool());
@@ -39,22 +40,23 @@ class PrqxMcpServer {
         this.tools.push(new getPricingGroups_1.GetPricingGroupsTool());
         this.tools.push(new createPricingGroup_1.CreatePricingGroupTool());
         this.tools.push(new deletePricingGroups_1.DeletePricingGroupsTool());
+        this.tools.push(new updatePricingGroup_1.UpdatePricingGroupTool());
         this.setupToolHandlers();
         this.server.onerror = (error) => {
-            console.error('[Error] MCP server error:', error);
+            console.error("[Error] MCP server error:", error);
         };
-        process.on('SIGINT', async () => {
-            console.error('[Info] MCP server shutting down...');
+        process.on("SIGINT", async () => {
+            console.error("[Info] MCP server shutting down...");
             await this.server.close();
             process.exit(0);
         });
     }
     setupToolHandlers() {
         this.server.setRequestHandler(types_js_1.ListToolsRequestSchema, async () => ({
-            tools: this.tools
+            tools: this.tools,
         }));
         this.server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
-            const tool = this.tools.find(tool => tool.name === request.params.name);
+            const tool = this.tools.find((tool) => tool.name === request.params.name);
             if (!tool) {
                 throw new types_js_1.McpError(types_js_1.ErrorCode.MethodNotFound, `Tool name ${request.params.name} is not supported`);
             }
@@ -64,7 +66,7 @@ class PrqxMcpServer {
     async run() {
         const transport = new stdio_js_1.StdioServerTransport();
         await this.server.connect(transport);
-        console.error('[Info] MCP server started !!');
+        console.error("[Info] MCP server started !!");
     }
 }
 new PrqxMcpServer().run();

package/build/tools/createPricingGroup.js

@@ -150,7 +150,9 @@ class CreatePricingGroupTool {
                     ceilingPricingMethod: ceilingPricingMethod,
                     noCompPricingMethod: noCompPricingMethod
                 },
-                marketGroupCriteria: {},
+                marketGroupCriteria: {
+                    sections: []
+                },
                 pricingGroupRequestRanks: pricingGroupRequestRanks
             };
             console.error('[API] Create Pricing Group with arguments:', args);

package/build/tools/deletePricingGroups.js

@@ -3,31 +3,31 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.DeletePricingGroupsTool = void 0;
 const types_js_1 = require("@modelcontextprotocol/sdk/types.js");
 class DeletePricingGroupsTool {
-    name = 'DeletePricingGroups';
-    description = 'Delete multiple pricing groups in bulk';
+    name = "DeletePricingGroups";
+    description = "Delete multiple pricing groups in bulk";
     inputSchema = {
-        type: 'object',
+        type: "object",
         properties: {
             pricingGroupIds: {
-                type: 'array',
-                description: 'Array of IDs (numbers) of the pricing groups that will be deleted. They can belong to multiple productions.'
-            }
+                type: "array",
+                description: "Array of IDs (numbers) of the pricing groups that will be deleted. They can belong to multiple productions.",
+            },
         },
-        required: ['pricingGroupIds']
+        required: ["pricingGroupIds"],
     };
     async toolHandler(request, axiosInstance) {
         try {
             const args = request.params.arguments;
             if (!args) {
-                throw new Error('Missing argument pricingGroupIds');
+                throw new Error("Missing argument pricingGroupIds");
             }
-            console.error('[API] Delete Pricing Group with arguments:', args);
+            console.error("[API] Delete Pricing Group with arguments:", args);
             const response = await axiosInstance.delete(`/v2/client/pricing-group/bulk`, { data: args });
-            return { content: [{ type: 'text', text: 'Operation Completed!' }] };
+            return { content: [{ type: "text", text: "Operation Completed!" }] };
         }
         catch (error) {
             if (error instanceof Error) {
-                console.error('Error in Delete Pricing Groups:', error);
+                console.error("Error in Delete Pricing Groups:", error);
                 throw new types_js_1.McpError(types_js_1.ErrorCode.InternalError, `Failed to delete pricing groups: ${error.message}`);
             }
             throw error;

package/build/tools/updatePricingGroup.js

@@ -0,0 +1,194 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UpdatePricingGroupTool = void 0;
+const types_js_1 = require("@modelcontextprotocol/sdk/types.js");
+const pricingGroup_1 = require("../types/pricingGroup");
+class UpdatePricingGroupTool {
+    name = "UpdatePricingGroup";
+    description = "Allows to update any individual property of an existing pricing group";
+    inputSchema = {
+        type: "object",
+        properties: {
+            pricingGroupId: {
+                type: "number",
+                description: "ID of the pricing group to modify",
+            },
+            name: {
+                type: "string",
+                description: "Name of the pricing group",
+            },
+            ceilingPrice: {
+                type: "number",
+                description: "Maximum price that the pricing group tickets can have",
+            },
+            floorPrice: {
+                type: "number",
+                description: "Minimum price that the pricing group tickets can have",
+            },
+            pricingGroupMode: {
+                type: "string",
+                description: "(AutoPrice or SimulationOnly) Mode of the pricing group",
+            },
+            amount: {
+                type: "number",
+                description: "Amount used to price the anchor ticket of the pricing group based on the first market comparable",
+            },
+            increment: {
+                type: "string",
+                description: "(increase or decrease) Decides if the amount is applied to increase or decrease the price of the anchor ticket of the pricing group based on the first market comparable",
+            },
+            incrementMethod: {
+                type: "string",
+                description: "( % or $ ) Decides if the amount is applied as a percentage or a dollar amount",
+            },
+            offsetAmount: {
+                type: "number",
+                description: "Offset amount used to price the other tickets in the group based of the previously ranked ticket",
+            },
+            offsetIncrement: {
+                type: "string",
+                description: "(increase or decrease) Decides if the offset amount is applied to increase or decrease the price of the other tickets in the group based of the previously ranked ticket",
+            },
+            offsetIncrementMethod: {
+                type: "string",
+                description: "( % or $ ) Decides if the offset amount is applied as a percentage or a dollar amount",
+            },
+            enableShareOptions: {
+                type: "boolean",
+                description: "Decides if the pricing group will control the sharing of tickets in a marketplace or not",
+            },
+            shareOptionsType: {
+                type: "string",
+                description: "(all or custom) Decides if we use custom parameters to share the tickets in the group or if we share them all. Default all.",
+            },
+            shareAnchor: {
+                type: "boolean",
+                description: "Controls if the anchor ticket of the pricing group will be shared or not",
+            },
+            customSharingAmount: {
+                type: "number",
+                description: "Custom sharing amount use to determine which tickets to share of this pricing group",
+            },
+            customSharingMethod: {
+                type: "string",
+                description: "( $ or % ) Decides if the custom sharing amount is applied as a percentage or a dollar amount.",
+            },
+            applyCeilingOnlyToAnchor: {
+                type: "boolean",
+                description: "Decides if the ceiling price will be applied only to the anchor ticket of the pricing group",
+            },
+            applyFloorOnlyToAnchor: {
+                type: "boolean",
+                description: "Decides if the floor price will be applied only to the anchor ticket of the pricing group",
+            },
+            floorPricingMethod: {
+                type: "string",
+                description: "(standard, variable, useFloor or floorRandomize) Decides what method to apply for pricing when the market comparable for the pricing group hits the floor price",
+            },
+            ceilingPricingMethod: {
+                type: "string",
+                description: "(standard, variable, useCeiling or ceilingRandomize) Decides what method to apply for pricing when the market comparable for the pricing group hits the ceiling price",
+            },
+            noCompPricingMethod: {
+                type: "string",
+                description: "(standard, variable, ceiling, freezePricing, useFloorForAnchor, useCeilingForAnchor, useCeiling, ceilingRandomize) Decides what method to apply for pricing when there is no market comparables for the pricing group",
+            },
+            pricingGroupRequestRanks: {
+                type: "array",
+                description: 'Array of objects containing pricing group request ranks starting at 0 (anchor ticket). i.e [{"ticketGroupId": 1, "rank": 0},...]',
+            },
+        },
+        mandatory: ["pricingGroupId"],
+    };
+    toolHandler = async (request, httpClient) => {
+        try {
+            const pricingGroupId = request?.params?.arguments
+                ?.pricingGroupId;
+            if (!pricingGroupId) {
+                throw new Error("Missing argument pricingGroupId");
+            }
+            const originalResponse = await httpClient.get(`/v2/client/pricing-group/${pricingGroupId}`);
+            if (originalResponse.status !== 200) {
+                throw new Error(`API error: ${originalResponse.statusText}`);
+            }
+            if (!originalResponse.data) {
+                throw new Error(`Pricing group ${pricingGroupId} not found`);
+            }
+            const originalData = originalResponse.data;
+            const modifyArgs = {
+                productionId: originalData.productionId,
+                name: request?.params?.arguments?.name ?? originalData.name,
+                ceilingPrice: request?.params?.arguments?.ceilingPrice ??
+                    originalData.ceilingPrice,
+                floorPrice: request?.params?.arguments?.floorPrice ??
+                    originalData.floorPrice,
+                pricingGroupRequestType: (request?.params?.arguments
+                    ?.pricingGroupRequestType ??
+                    originalData.isAutoPricingEnabled)
+                    ? pricingGroup_1.PricingGroupRequestType.AutoPrice
+                    : pricingGroup_1.PricingGroupRequestType.SimulationOnly,
+                ruleSet: {
+                    amount: request?.params?.arguments?.amount ??
+                        originalData.ruleSet.amount,
+                    increment: request?.params?.arguments?.increment ??
+                        originalData.ruleSet.increment,
+                    incrementMethod: request?.params?.arguments?.incrementMethod ??
+                        originalData.ruleSet.incrementMethod,
+                    offsetAmount: request?.params?.arguments?.offsetAmount ??
+                        originalData.ruleSet.offsetAmount,
+                    offsetIncrement: request?.params?.arguments?.offsetIncrement ??
+                        originalData.ruleSet.offsetIncrement,
+                    offsetIncrementMethod: request?.params?.arguments?.offsetIncrementMethod ??
+                        originalData.ruleSet.offsetIncrementMethod,
+                    enableShareOptions: request?.params?.arguments?.enableShareOptions ??
+                        originalData.ruleSet.enableShareOptions,
+                    shareOptionsType: request?.params?.arguments
+                        ?.shareOptionsType ??
+                        originalData.ruleSet.shareOptionsType,
+                    shareAnchor: request?.params?.arguments?.shareAnchor ??
+                        originalData.ruleSet.shareAnchor,
+                    customSharingAmount: request?.params?.arguments?.customSharingAmount ??
+                        originalData.ruleSet.customSharingAmount,
+                    customSharingMethod: request?.params?.arguments
+                        ?.customSharingMethod ??
+                        originalData.ruleSet.customSharingMethod,
+                    applyCeilingOnlyToAnchor: request?.params?.arguments?.applyCeilingOnlyToAnchor ??
+                        originalData.ruleSet.applyCeilingOnlyToAnchor,
+                    applyFloorOnlyToAnchor: request?.params?.arguments?.applyFloorOnlyToAnchor ??
+                        originalData.ruleSet.applyFloorOnlyToAnchor,
+                    floorPricingMethod: request?.params?.arguments
+                        ?.floorPricingMethod ??
+                        originalData.ruleSet.floorPricingMethod,
+                    ceilingPricingMethod: request?.params?.arguments
+                        ?.ceilingPricingMethod ??
+                        originalData.ruleSet.ceilingPricingMethod,
+                    noCompPricingMethod: request?.params?.arguments
+                        ?.noCompPricingMethod ??
+                        originalData.ruleSet.noCompPricingMethod,
+                },
+                pricingGroupRequestRanks: request?.params?.arguments
+                    ?.pricingGroupRequestRanks ?? originalData.pricingGroupTickets?.map((ticket) => ({
+                    ticketGroupId: ticket.ticketGroupId,
+                    rank: ticket.rank
+                })),
+                marketGroupCriteria: originalData.marketGroupCriteria,
+            };
+            console.error("[API] Update Pricing Group:", modifyArgs);
+            const response = await httpClient.put(`/v2/client/pricing-group/${pricingGroupId}`, modifyArgs);
+            if (response.status !== 200) {
+                throw new Error(`API error: ${response.statusText}`);
+            }
+            return {
+                content: [{ type: "text", text: JSON.stringify([response.data]) }],
+            };
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                console.error("Error in Update Pricing Group:", error);
+                throw new types_js_1.McpError(types_js_1.ErrorCode.InternalError, `Failed to update pricing group: ${error.message}`);
+            }
+            throw error;
+        }
+    };
+}
+exports.UpdatePricingGroupTool = UpdatePricingGroupTool;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mcp-prqx-pricer",
-  "version": "1.0.12",
+  "version": "1.0.13",
   "description": "",
   "main": "index.js",
   "bin": {

package/src/index.ts

@@ -1,83 +1,95 @@
 #!/usr/bin/env node
-import {Server} from "@modelcontextprotocol/sdk/server/index.js";
-import {StdioServerTransport} from "@modelcontextprotocol/sdk/server/stdio.js";
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import {
-    CallToolRequest,
-    CallToolRequestSchema,
-    ErrorCode,
-    ListToolsRequestSchema,
-    McpError,
-  } from '@modelcontextprotocol/sdk/types.js';
-import axios from 'axios';
+  CallToolRequest,
+  CallToolRequestSchema,
+  ErrorCode,
+  ListToolsRequestSchema,
+  McpError,
+} from "@modelcontextprotocol/sdk/types.js";
+import axios from "axios";
 import { McpTool } from "./types/tool";
 import { GetProductionsTool } from "./tools/getProductions";
 import { GetProductionInventoryTool } from "./tools/getProductionInventory";
 import { GetPricingGroupsTool } from "./tools/getPricingGroups";
 import { CreatePricingGroupTool } from "./tools/createPricingGroup";
 import { DeletePricingGroupsTool } from "./tools/deletePricingGroups";
+import { UpdatePricingGroupTool } from "./tools/updatePricingGroup";
 
-  class PrqxMcpServer{
-    private server: Server;
-    private axiosInstance;
-    private tools: McpTool[] = [];
+class PrqxMcpServer {
+  private server: Server;
+  private axiosInstance;
+  private tools: McpTool[] = [];
 
-    constructor() {
-      console.error('[Setup] Initializing MCP server...');
-        this.server = new Server({
-        name: 'PrqxMcpServer',
-        version: '1.0.0',
+  constructor() {
+    console.error("[Setup] Initializing MCP server...");
+    this.server = new Server(
+      {
+        name: "PrqxMcpServer",
+        version: "1.0.0",
       },
-    {
+      {
         capabilities: {
-            tools:{}
-        }
+          tools: {},
+        },
+      }
+    );
+
+    this.axiosInstance = axios.create({
+      baseURL: "https://pricer-svc.dev.pricerqx.com/",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: "Bearer " + process.env.TOKEN,
+      },
     });
 
-      this.axiosInstance = axios.create({
-        baseURL: 'https://pricer-svc.dev.pricerqx.com/',
-        headers: {
-          'Content-Type': 'application/json',
-          'Authorization': 'Bearer ' + process.env.TOKEN
-        },
-      });
+    this.tools.push(new GetProductionsTool());
+    this.tools.push(new GetProductionInventoryTool());
+    this.tools.push(new GetPricingGroupsTool());
+    this.tools.push(new CreatePricingGroupTool());
+    this.tools.push(new DeletePricingGroupsTool());
+    this.tools.push(new UpdatePricingGroupTool());
+    this.setupToolHandlers();
+    this.server.onerror = (error) => {
+      console.error("[Error] MCP server error:", error);
+    };
 
-      this.tools.push(new GetProductionsTool());
-      this.tools.push(new GetProductionInventoryTool());
-      this.tools.push(new GetPricingGroupsTool());
-      this.tools.push(new CreatePricingGroupTool());
-      this.tools.push(new DeletePricingGroupsTool());
-      this.setupToolHandlers();
-      this.server.onerror = (error) => {
-        console.error('[Error] MCP server error:', error);
-      };
+    process.on("SIGINT", async () => {
+      console.error("[Info] MCP server shutting down...");
+      await this.server.close();
+      process.exit(0);
+    });
+  }
 
-      process.on('SIGINT', async () => {
-        console.error('[Info] MCP server shutting down...');
-        await this.server.close();
-        process.exit(0);
-      });
-    }
-    
-    private setupToolHandlers() {
-        this.server.setRequestHandler(ListToolsRequestSchema, async () => ({
-            tools: this.tools
-        }));
+  private setupToolHandlers() {
+    this.server.setRequestHandler(ListToolsRequestSchema, async () => ({
+      tools: this.tools,
+    }));
 
-        this.server.setRequestHandler(CallToolRequestSchema, async (request: CallToolRequest) => {
-            const tool = this.tools.find(tool => tool.name === request.params.name);
-            if(!tool) {
-                throw new McpError(ErrorCode.MethodNotFound, `Tool name ${request.params.name} is not supported`);
-            }
+    this.server.setRequestHandler(
+      CallToolRequestSchema,
+      async (request: CallToolRequest) => {
+        const tool = this.tools.find(
+          (tool) => tool.name === request.params.name
+        );
+        if (!tool) {
+          throw new McpError(
+            ErrorCode.MethodNotFound,
+            `Tool name ${request.params.name} is not supported`
+          );
+        }
 
-            return await tool.toolHandler(request, this.axiosInstance);
-        });
-    }
+        return await tool.toolHandler(request, this.axiosInstance);
+      }
+    );
+  }
 
-    async run() {
-        const transport = new StdioServerTransport();
-        await this.server.connect(transport);
-        console.error('[Info] MCP server started !!');
-    }
+  async run() {
+    const transport = new StdioServerTransport();
+    await this.server.connect(transport);
+    console.error("[Info] MCP server started !!");
   }
+}
 
-  new PrqxMcpServer().run();
+new PrqxMcpServer().run();

package/src/tools/createPricingGroup.ts

@@ -153,7 +153,9 @@ export class CreatePricingGroupTool implements McpTool {
                     ceilingPricingMethod: ceilingPricingMethod,
                     noCompPricingMethod: noCompPricingMethod
                 },
-                marketGroupCriteria: {},
+                marketGroupCriteria: {
+                    sections: []
+                },
                 pricingGroupRequestRanks: pricingGroupRequestRanks
             };
             console.error('[API] Create Pricing Group with arguments:', args);

package/src/tools/deletePricingGroups.ts

@@ -1,36 +1,50 @@
-import { CallToolRequest, ErrorCode, McpError } from "@modelcontextprotocol/sdk/types.js";
+import {
+  CallToolRequest,
+  ErrorCode,
+  McpError,
+} from "@modelcontextprotocol/sdk/types.js";
 import { AxiosInstance } from "axios";
 import { McpTool } from "../types/tool";
 
 export class DeletePricingGroupsTool implements McpTool {
-    name = 'DeletePricingGroups';
-    description = 'Delete multiple pricing groups in bulk';
-    inputSchema = {
-        type: 'object',
-        properties: {
-            pricingGroupIds: {
-                type: 'array',
-                description: 'Array of IDs (numbers) of the pricing groups that will be deleted. They can belong to multiple productions.'
-            }
-        },
-        required: ['pricingGroupIds']
-    };
+  name = "DeletePricingGroups";
+  description = "Delete multiple pricing groups in bulk";
+  inputSchema = {
+    type: "object",
+    properties: {
+      pricingGroupIds: {
+        type: "array",
+        description:
+          "Array of IDs (numbers) of the pricing groups that will be deleted. They can belong to multiple productions.",
+      },
+    },
+    required: ["pricingGroupIds"],
+  };
 
-    async toolHandler(request: CallToolRequest, axiosInstance: AxiosInstance): Promise<any> {
-        try{
-            const args = request.params.arguments as { pricingGroupIds: [number] };
-            if (!args) {
-                throw new Error('Missing argument pricingGroupIds');
-            }
-            console.error('[API] Delete Pricing Group with arguments:', args);
-            const response = await axiosInstance.delete(`/v2/client/pricing-group/bulk`, {data: args});
-            return { content: [{ type: 'text', text: 'Operation Completed!' }] };
-        } catch (error) {
-            if (error instanceof Error) {
-                console.error('Error in Delete Pricing Groups:', error);
-                throw new McpError(ErrorCode.InternalError, `Failed to delete pricing groups: ${error.message}`);
-            }
-            throw error;
-        }
+  async toolHandler(
+    request: CallToolRequest,
+    axiosInstance: AxiosInstance
+  ): Promise<any> {
+    try {
+      const args = request.params.arguments as { pricingGroupIds: [number] };
+      if (!args) {
+        throw new Error("Missing argument pricingGroupIds");
+      }
+      console.error("[API] Delete Pricing Group with arguments:", args);
+      const response = await axiosInstance.delete(
+        `/v2/client/pricing-group/bulk`,
+        { data: args }
+      );
+      return { content: [{ type: "text", text: "Operation Completed!" }] };
+    } catch (error) {
+      if (error instanceof Error) {
+        console.error("Error in Delete Pricing Groups:", error);
+        throw new McpError(
+          ErrorCode.InternalError,
+          `Failed to delete pricing groups: ${error.message}`
+        );
+      }
+      throw error;
     }
-}
+  }
+}