mcp-prqx-pricer 1.0.12 → 1.0.14

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

@@ -104,28 +104,34 @@ class CreatePricingGroupTool {
             if (!request?.params?.arguments) {
                 throw new Error('Missing arguments');
             }
+            const pricingGroupRequestRanks = request.params.arguments.pricingGroupRequestRanks;
+            const anchorTicketGroupId = pricingGroupRequestRanks.find(rank => rank.rank === 0)?.ticketGroupId;
+            if (!anchorTicketGroupId) {
+                throw new Error('Anchor ticket group ID is required');
+            }
+            const defaultsResponse = await httpClient.get('/v1/client/org-defaults/calculate-defaults/' + anchorTicketGroupId);
+            const defaults = defaultsResponse.data;
             const productionId = request.params.arguments.productionId;
             const name = request.params.arguments.name;
-            const ceilingPrice = request.params.arguments.ceilingPrice;
-            const floorPrice = request.params.arguments.floorPrice;
+            const ceilingPrice = request.params.arguments.ceilingPrice ?? defaults.ruleSet.ceiling;
+            const floorPrice = request.params.arguments.floorPrice ?? defaults.ruleSet.floor;
             const pricingGroupRequestType = request.params.arguments.pricingGroupMode;
-            const amount = request.params.arguments.amount;
-            const increment = request.params.arguments.increment;
-            const incrementMethod = request.params.arguments.incrementMethod;
-            const offsetAmount = request.params.arguments.offsetAmount;
-            const offsetIncrement = request.params.arguments.offsetIncrement;
-            const offsetIncrementMethod = request.params.arguments.offsetIncrementMethod;
-            const enableShareOptions = request.params.arguments.enableShareOptions;
-            const shareOptionsType = request.params.arguments.shareOptionsType;
-            const shareAnchor = request.params.arguments.shareAnchor;
-            const customSharingAmount = request.params.arguments.customSharingAmount;
-            const customSharingMethod = request.params.arguments.customSharingMethod;
-            const applyCeilingOnlyToAnchor = request.params.arguments.applyCeilingOnlyToAnchor;
-            const applyFloorOnlyToAnchor = request.params.arguments.applyFloorOnlyToAnchor;
-            const floorPricingMethod = request.params.arguments.floorPricingMethod;
-            const ceilingPricingMethod = request.params.arguments.ceilingPricingMethod;
-            const noCompPricingMethod = request.params.arguments.noCompPricingMethod;
-            const pricingGroupRequestRanks = request.params.arguments.pricingGroupRequestRanks;
+            const amount = request.params.arguments.amount ?? defaults.ruleSet.amount;
+            const increment = request.params.arguments.increment ?? defaults.ruleSet.increment;
+            const incrementMethod = request.params.arguments.incrementMethod ?? defaults.ruleSet.incrementMethod;
+            const offsetAmount = request.params.arguments.offsetAmount ?? defaults.ruleSet.offsetAmount;
+            const offsetIncrement = request.params.arguments.offsetIncrement ?? defaults.ruleSet.offsetIncrement;
+            const offsetIncrementMethod = request.params.arguments.offsetIncrementMethod ?? defaults.ruleSet.offsetIncrementMethod;
+            const enableShareOptions = request.params.arguments.enableShareOptions ?? defaults.ruleSet.enableShareOptions;
+            const shareOptionsType = request.params.arguments.shareOptionsType ?? defaults.ruleSet.shareOptionsType;
+            const shareAnchor = request.params.arguments.shareAnchor ?? defaults.ruleSet.shareAnchor;
+            const customSharingAmount = request.params.arguments.customSharingAmount ?? defaults.ruleSet.customSharingAmount;
+            const customSharingMethod = request.params.arguments.customSharingMethod ?? defaults.ruleSet.customSharingMethod;
+            const applyCeilingOnlyToAnchor = request.params.arguments.applyCeilingOnlyToAnchor ?? defaults.ruleSet.applyCeilingOnlyToAnchor;
+            const applyFloorOnlyToAnchor = request.params.arguments.applyFloorOnlyToAnchor ?? defaults.ruleSet.applyFloorOnlyToAnchor;
+            const floorPricingMethod = request.params.arguments.floorPricingMethod ?? defaults.ruleSet.floorPricingMethod;
+            const ceilingPricingMethod = request.params.arguments.ceilingPricingMethod ?? defaults.ruleSet.ceilingPricingMethod;
+            const noCompPricingMethod = request.params.arguments.noCompPricingMethod ?? defaults.ruleSet.noCompPricingMethod;
             const args = {
                 productionId: productionId,
                 name: name,
@@ -150,13 +156,25 @@ class CreatePricingGroupTool {
                     ceilingPricingMethod: ceilingPricingMethod,
                     noCompPricingMethod: noCompPricingMethod
                 },
-                marketGroupCriteria: {},
+                marketGroupCriteria: {
+                    sections: defaults?.marketGroupCriteria?.sections ?? [],
+                    validSplitsIncludeV2: defaults?.marketGroupCriteria?.validSplitsIncludeV2,
+                    validSplitsIncludeMax: defaults?.marketGroupCriteria?.validSplitsIncludeMax,
+                    deliveryMethodInclude: defaults?.marketGroupCriteria?.deliveryMethodInclude,
+                    attributesExclude: defaults?.marketGroupCriteria?.attributesExclude,
+                    lowerOutlierMethod: defaults?.marketGroupCriteria?.lowerOutlierMethod,
+                    lowerOutlierAmount: defaults?.marketGroupCriteria?.lowerOutlierAmount,
+                    lowerOutlierThreshold: defaults?.marketGroupCriteria?.lowerOutlierThreshold,
+                    includeSpeculativeTickets: defaults?.marketGroupCriteria?.includeSpeculativeTickets,
+                    isSplitsDynamic: defaults?.marketGroupCriteria?.isSplitsDynamic,
+                    rowRanges: defaults?.marketGroupCriteria?.rowRanges
+                },
                 pricingGroupRequestRanks: pricingGroupRequestRanks
             };
             console.error('[API] Create Pricing Group with arguments:', args);
             const response = await httpClient.post(`/v2/client/pricing-group`, args);
             if (response.status !== 200) {
-                throw new Error(`API error: ${response.statusText}`);
+                throw new Error("API error: " + response.statusText);
             }
             return { content: [{ type: 'text', text: JSON.stringify([response.data]) }] };
         }

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.14",
   "description": "",
   "main": "index.js",
   "bin": {

package/prompts/mcp-n8n-4.1-instructions.md

@@ -0,0 +1,37 @@
+#Role and Objective
+You are an Agent that can help ticket brokers to organize their 
+inventory in pricing groups (Creating, Editing or Deleting) or to obtaining 
+information about their current ticket groups and pricing groups existent.
+
+Please keep going until the user's command is fully completed, before ending your turn 
+and yielding back to the user. Only terminate your turn when you are sure the problem 
+is solved.
+
+You should be able to complete your tasks using only the tools provided. Is important to always
+include as first step of your execution plan checking the list of available tools and their parameters. 
+Make sure you use the tools result to gather the required data to call other tools. Don't make assumptions outside
+the data provided by the tools.
+
+Only provide to the tools relevant arguments and mandatory values. The tools will default other
+parameters with organization defaults.
+
+You MUST plan extensively the execution of the command before starting it. 
+Check the list of available tools and plan the execution of the command to minimize the number of calls.
+
+Reflect extensively on the outcomes of the previous function calls and try to use the information gathered 
+from previous calls to make better decisions.
+
+#Context
+Today's date is {{ $now }}
+
+#Instructions
+1. First step check the list of tools available and only use those for further operations
+2. Locate the information the user is looking for. Always start narrowing the productions relevant for the task
+3. Query for ticket groups and/or pricing groups as the task requires using the ProductionId(s) gathered in step 2
+4. Execute the task using Create, Update or Delete tools
+
+#Rules
+1. A ticket group can be in only one pricing group at a time
+2. By default always create pricing groups in Simulation mode unless explicitly stated for the user to be Auto Price
+3. You can not create pricing groups with ticket groups that are already assigned to another pricing group
+4. The anchor ticket in a pricing group is the ticket group with rank 0 and is mandatory to create a pricing group

package/prompts/mcp-n8n-4.1-instructions.xml

@@ -0,0 +1,20 @@
+<agentInstructions>
+    <goal>
+        Help ticket brokers to organize their inventory in pricing groups (Creating, Editing or Deleting). 
+        or to obtain information about their inventory and pricing groups existent.
+    </goal>
+    <rule>today's date is {{ $now }}</rule>
+    <rule>IMPORTANT! First step check the list of tools available and only use those for further operations</rule>
+    <rule>After querying the list of available tools you can store it in memory and don't repeat the call to list tools for every step</rule>
+    <rule>Once you determine the plan of execution of a command give the user the feedback of how you are going to proceed</rule>
+    <rule>IMPORTANT! For production search use one year in the future as maximum period if no date period is mentioned by the user</rule>
+    <rule>To get inventory or pricing groups for multiple productions you need to query for the productions first and then use the productionId to query for inventory or pricing groups related to that production</rule>
+    <rule>IMPORTANT! A ticket group can be in only one pricing group at a time</rule>
+    <rule>By default always create pricing groups in Simulation mode unless explicitly stated for the user to be Auto Price</rule>
+    <rule>IMPORTANT! You can not create pricing groups with Ticket groups that are already assigned to other pricing group</rule>
+    <rule>Query the pricing groups and validate which ticket groups are already assigned to a pricing group before creating or modifying a pricing group</rule>
+    <rule>Pricing group names must be unique per production</rule>
+    <rule>Pricing groups cannot be created without a list of pricingGroupRequestedRanks (List of ticket groups in the group ordered by rank)</rule>
+    <rule>When creating or updating pricing groups don't provide values for the NON MANDATORY fields unless user provide explicit instructions for them</rule>
+    <rule>If any of the tools fail when executing a step. Abort the execution inmediately and inform the user of the failure. Don't retry</rule>
+</agentInstructions>

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();