@bosonprotocol/agentic-commerce 1.0.0-alpha.41

package/dist/boson/mcp-server/index.js

@@ -0,0 +1,1029 @@
+#!/usr/bin/env node
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BosonMCPServer = void 0;
+const node_crypto_1 = require("node:crypto");
+const core_sdk_1 = require("@bosonprotocol/core-sdk");
+const core_sdk_2 = require("@fermionprotocol/core-sdk");
+const mcp_js_1 = require("@modelcontextprotocol/sdk/server/mcp.js");
+const stdio_js_1 = require("@modelcontextprotocol/sdk/server/stdio.js");
+const streamableHttp_js_1 = require("@modelcontextprotocol/sdk/server/streamableHttp.js");
+const types_js_1 = require("@modelcontextprotocol/sdk/types.js");
+const configLoader_js_1 = require("../../common/mcp-server/configLoader.js");
+const errorHandling_js_1 = require("../../common/mcp-server/errorHandling.js");
+const transactionSigning_js_1 = require("../../common/mcp-server/transactionSigning.js");
+const disputeResolversFilter_js_1 = require("./filters/disputeResolversFilter.js");
+const disputesFilter_js_1 = require("./filters/disputesFilter.js");
+const exchangesFilter_js_1 = require("./filters/exchangesFilter.js");
+const fundsFilter_js_1 = require("./filters/fundsFilter.js");
+const offersFilter_js_1 = require("./filters/offersFilter.js");
+const productsFilter_js_1 = require("./filters/productsFilter.js");
+const sellersByAddressFilter_js_1 = require("./filters/sellersByAddressFilter.js");
+const sellersFilter_js_1 = require("./filters/sellersFilter.js");
+const accounts_js_1 = require("./handlers/accounts.js");
+const disputes_js_1 = require("./handlers/disputes.js");
+const exchanges_js_1 = require("./handlers/exchanges.js");
+const funds_js_1 = require("./handlers/funds.js");
+const metaTx_js_1 = require("./handlers/metaTx.js");
+const offers_js_1 = require("./handlers/offers.js");
+const sdk_js_1 = require("./handlers/sdk.js");
+const transactions_js_1 = require("./handlers/transactions.js");
+const validation_js_1 = require("./validation.js");
+const log = console.error;
+class BosonMCPServer {
+    coreSDK = null;
+    constructor() {
+        // Error handling will be set up per server instance
+    }
+    createServerInstance() {
+        const server = new mcp_js_1.McpServer({
+            name: "boson-protocol-server",
+            version: "1.0.0",
+        }, {
+            capabilities: {
+                tools: {},
+                resources: {},
+                completions: {},
+            },
+        });
+        this.setupToolHandlers(server);
+        this.setupErrorHandling(server);
+        return server;
+    }
+    setupErrorHandling(server) {
+        // eslint-disable-next-line @typescript-eslint/no-misused-promises
+        process.on("SIGINT", async () => {
+            try {
+                await server.close();
+            }
+            catch (error) {
+                console.error("Error closing server:", error);
+            }
+            process.exit(0);
+        });
+    }
+    setupToolHandlers(server) {
+        const initializeSDKHandler = (0, sdk_js_1.createInitializeSDKHandler)((sdk) => {
+            this.coreSDK = sdk;
+        });
+        const offerHandler = (0, offers_js_1.createOfferHandler)(() => this.coreSDK);
+        const voidOfferHandler = (0, offers_js_1.createVoidOfferHandler)(() => this.coreSDK);
+        const sellerHandler = (0, accounts_js_1.createSellerHandler)(() => this.coreSDK);
+        const transactionHandler = (0, transactions_js_1.createTransactionHandler)(() => this.coreSDK);
+        const signTransactionHandler = (0, transactions_js_1.createSignTransactionHandler)();
+        const signTypedDataHandler = (0, transactions_js_1.createSignTypedDataHandler)();
+        const sendMetaTransactionHandler = (0, metaTx_js_1.createSendMetaTransactionHandler)(() => this.coreSDK);
+        const sendNativeMetaTransactionHandler = (0, metaTx_js_1.createSendNativeMetaTransactionHandler)(() => this.coreSDK);
+        const sendForwardedMetaTransactionHandler = (0, metaTx_js_1.createSendForwardedMetaTransactionHandler)(() => this.coreSDK);
+        const withdrawFundsHandler = (0, funds_js_1.createWithdrawFundsHandler)(() => this.coreSDK);
+        const depositFundsHandler = (0, funds_js_1.createDepositFundsHandler)(() => this.coreSDK);
+        const getFundsHandler = (0, funds_js_1.createGetFundsHandler)(() => this.coreSDK);
+        const extendDisputeTimeoutHandler = (0, disputes_js_1.createExtendDisputeTimeoutHandler)(() => this.coreSDK);
+        const expireDisputeHandler = (0, disputes_js_1.createExpireDisputeHandler)(() => this.coreSDK);
+        const expireDisputeBatchHandler = (0, disputes_js_1.createExpireDisputeBatchHandler)(() => this.coreSDK);
+        const resolveDisputeHandler = (0, disputes_js_1.createResolveDisputeHandler)(() => this.coreSDK);
+        const disputeResolutionProposalHandler = (0, disputes_js_1.createDisputeResolutionProposalHandler)(() => this.coreSDK);
+        const getDisputesHandler = (0, disputes_js_1.createGetDisputesHandler)(() => this.coreSDK);
+        const revokeVoucherHandler = (0, exchanges_js_1.createRevokeVoucherHandler)(() => this.coreSDK);
+        const commitToOfferHandler = (0, offers_js_1.createCommitToOfferHandler)(() => this.coreSDK);
+        const cancelVoucherHandler = (0, exchanges_js_1.createCancelVoucherHandler)(() => this.coreSDK);
+        const redeemVoucherHandler = (0, exchanges_js_1.createRedeemVoucherHandler)(() => this.coreSDK);
+        const getExchangesHandler = (0, exchanges_js_1.createGetExchangesHandler)(() => this.coreSDK);
+        const getOffersHandler = (0, offers_js_1.createGetOffersHandler)(() => this.coreSDK);
+        const getSellersHandler = (0, accounts_js_1.createGetSellersHandler)(() => this.coreSDK);
+        const getSellersByAddressHandler = (0, accounts_js_1.createGetSellersByAddressHandler)(() => this.coreSDK);
+        const getAllProductsWithNotVoidedVariantsHandler = (0, offers_js_1.createGetAllProductsWithNotVoidedVariantsHandler)(() => this.coreSDK);
+        const getDisputeResolversHandler = (0, accounts_js_1.createGetDisputeResolversHandler)(() => this.coreSDK);
+        // Add tools for resource queries
+        server.tool("get_funds", "Get funds entities with flexible query parameters including pagination, ordering, and filtering", validation_js_1.getFundsValidation.shape, async (args) => {
+            const validatedArgs = validation_js_1.getFundsValidation.parse(args);
+            const result = await getFundsHandler(validatedArgs);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: result,
+                    },
+                ],
+            };
+        });
+        server.tool("get_disputes", "Get dispute entities with flexible query parameters including pagination, ordering, and filtering", validation_js_1.getDisputesValidation.shape, async (args) => {
+            const validatedArgs = validation_js_1.getDisputesValidation.parse(args);
+            const result = await getDisputesHandler(validatedArgs);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: result,
+                    },
+                ],
+            };
+        });
+        server.tool("get_exchanges", "Get exchange entities with flexible query parameters including pagination, ordering, and filtering", validation_js_1.getExchangesValidation.shape, async (args) => {
+            const validatedArgs = validation_js_1.getExchangesValidation.parse(args);
+            const result = await getExchangesHandler(validatedArgs);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: result,
+                    },
+                ],
+            };
+        });
+        server.tool("get_offers", "Get offer entities with flexible query parameters including pagination, ordering, and filtering", validation_js_1.getOffersValidation.shape, async (args) => {
+            const validatedArgs = validation_js_1.getOffersValidation.parse(args);
+            const result = await getOffersHandler(validatedArgs);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: result,
+                    },
+                ],
+            };
+        });
+        server.tool("get_sellers", "Get seller entities with flexible query parameters including pagination, ordering, and filtering", validation_js_1.getSellersValidation.shape, async (args) => {
+            const validatedArgs = validation_js_1.getSellersValidation.parse(args);
+            const result = await getSellersHandler(validatedArgs);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: result,
+                    },
+                ],
+            };
+        });
+        server.tool("get_dispute_resolvers", "Get dispute resolver entities with flexible query parameters including pagination, ordering, and filtering", validation_js_1.getDisputeResolversValidation.shape, async (args) => {
+            const validatedArgs = validation_js_1.getDisputeResolversValidation.parse(args);
+            const result = await getDisputeResolversHandler(validatedArgs);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: result,
+                    },
+                ],
+            };
+        });
+        server.tool("initialize_sdk", "Initialize the Boson Protocol SDK with custom configuration", sdk_js_1.initializeSDKSchema, (args) => {
+            // Validate required fields - signerAddress can come from params or env
+            const signerAddress = args.signerAddress || process.env.SIGNER_ADDRESS;
+            if (!signerAddress) {
+                throw new Error("signerAddress is required. Provide it as parameter or set SIGNER_ADDRESS environment variable.");
+            }
+            return initializeSDKHandler(args);
+        });
+        server.tool("create_offer", "Create a new offer on Boson Protocol", validation_js_1.createOfferValidation.shape, (args) => {
+            try {
+                const validatedArgs = validation_js_1.createOfferValidation.parse(args);
+                return offerHandler(validatedArgs);
+            }
+            catch (error) {
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify({
+                                success: false,
+                                error: `Failed to create offer: ${(0, errorHandling_js_1.formatErrorMessage)(error)}`,
+                                errorDetails: error,
+                                message: "create offer validation failed",
+                            }),
+                        },
+                    ],
+                };
+            }
+        });
+        server.tool("void_offer", "Void an existing offer by calling the OfferHandlerFacet contract", validation_js_1.voidOfferValidation.shape, (args) => {
+            const validatedArgs = validation_js_1.voidOfferValidation.parse(args);
+            return voidOfferHandler(validatedArgs);
+        });
+        server.tool("create_seller", "Create a new seller on Boson Protocol", validation_js_1.createSellerValidation.shape, (args) => {
+            const validatedArgs = validation_js_1.createSellerValidation.parse(args);
+            return sellerHandler(validatedArgs);
+        });
+        server.tool("send_signed_transaction", "Send a signed transaction to the Ethereum network", validation_js_1.signedTransactionValidation, transactionHandler);
+        server.tool("sign_transaction", "Sign a transaction with a private key", validation_js_1.signTransactionValidation, signTransactionHandler);
+        server.tool("sign_typed_data", "Sign typed data using EIP-712 standard (optionally create transaction for contract submission)", transactionSigning_js_1.signTypedDataValidation, signTypedDataHandler);
+        server.tool("send_meta_transaction", "Send a meta transaction using Boson Protocol SDK", metaTx_js_1.sendMetaTransactionValidation.shape, (args) => {
+            const validatedArgs = metaTx_js_1.sendMetaTransactionValidation.parse(args);
+            return sendMetaTransactionHandler(validatedArgs);
+        });
+        server.tool("send_native_meta_transaction", "Send a native meta transaction using Boson Protocol SDK", metaTx_js_1.sendNativeMetaTransactionValidation.shape, (args) => {
+            const validatedArgs = metaTx_js_1.sendNativeMetaTransactionValidation.parse(args);
+            return sendNativeMetaTransactionHandler(validatedArgs);
+        });
+        server.tool("send_forwarded_meta_transaction", "Send a forwarded meta transaction using Boson Protocol SDK", metaTx_js_1.sendForwardedMetaTransactionValidation.shape, (args) => {
+            const validatedArgs = metaTx_js_1.sendForwardedMetaTransactionValidation.parse(args);
+            return sendForwardedMetaTransactionHandler(validatedArgs);
+        });
+        server.tool("withdraw_funds", "Withdraw funds from an entity treasury", validation_js_1.withdrawFundsValidation.shape, (args) => {
+            const validatedArgs = validation_js_1.withdrawFundsValidation.parse(args);
+            return withdrawFundsHandler(validatedArgs);
+        });
+        server.tool("deposit_funds", "Deposit funds to an entity treasury", validation_js_1.depositFundsValidation.shape, (args) => {
+            const validatedArgs = validation_js_1.depositFundsValidation.parse(args);
+            return depositFundsHandler(validatedArgs);
+        });
+        server.tool("extend_dispute_timeout", "Extend the timeout for a dispute", validation_js_1.extendDisputeTimeoutValidation.shape, (args) => {
+            const validatedArgs = validation_js_1.extendDisputeTimeoutValidation.parse(args);
+            return extendDisputeTimeoutHandler(validatedArgs);
+        });
+        server.tool("expire_dispute", "Expire a dispute", validation_js_1.expireDisputeValidation.shape, (args) => {
+            const validatedArgs = validation_js_1.expireDisputeValidation.parse(args);
+            return expireDisputeHandler(validatedArgs);
+        });
+        server.tool("expire_dispute_batch", "Expire multiple disputes in a batch", validation_js_1.expireDisputeBatchValidation.shape, (args) => {
+            const validatedArgs = validation_js_1.expireDisputeBatchValidation.parse(args);
+            return expireDisputeBatchHandler(validatedArgs);
+        });
+        server.tool("resolve_dispute", "Resolve a dispute with mutual agreement", validation_js_1.resolveDisputeValidation.shape, (args) => {
+            const validatedArgs = validation_js_1.resolveDisputeValidation.parse(args);
+            return resolveDisputeHandler(validatedArgs);
+        });
+        server.tool("create_dispute_resolution_proposal", "Create a dispute resolution proposal signature", validation_js_1.createDisputeResolutionProposalValidation.shape, (args) => {
+            const validatedArgs = validation_js_1.createDisputeResolutionProposalValidation.parse(args);
+            return disputeResolutionProposalHandler(validatedArgs);
+        });
+        server.tool("revoke_voucher", "Revoke an existing voucher by seller assistant", validation_js_1.revokeVoucherValidation.shape, (args) => {
+            const validatedArgs = validation_js_1.revokeVoucherValidation.parse(args);
+            return revokeVoucherHandler(validatedArgs);
+        });
+        server.tool("commit_to_offer", "Commit to an offer to create an exchange", validation_js_1.commitToOfferValidation.shape, (args) => {
+            const validatedArgs = validation_js_1.commitToOfferValidation.parse(args);
+            return commitToOfferHandler(validatedArgs);
+        });
+        server.tool("cancel_voucher", "Cancel an existing voucher by buyer", validation_js_1.cancelVoucherValidation.shape, (args) => {
+            const validatedArgs = validation_js_1.cancelVoucherValidation.parse(args);
+            return cancelVoucherHandler(validatedArgs);
+        });
+        server.tool("redeem_voucher", "Redeem an existing voucher by buyer", validation_js_1.redeemVoucherValidation.shape, (args) => {
+            const validatedArgs = validation_js_1.redeemVoucherValidation.parse(args);
+            return redeemVoucherHandler(validatedArgs);
+        });
+        server.tool("get_sellers_by_address", "Get seller entities by address with flexible query parameters including pagination, ordering, and filtering", validation_js_1.getSellersByAddressValidation.shape, async (args) => {
+            const validatedArgs = validation_js_1.getSellersByAddressValidation.parse(args);
+            const result = await getSellersByAddressHandler(validatedArgs);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: result,
+                    },
+                ],
+            };
+        });
+        server.tool("get_all_products_with_not_voided_variants", "Get all products with not voided variants with flexible query parameters including pagination, ordering, and filtering", validation_js_1.getAllProductsWithNotVoidedVariantsValidation.shape, async (args) => {
+            const validatedArgs = validation_js_1.getAllProductsWithNotVoidedVariantsValidation.parse(args);
+            const result = await getAllProductsWithNotVoidedVariantsHandler(validatedArgs);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: result,
+                    },
+                ],
+            };
+        });
+        // Add the funds resource with flexible query parameters
+        server.resource("funds", new mcp_js_1.ResourceTemplate(fundsFilter_js_1.fundsUriTemplate, {
+            list: undefined,
+            complete: {
+                fundsSkip: () => {
+                    return ["0", "10", "20", "50", "100"];
+                },
+                fundsFirst: () => {
+                    return ["10", "20", "50", "100"];
+                },
+                fundsOrderBy: () => {
+                    return Object.values(core_sdk_2.Subgraph.FundsEntity_OrderBy);
+                },
+                fundsOrderDirection: () => {
+                    return Object.values(core_sdk_2.Subgraph.OrderDirection);
+                },
+            },
+        }), {
+            name: "Funds Entities",
+            description: "Get funds entities with flexible query parameters including pagination, ordering, and filtering",
+            mimeType: "application/json",
+        }, async (uri) => {
+            const queryParams = {};
+            // Extract query parameters from URL
+            const urlParams = new URLSearchParams(uri.search);
+            if (urlParams.get("fundsSkip")) {
+                queryParams.fundsSkip = parseInt(urlParams.get("fundsSkip"));
+            }
+            if (urlParams.get("fundsFirst")) {
+                queryParams.fundsFirst = parseInt(urlParams.get("fundsFirst"));
+            }
+            if (urlParams.get("fundsOrderBy")) {
+                queryParams.fundsOrderBy = urlParams.get("fundsOrderBy");
+            }
+            if (urlParams.get("fundsOrderDirection")) {
+                queryParams.fundsOrderDirection = urlParams.get("fundsOrderDirection");
+            }
+            // Process filter parameters
+            const filterParams = (0, fundsFilter_js_1.fundsProcessFilterParams)(urlParams);
+            if (Object.keys(filterParams).length > 0) {
+                queryParams.fundsFilter = filterParams;
+            }
+            const validatedArgs = validation_js_1.getFundsValidation.parse(queryParams);
+            const result = await getFundsHandler(validatedArgs);
+            return {
+                contents: [
+                    {
+                        uri: uri.toString(),
+                        mimeType: "application/json",
+                        text: result,
+                    },
+                ],
+            };
+        });
+        // Add the signer-address resource with no parameters
+        server.resource("signer-address", "signer-address://", async (url) => {
+            if (!this.coreSDK?.web3Lib?.getSignerAddress) {
+                throw new Error("SDK not initialized. Call initialize_sdk first.");
+            }
+            return {
+                contents: [
+                    {
+                        uri: url.toString(),
+                        mimeType: "text/plain",
+                        text: await this.coreSDK.web3Lib.getSignerAddress(),
+                    },
+                ],
+            };
+        });
+        // Add the disputes resource with flexible query parameters
+        server.resource("disputes", new mcp_js_1.ResourceTemplate(disputesFilter_js_1.disputesUriTemplate, {
+            list: undefined,
+            complete: {
+                disputesSkip: () => {
+                    return ["0", "10", "20", "50", "100"];
+                },
+                disputesFirst: () => {
+                    return ["10", "20", "50", "100"];
+                },
+                disputesOrderBy: () => {
+                    return Object.values(core_sdk_1.subgraph.Dispute_OrderBy);
+                },
+                disputesOrderDirection: () => {
+                    return Object.values(core_sdk_1.subgraph.OrderDirection);
+                },
+            },
+        }), {
+            name: "Dispute Entities",
+            description: "Get dispute entities with flexible query parameters including pagination, ordering, and filtering",
+            mimeType: "application/json",
+        }, async (uri) => {
+            const queryParams = {};
+            // Extract query parameters from URL
+            const urlParams = new URLSearchParams(uri.search);
+            if (urlParams.get("disputesSkip")) {
+                queryParams.disputesSkip = parseInt(urlParams.get("disputesSkip"));
+            }
+            if (urlParams.get("disputesFirst")) {
+                queryParams.disputesFirst = parseInt(urlParams.get("disputesFirst"));
+            }
+            if (urlParams.get("disputesOrderBy")) {
+                queryParams.disputesOrderBy = urlParams.get("disputesOrderBy");
+            }
+            if (urlParams.get("disputesOrderDirection")) {
+                queryParams.disputesOrderDirection = urlParams.get("disputesOrderDirection");
+            }
+            // Process filter parameters
+            const filterParams = (0, disputesFilter_js_1.disputesProcessFilterParams)(urlParams);
+            if (Object.keys(filterParams).length > 0) {
+                queryParams.disputesFilter = filterParams;
+            }
+            const validatedArgs = validation_js_1.getDisputesValidation.parse(queryParams);
+            const result = await getDisputesHandler(validatedArgs);
+            return {
+                contents: [
+                    {
+                        uri: uri.toString(),
+                        mimeType: "application/json",
+                        text: result,
+                    },
+                ],
+            };
+        });
+        // Add the exchanges resource with flexible query parameters
+        server.resource("exchanges", new mcp_js_1.ResourceTemplate(exchangesFilter_js_1.exchangesUriTemplate, {
+            list: undefined,
+            complete: {
+                exchangesSkip: () => {
+                    return ["0", "10", "20", "50", "100"];
+                },
+                exchangesFirst: () => {
+                    return ["10", "20", "50", "100"];
+                },
+                exchangesOrderBy: () => {
+                    return Object.values(core_sdk_1.subgraph.Exchange_OrderBy);
+                },
+                exchangesOrderDirection: () => {
+                    return Object.values(core_sdk_1.subgraph.OrderDirection);
+                },
+            },
+        }), {
+            name: "Exchange Entities",
+            description: "Get exchange entities with flexible query parameters including pagination, ordering, and filtering",
+            mimeType: "application/json",
+        }, async (uri) => {
+            const queryParams = {};
+            // Extract query parameters from URL
+            const urlParams = new URLSearchParams(uri.search);
+            if (urlParams.get("exchangesSkip")) {
+                queryParams.exchangesSkip = parseInt(urlParams.get("exchangesSkip"));
+            }
+            if (urlParams.get("exchangesFirst")) {
+                queryParams.exchangesFirst = parseInt(urlParams.get("exchangesFirst"));
+            }
+            if (urlParams.get("exchangesOrderBy")) {
+                queryParams.exchangesOrderBy = urlParams.get("exchangesOrderBy");
+            }
+            if (urlParams.get("exchangesOrderDirection")) {
+                queryParams.exchangesOrderDirection = urlParams.get("exchangesOrderDirection");
+            }
+            // Process filter parameters
+            const filterParams = (0, exchangesFilter_js_1.exchangesProcessFilterParams)(urlParams);
+            if (Object.keys(filterParams).length > 0) {
+                queryParams.exchangesFilter = filterParams;
+            }
+            const validatedArgs = validation_js_1.getExchangesValidation.parse(queryParams);
+            const result = await getExchangesHandler(validatedArgs);
+            return {
+                contents: [
+                    {
+                        uri: uri.toString(),
+                        mimeType: "application/json",
+                        text: result,
+                    },
+                ],
+            };
+        });
+        // Add the offers resource with flexible query parameters
+        server.resource("offers", new mcp_js_1.ResourceTemplate(offersFilter_js_1.offersUriTemplate, {
+            list: undefined,
+            complete: {
+                offersSkip: () => {
+                    return ["0", "10", "20", "50", "100"];
+                },
+                offersFirst: () => {
+                    return ["10", "20", "50", "100"];
+                },
+                offersOrderBy: () => {
+                    return Object.values(core_sdk_1.subgraph.Offer_OrderBy);
+                },
+                offersOrderDirection: () => {
+                    return Object.values(core_sdk_1.subgraph.OrderDirection);
+                },
+                exchangesSkip: () => {
+                    return ["0", "10", "20", "50", "100"];
+                },
+                exchangesFirst: () => {
+                    return ["10", "20", "50", "100"];
+                },
+                exchangesOrderBy: () => {
+                    return Object.values(core_sdk_1.subgraph.Exchange_OrderBy);
+                },
+                exchangesOrderDirection: () => {
+                    return Object.values(core_sdk_1.subgraph.OrderDirection);
+                },
+                includeExchanges: () => {
+                    return ["true", "false"];
+                },
+            },
+        }), {
+            name: "Offer Entities",
+            description: "Get offer entities with flexible query parameters including pagination, ordering, and filtering. Supports exchanges filtering for exchangeId",
+            mimeType: "application/json",
+        }, async (uri) => {
+            const queryParams = {};
+            // Extract query parameters from URL
+            const urlParams = new URLSearchParams(uri.search);
+            // Offers parameters
+            if (urlParams.get("offersSkip")) {
+                queryParams.offersSkip = parseInt(urlParams.get("offersSkip"));
+            }
+            if (urlParams.get("offersFirst")) {
+                queryParams.offersFirst = parseInt(urlParams.get("offersFirst"));
+            }
+            if (urlParams.get("offersOrderBy")) {
+                queryParams.offersOrderBy = urlParams.get("offersOrderBy");
+            }
+            if (urlParams.get("offersOrderDirection")) {
+                queryParams.offersOrderDirection = urlParams.get("offersOrderDirection");
+            }
+            // Exchanges parameters
+            if (urlParams.get("exchangesSkip")) {
+                queryParams.exchangesSkip = parseInt(urlParams.get("exchangesSkip"));
+            }
+            if (urlParams.get("exchangesFirst")) {
+                queryParams.exchangesFirst = parseInt(urlParams.get("exchangesFirst"));
+            }
+            if (urlParams.get("exchangesOrderBy")) {
+                queryParams.exchangesOrderBy = urlParams.get("exchangesOrderBy");
+            }
+            if (urlParams.get("exchangesOrderDirection")) {
+                queryParams.exchangesOrderDirection = urlParams.get("exchangesOrderDirection");
+            }
+            if (urlParams.get("includeExchanges")) {
+                queryParams.includeExchanges =
+                    urlParams.get("includeExchanges") === "true";
+            }
+            // Process exchanges filter parameters using exchanges filter processor
+            const exchangesFilterParams = (0, offersFilter_js_1.offerExchangesProcessFilterParams)(urlParams);
+            if (Object.keys(exchangesFilterParams).length > 0) {
+                queryParams.exchangesFilter = exchangesFilterParams;
+            }
+            // Process offers filter parameters
+            const filterParams = (0, offersFilter_js_1.offersProcessFilterParams)(urlParams);
+            if (Object.keys(filterParams).length > 0) {
+                queryParams.offersFilter = filterParams;
+            }
+            const result = await getOffersHandler(queryParams);
+            return {
+                contents: [
+                    {
+                        uri: uri.toString(),
+                        mimeType: "application/json",
+                        text: result,
+                    },
+                ],
+            };
+        });
+        // Add the sellers resource with flexible query parameters
+        server.resource("sellers", new mcp_js_1.ResourceTemplate(sellersFilter_js_1.sellersUriTemplate, {
+            list: undefined,
+            complete: {
+                sellersSkip: () => {
+                    return ["0", "10", "20", "50", "100"];
+                },
+                sellersFirst: () => {
+                    return ["10", "20", "50", "100"];
+                },
+                sellersOrderBy: () => {
+                    return Object.values(core_sdk_1.subgraph.Seller_OrderBy);
+                },
+                sellersOrderDirection: () => {
+                    return Object.values(core_sdk_1.subgraph.OrderDirection);
+                },
+                includeExchanges: () => {
+                    return ["true", "false"];
+                },
+                includeOffers: () => {
+                    return ["true", "false"];
+                },
+                includeFunds: () => {
+                    return ["true", "false"];
+                },
+                includeLogs: () => {
+                    return ["true", "false"];
+                },
+            },
+        }), {
+            name: "Seller Entities",
+            description: "Get seller entities with flexible query parameters including pagination, ordering, and filtering",
+            mimeType: "application/json",
+        }, async (uri) => {
+            const queryParams = {};
+            // Extract query parameters from URL
+            const urlParams = new URLSearchParams(uri.search);
+            if (urlParams.get("sellersSkip")) {
+                queryParams.sellersSkip = parseInt(urlParams.get("sellersSkip"));
+            }
+            if (urlParams.get("sellersFirst")) {
+                queryParams.sellersFirst = parseInt(urlParams.get("sellersFirst"));
+            }
+            if (urlParams.get("sellersOrderBy")) {
+                queryParams.sellersOrderBy = urlParams.get("sellersOrderBy");
+            }
+            if (urlParams.get("sellersOrderDirection")) {
+                queryParams.sellersOrderDirection = urlParams.get("sellersOrderDirection");
+            }
+            if (urlParams.get("includeExchanges")) {
+                queryParams.includeExchanges =
+                    urlParams.get("includeExchanges") === "true";
+            }
+            if (urlParams.get("includeOffers")) {
+                queryParams.includeOffers = urlParams.get("includeOffers") === "true";
+            }
+            if (urlParams.get("includeFunds")) {
+                queryParams.includeFunds = urlParams.get("includeFunds") === "true";
+            }
+            if (urlParams.get("includeLogs")) {
+                queryParams.includeLogs = urlParams.get("includeLogs") === "true";
+            }
+            // Process filter parameters
+            const filterParams = (0, sellersFilter_js_1.sellersProcessFilterParams)(urlParams);
+            if (Object.keys(filterParams).length > 0) {
+                queryParams.sellersFilter = filterParams;
+            }
+            const validatedArgs = validation_js_1.getSellersValidation.parse(queryParams);
+            const result = await getSellersHandler(validatedArgs);
+            return {
+                contents: [
+                    {
+                        uri: uri.toString(),
+                        mimeType: "application/json",
+                        text: result,
+                    },
+                ],
+            };
+        });
+        // Add the dispute_resolvers resource with flexible query parameters
+        server.resource("dispute_resolvers", new mcp_js_1.ResourceTemplate(disputeResolversFilter_js_1.disputeResolversUriTemplate, {
+            list: undefined,
+            complete: {
+                disputeResolversSkip: () => {
+                    return ["0", "10", "20", "50", "100"];
+                },
+                disputeResolversFirst: () => {
+                    return ["10", "20", "50", "100"];
+                },
+                disputeResolversOrderBy: () => {
+                    return Object.values(core_sdk_1.subgraph.DisputeResolver_OrderBy);
+                },
+                disputeResolversOrderDirection: () => {
+                    return Object.values(core_sdk_1.subgraph.OrderDirection);
+                },
+            },
+        }), {
+            name: "Dispute Resolver Entities",
+            description: "Get dispute resolver entities with flexible query parameters including pagination, ordering, and filtering",
+            mimeType: "application/json",
+        }, async (uri) => {
+            const queryParams = {};
+            // Extract query parameters from URL
+            const urlParams = new URLSearchParams(uri.search);
+            if (urlParams.get("disputeResolversSkip")) {
+                queryParams.disputeResolversSkip = parseInt(urlParams.get("disputeResolversSkip"));
+            }
+            if (urlParams.get("disputeResolversFirst")) {
+                queryParams.disputeResolversFirst = parseInt(urlParams.get("disputeResolversFirst"));
+            }
+            if (urlParams.get("disputeResolversOrderBy")) {
+                queryParams.disputeResolversOrderBy = urlParams.get("disputeResolversOrderBy");
+            }
+            if (urlParams.get("disputeResolversOrderDirection")) {
+                queryParams.disputeResolversOrderDirection = urlParams.get("disputeResolversOrderDirection");
+            }
+            // Process filter parameters
+            const filterParams = (0, disputeResolversFilter_js_1.disputeResolversProcessFilterParams)(urlParams);
+            if (Object.keys(filterParams).length > 0) {
+                queryParams.disputeResolversFilter = filterParams;
+            }
+            const validatedArgs = validation_js_1.getDisputeResolversValidation.parse(queryParams);
+            const result = await getDisputeResolversHandler(validatedArgs);
+            return {
+                contents: [
+                    {
+                        uri: uri.toString(),
+                        mimeType: "application/json",
+                        text: result,
+                    },
+                ],
+            };
+        });
+        // Add the sellers-by-address resource with flexible query parameters
+        server.resource("sellers-by-address", new mcp_js_1.ResourceTemplate(sellersByAddressFilter_js_1.sellersByAddressUriTemplate, {
+            list: undefined,
+            complete: {
+                sellersSkip: () => {
+                    return ["0", "10", "20", "50", "100"];
+                },
+                sellersFirst: () => {
+                    return ["10", "20", "50", "100"];
+                },
+                sellersOrderBy: () => {
+                    return Object.values(core_sdk_1.subgraph.Seller_OrderBy);
+                },
+                sellersOrderDirection: () => {
+                    return Object.values(core_sdk_1.subgraph.OrderDirection);
+                },
+                includeExchanges: () => {
+                    return ["true", "false"];
+                },
+                includeOffers: () => {
+                    return ["true", "false"];
+                },
+                includeFunds: () => {
+                    return ["true", "false"];
+                },
+                includeLogs: () => {
+                    return ["true", "false"];
+                },
+            },
+        }), {
+            name: "Sellers By Address",
+            description: "Get seller entities by address with flexible query parameters including pagination, ordering, and filtering",
+            mimeType: "application/json",
+        }, async (uri) => {
+            const urlParams = new URLSearchParams(uri.search);
+            const queryParams = {};
+            // Extract address parameter (required)
+            const address = urlParams.get("address");
+            if (!address) {
+                throw new Error("address parameter is required");
+            }
+            queryParams.address = address;
+            // Extract pagination parameters
+            const sellersSkip = urlParams.get("sellersSkip");
+            if (sellersSkip !== null) {
+                queryParams.sellersSkip = parseInt(sellersSkip, 10);
+            }
+            const sellersFirst = urlParams.get("sellersFirst");
+            if (sellersFirst !== null) {
+                queryParams.sellersFirst = parseInt(sellersFirst, 10);
+            }
+            // Extract ordering parameters
+            const sellersOrderBy = urlParams.get("sellersOrderBy");
+            if (sellersOrderBy !== null) {
+                queryParams.sellersOrderBy = sellersOrderBy;
+            }
+            const sellersOrderDirection = urlParams.get("sellersOrderDirection");
+            if (sellersOrderDirection !== null) {
+                queryParams.sellersOrderDirection = sellersOrderDirection;
+            }
+            // Extract include flags
+            const includeExchanges = urlParams.get("includeExchanges");
+            if (includeExchanges !== null) {
+                queryParams.includeExchanges = includeExchanges === "true";
+            }
+            const includeOffers = urlParams.get("includeOffers");
+            if (includeOffers !== null) {
+                queryParams.includeOffers = includeOffers === "true";
+            }
+            const includeFunds = urlParams.get("includeFunds");
+            if (includeFunds !== null) {
+                queryParams.includeFunds = includeFunds === "true";
+            }
+            const includeLogs = urlParams.get("includeLogs");
+            if (includeLogs !== null) {
+                queryParams.includeLogs = includeLogs === "true";
+            }
+            // Process filter parameters
+            const sellersFilter = (0, sellersByAddressFilter_js_1.sellersByAddressProcessFilterParams)(urlParams);
+            if (Object.keys(sellersFilter).length > 0) {
+                queryParams.sellersFilter = sellersFilter;
+            }
+            // Validate arguments
+            const validatedArgs = validation_js_1.getSellersByAddressValidation.parse(queryParams);
+            // Call the handler
+            const result = await getSellersByAddressHandler(validatedArgs);
+            return {
+                contents: [
+                    {
+                        uri: uri.toString(),
+                        mimeType: "application/json",
+                        text: result,
+                    },
+                ],
+            };
+        });
+        // Add the products resource with flexible query parameters
+        server.resource("products", new mcp_js_1.ResourceTemplate(productsFilter_js_1.productsUriTemplate, {
+            list: undefined,
+            complete: {
+                productsSkip: () => {
+                    return ["0", "10", "20", "50", "100"];
+                },
+                productsFirst: () => {
+                    return ["10", "20", "50", "100"];
+                },
+                productsOrderBy: () => {
+                    return Object.values(core_sdk_1.subgraph.ProductV1Product_OrderBy);
+                },
+                productsOrderDirection: () => {
+                    return Object.values(core_sdk_1.subgraph.OrderDirection);
+                },
+            },
+        }), {
+            name: "Products",
+            description: "Get all products with not voided variants with flexible query parameters including pagination, ordering, and filtering",
+            mimeType: "application/json",
+        }, async (uri) => {
+            const urlParams = new URLSearchParams(uri.search);
+            const queryParams = {};
+            // Extract pagination parameters
+            const productsSkip = urlParams.get("productsSkip");
+            if (productsSkip !== null) {
+                queryParams.productsSkip = parseInt(productsSkip, 10);
+            }
+            const productsFirst = urlParams.get("productsFirst");
+            if (productsFirst !== null) {
+                queryParams.productsFirst = parseInt(productsFirst, 10);
+            }
+            // Extract ordering parameters
+            const productsOrderBy = urlParams.get("productsOrderBy");
+            if (productsOrderBy !== null) {
+                queryParams.productsOrderBy = productsOrderBy;
+            }
+            const productsOrderDirection = urlParams.get("productsOrderDirection");
+            if (productsOrderDirection !== null) {
+                queryParams.productsOrderDirection = productsOrderDirection;
+            }
+            // Process filter parameters
+            const productsFilter = (0, productsFilter_js_1.productsProcessFilterParams)(urlParams);
+            if (Object.keys(productsFilter).length > 0) {
+                queryParams.productsFilter = productsFilter;
+            }
+            // Validate arguments
+            const validatedArgs = validation_js_1.getAllProductsWithNotVoidedVariantsValidation.parse(queryParams);
+            // Call the handler
+            const result = await getAllProductsWithNotVoidedVariantsHandler(validatedArgs);
+            return {
+                contents: [
+                    {
+                        uri: uri.toString(),
+                        mimeType: "application/json",
+                        text: result,
+                    },
+                ],
+            };
+        });
+    }
+    async startStdio() {
+        const server = this.createServerInstance();
+        const transport = new stdio_js_1.StdioServerTransport();
+        await server.connect(transport);
+        log("Boson Protocol MCP server running on stdio");
+    }
+    async startHttp(port = 3000) {
+        const express = await Promise.resolve().then(() => __importStar(require("express")));
+        const app = express.default();
+        app.use(express.json());
+        // Enable CORS for cross-origin requests
+        app.use((req, res, next) => {
+            res.header("Access-Control-Allow-Origin", "*");
+            res.header("Access-Control-Allow-Methods", "GET, POST, PUT, DELETE, OPTIONS");
+            res.header("Access-Control-Allow-Headers", "Origin, X-Requested-With, Content-Type, Accept, Authorization");
+            if (req.method === "OPTIONS") {
+                res.sendStatus(200);
+            }
+            else {
+                next();
+            }
+        });
+        // Root endpoint - serves as the main page for integration
+        app.get("/", (_, res) => {
+            res.json({
+                name: "Boson Protocol MCP Server",
+                version: "1.0.0",
+                description: "MCP Server for Boson Protocol operations",
+                endpoints: {
+                    health: "/health",
+                    mcp: "/mcp",
+                },
+                status: "running",
+                transport: "Streamable HTTP",
+            });
+        });
+        // Health check endpoint
+        app.get("/health", (_, res) => {
+            res.json({
+                status: "ok",
+                timestamp: new Date().toISOString(),
+                server: "Boson Protocol MCP Server",
+            });
+        });
+        // Map to store transports by session ID
+        const transports = {};
+        app.post("/mcp", async (req, res) => {
+            // Check for existing session ID
+            const sessionId = req.headers["mcp-session-id"];
+            let transport;
+            if (sessionId && transports[sessionId]) {
+                // Reuse existing transport
+                transport = transports[sessionId];
+            }
+            else if (!sessionId && (0, types_js_1.isInitializeRequest)(req.body)) {
+                // New initialization request - create new server instance
+                const server = this.createServerInstance();
+                transport = new streamableHttp_js_1.StreamableHTTPServerTransport({
+                    sessionIdGenerator: () => (0, node_crypto_1.randomUUID)(),
+                    onsessioninitialized: (sessionId) => {
+                        // Store the transport by session ID
+                        transports[sessionId] = transport;
+                    },
+                });
+                // Clean up transport when closed
+                transport.onclose = () => {
+                    log("transport has been closed");
+                    if (transport.sessionId) {
+                        delete transports[transport.sessionId];
+                    }
+                };
+                // Connect to the MCP server
+                await server.connect(transport);
+            }
+            else {
+                // Invalid request
+                res.status(400).json({
+                    jsonrpc: "2.0",
+                    error: {
+                        code: -32000,
+                        message: "Bad Request: No valid session ID provided",
+                    },
+                    id: null,
+                });
+                return;
+            }
+            // Handle the request
+            await transport.handleRequest(req, res, req.body);
+        });
+        // Handle GET requests for server-to-client notifications via SSE
+        app.get("/mcp", async (req, res) => {
+            const sessionId = req.headers["mcp-session-id"];
+            if (!sessionId || !transports[sessionId]) {
+                res.status(400).send("Invalid or missing session ID");
+                return;
+            }
+            const transport = transports[sessionId];
+            await transport.handleRequest(req, res);
+        });
+        // Handle DELETE requests for session termination
+        app.delete("/mcp", async (req, res) => {
+            const sessionId = req.headers["mcp-session-id"];
+            if (!sessionId || !transports[sessionId]) {
+                res.status(400).send("Invalid or missing session ID");
+                return;
+            }
+            const transport = transports[sessionId];
+            await transport.handleRequest(req, res);
+        });
+        // Catch-all for unknown routes
+        app.use((req, res) => {
+            res.status(404).json({
+                error: "Not Found",
+                message: `The requested endpoint ${req.originalUrl} was not found`,
+                availableEndpoints: {
+                    root: "/",
+                    health: "/health",
+                    mcp: "/mcp",
+                },
+            });
+        });
+        app.listen(port, () => {
+            log(`Boson MCP Server running on http://localhost:${port}`);
+            log(`Web interface: http://localhost:${port}`);
+            log(`MCP endpoint: http://localhost:${port}/mcp`);
+            log(`Health check: http://localhost:${port}/health`);
+        });
+    }
+    async run() {
+        const args = (0, configLoader_js_1.parseArgs)();
+        // Load environment variables from config if provided
+        (0, configLoader_js_1.loadConfigEnv)(args.config, args.server);
+        const useHttp = args.http || process.env.MCP_TRANSPORT === "http";
+        if (useHttp) {
+            await this.startHttp();
+        }
+        else {
+            await this.startStdio();
+        }
+    }
+}
+exports.BosonMCPServer = BosonMCPServer;
+// Only run server if not in test environment
+if (process.env.NODE_ENV !== "test" && process.env.VITEST !== "true") {
+    const server = new BosonMCPServer();
+    server.run().catch(log);
+}
+//# sourceMappingURL=index.js.map