@goplausible/algorand-mcp 4.3.2 → 4.4.0

package/README.md

@@ -481,7 +481,7 @@ See [Secure Wallet](#secure-wallet) for full architecture details.
 | `wallet_sign_data` | Sign arbitrary hex data with raw Ed25519 (noble, no SDK prefix) |
 | `wallet_optin_asset` | Opt the active account into an asset (creates, signs, and submits) |
 
-### x402 HTTP Payment Tools (2 tools)
+### x402 HTTP Payment Tools (5 tools)
 
 See [x402 HTTP Payments](#x402-http-payments) for the full protocol explanation.
 
@@ -489,6 +489,9 @@ See [x402 HTTP Payments](#x402-http-payments) for the full protocol explanation.
 |---|---|
 | `x402_discover_payment_requirements` | Probe an x402-protected endpoint and return its `accepts[]` array (cost, asset, network, payTo) without paying. Read-only. |
 | `make_http_request_with_x402` | Call an x402-protected endpoint with automatic USDC/ALGO payment from the active wallet. Discovers internally if `paymentRequirements` is not supplied, builds the atomic fee-payer + payment group, signs, and retries with the `PAYMENT-SIGNATURE` header. |
+| `bazaar_list` | Browse paid API resources cataloged in the Bazaar discovery directory hosted by the configured facilitator (`facilitator.goplausible.xyz` by default). Compact summary by default; `full: true` returns verbatim records. Filters: `network`, `method`, `merchantId`, `limit`, `offset`. |
+| `bazaar_search` | Keyword search over Bazaar resources (URL + description). Server-side: `query`, `network`. Client-side post-filters: `scheme`, `maxUsdPrice`, `asset`, `payTo`, `extensions`, `includeTestnets`. |
+| `bazaar_get_resource_details` | Fetch a single Bazaar resource by its exact `resource` URL. Returns the verbatim record (accepts[], discoveryInfo, popularity counters). |
 
 ### Account Management (8 tools)
 

package/dist/index.js

@@ -7,7 +7,7 @@ import { CallToolRequestSchema, ErrorCode, ListResourcesRequestSchema, ListTools
 import { AccountManager, WalletManager, X402Manager, UtilityManager, TransactionManager, AlgodManager, transactionTools, apiManager, handleApiManager, arc26Manager, KnowledgeManager } from './tools/index.js';
 import { ResourceManager } from './resources/index.js';
 class AlgorandMcpServer {
-    constructor(name = 'algorand-mcp-server', version = '2.7.5') {
+    constructor(name = 'algorand-mcp-server', version = '4.4.0') {
         this.name = name;
         this.server = new Server({
             name,
@@ -95,8 +95,10 @@ class AlgorandMcpServer {
             if (name.startsWith('wallet_')) {
                 return WalletManager.handleTool(name, args);
             }
-            // Handle x402 tools
-            if (name === 'make_http_request_with_x402' || name === 'x402_discover_payment_requirements') {
+            // Handle x402 tools (payment) + bazaar_* (discovery directory)
+            if (name === 'make_http_request_with_x402' ||
+                name === 'x402_discover_payment_requirements' ||
+                name.startsWith('bazaar_')) {
                 return X402Manager.handleTool(name, args);
             }
             // Handle account tools

package/dist/tools/utilityManager.js

@@ -86,7 +86,7 @@ export class UtilityManager {
                                 type: 'text',
                                 text: JSON.stringify({
                                     name: 'Algorand MCP Server',
-                                    version: '4.3.2',
+                                    version: '4.4.0',
                                     builder: 'GoPlausible',
                                     description: 'A Model Context Protocol (MCP) server providing comprehensive access to the Algorand blockchain. Supports account management, transaction building and signing, smart contract interaction, asset operations, ARC-26 URI generation, and deep integration with Algorand ecosystem services including NFDomains, Tinyman, Vestige, and Ultrade.',
                                     blockchain: 'Algorand — a carbon-negative, pure proof-of-stake Layer 1 blockchain delivering instant finality, low fees, and advanced smart contract capabilities via AVM (Algorand Virtual Machine).',

package/dist/tools/x402Manager.d.ts

@@ -31,4 +31,13 @@ export declare class X402Manager {
     private static decodeBase64Json;
     private static snippet;
     private static textResponse;
+    private static handleBazaarList;
+    private static handleBazaarSearch;
+    private static handleBazaarGetResourceDetails;
+    private static bazaarRequest;
+    private static summarizeBazaarItem;
+    /** USDC has 6 decimals; assume non-USDC assets are USDC-like for ballpark filtering. */
+    private static usdPriceOfAccept;
+    private static cheapestUsdPrice;
+    private static isTestnetNetwork;
 }

package/dist/tools/x402Manager.js

@@ -19,6 +19,31 @@ function caip2ToNetwork(caip2) {
     const hash = caip2.slice('algorand:'.length);
     return CAIP2_GENESIS_TO_NETWORK[hash] ?? null;
 }
+// ── Bazaar (discovery) config ────────────────────────────────────────────────
+const BAZAAR_BASE_URL = process.env.BAZAAR_BASE_URL || 'https://facilitator.goplausible.xyz';
+/**
+ * Friendly network name → CAIP-2 identifier expected by the Bazaar API.
+ * Anything starting with a known chain prefix (algorand:, eip155:, solana:) is
+ * passed through unchanged. Anything else is left as-is so the agent can
+ * still forward arbitrary upstream-supported network strings.
+ */
+function friendlyToCaip2Network(input) {
+    if (!input)
+        return input;
+    if (input.startsWith('algorand:') || input.startsWith('eip155:') || input.startsWith('solana:')) {
+        return input;
+    }
+    // Algorand friendly aliases.
+    if (input === 'algorand-mainnet' || input === 'mainnet')
+        return NETWORK_TO_CAIP2.mainnet;
+    if (input === 'algorand-testnet' || input === 'testnet')
+        return NETWORK_TO_CAIP2.testnet;
+    if (input === 'algorand-localnet' || input === 'localnet')
+        return NETWORK_TO_CAIP2.localnet;
+    // Pass through for non-Algorand short names — the Bazaar may or may not
+    // recognize them; if not, it returns an empty items[] which is fine.
+    return input;
+}
 const ATOMIC_UNITS_NOTE = 'USDC amounts are expressed in atomic units. 1,000,000 atomic units = $1.00 USDC (USDC has 6 decimals).';
 const HTTP_METHODS = ['GET', 'POST', 'PUT', 'DELETE', 'PATCH'];
 // ── Tool schemas ─────────────────────────────────────────────────────────────
@@ -45,12 +70,67 @@ const x402ToolSchemas = {
             headers: { type: 'object', description: 'Optional additional request headers', additionalProperties: { type: 'string' } },
             correlationId: { type: 'string', description: 'Optional correlation id; forwarded as X-Correlation-ID header' },
             maxAmountPerRequest: { type: 'integer', description: 'Maximum payment in USDC atomic units (1,000,000 = $1.00). If a payment requirement exceeds this, the call is refused.' },
-            paymentRequirements: { type: 'array', description: 'Pre-fetched accepts[] array from a prior x402_discover_payment_requirements call. If omitted, this tool discovers internally.' },
-            preferredNetwork: { type: 'string', enum: ['mainnet', 'testnet', 'localnet'], description: 'Preferred Algorand network. When multiple accepts entries match, this network wins. If omitted, the active wallet network is used.' },
+            paymentRequirements: {
+                type: 'array',
+                description: 'Pre-fetched accepts[] array from a prior x402_discover_payment_requirements call. If omitted, this tool discovers internally. Each element must be an OBJECT with at least { scheme, network, payTo, asset, amount }. Common mistake: passing `preferredNetwork` or `maxAmountPerRequest` as array elements instead of sibling top-level fields.',
+                items: {
+                    type: 'object',
+                    required: ['scheme', 'network', 'payTo', 'asset'],
+                    properties: {
+                        scheme: { type: 'string' },
+                        network: { type: 'string', description: 'CAIP-2 network identifier, e.g. "algorand:SGO1…" for testnet.' },
+                        amount: { type: 'string', description: 'x402 V2 canonical amount field (atomic units as decimal string).' },
+                        maxAmountRequired: { type: 'string', description: 'x402 V1 legacy amount field. Either `amount` or `maxAmountRequired` must be present.' },
+                        payTo: { type: 'string' },
+                        asset: { type: 'string' },
+                        maxTimeoutSeconds: { type: 'integer' },
+                        extra: { type: 'object' }
+                    }
+                }
+            },
+            preferredNetwork: {
+                type: 'string',
+                enum: ['mainnet', 'testnet', 'localnet'],
+                description: 'TOP-LEVEL sibling of paymentRequirements (NOT an array element). Preferred Algorand network when multiple accepts entries match. If omitted, the cheapest affordable Algorand entry is chosen.'
+            },
             extensions: { type: 'object', description: 'Optional pre-fetched PaymentRequired extensions (e.g. Bazaar resource details). Passed through to the response under `extensions`.' },
         },
         required: ['baseURL', 'path', 'method'],
     },
+    bazaarList: {
+        type: 'object',
+        properties: {
+            network: { type: 'string', description: 'Filter by network. Accepts friendly names ("algorand-mainnet", "algorand-testnet", "algorand-localnet", or bare "mainnet"/"testnet"/"localnet") or raw CAIP-2 strings ("algorand:wGHE2Pw…", "eip155:84532", "solana:EtWT…"). Friendly names are translated to CAIP-2 before the request.' },
+            method: { type: 'string', enum: HTTP_METHODS, description: 'Filter by HTTP method.' },
+            merchantId: { type: 'string', description: 'Filter by merchant id.' },
+            limit: { type: 'integer', description: 'Results per page (default 50, max 100).' },
+            offset: { type: 'integer', description: 'Pagination offset.' },
+            full: { type: 'boolean', description: 'If true, returns each item verbatim from the facilitator (large — includes full accepts[] and discoveryInfo). If false or omitted, returns a compact summary per item (URL, method, description, popularity counters, and just the Algorand-payable accepts).' },
+        },
+        required: [],
+    },
+    bazaarSearch: {
+        type: 'object',
+        properties: {
+            query: { type: 'string', description: 'Keyword to match in resource URL and description (minimum 1 char).', minLength: 1 },
+            limit: { type: 'integer', description: 'Max results to return (1–20, default 10).', minimum: 1, maximum: 20 },
+            network: { type: 'string', description: 'Filter by network (friendly name or CAIP-2). See bazaar_list for accepted values.' },
+            includeTestnets: { type: 'boolean', description: 'If true, include testnet/devnet networks in the results. Default false (mainnet-only).' },
+            scheme: { type: 'string', enum: ['exact', 'upto'], description: 'Client-side filter — only return resources whose accepts[] includes this payment scheme.' },
+            maxUsdPrice: { type: 'number', description: 'Client-side filter — exclude resources whose cheapest accepts entry exceeds this USD price (computed from amount + asset decimals). Assumes USDC pricing.', exclusiveMinimum: 0 },
+            asset: { type: 'string', description: 'Client-side filter — only return resources whose accepts[] includes this asset id.' },
+            payTo: { type: 'string', description: 'Client-side filter — only return resources whose accepts[] includes this recipient address.' },
+            extensions: { type: 'string', description: 'Client-side filter — only return resources whose discoveryInfo / extensions object contains this key (e.g. "bazaar", "outputSchema").' },
+        },
+        required: ['query'],
+    },
+    bazaarGetResourceDetails: {
+        type: 'object',
+        properties: {
+            resource: { type: 'string', description: 'Exact resource URL to fetch details for (must match the resourceUrl as registered in the Bazaar).' },
+        },
+        required: ['resource'],
+    },
 };
 // ── X402Manager ──────────────────────────────────────────────────────────────
 export class X402Manager {
@@ -62,6 +142,12 @@ export class X402Manager {
                     return await X402Manager.handleDiscover(args);
                 case 'make_http_request_with_x402':
                     return await X402Manager.handlePaidRequest(args);
+                case 'bazaar_list':
+                    return await X402Manager.handleBazaarList(args);
+                case 'bazaar_search':
+                    return await X402Manager.handleBazaarSearch(args);
+                case 'bazaar_get_resource_details':
+                    return await X402Manager.handleBazaarGetResourceDetails(args);
                 default:
                     throw new McpError(ErrorCode.MethodNotFound, `Unknown x402 tool: ${name}`);
             }
@@ -86,7 +172,35 @@ export class X402Manager {
         const preferredNetwork = typeof args.preferredNetwork === 'string' ? args.preferredNetwork : undefined;
         const extensions = args.extensions ?? undefined;
         let accepts = Array.isArray(args.paymentRequirements) ? args.paymentRequirements : undefined;
-        // 1. Discover if needed
+        // 1a. Defensive validation: every paymentRequirements entry must be an
+        //     object with at least { network, payTo, asset } and an amount field
+        //     (either x402 V2 `amount` or V1 `maxAmountRequired`). LLMs frequently
+        //     malform JSON by appending sibling field names (e.g. "preferredNetwork")
+        //     as bare strings inside this array — catch that here with an actionable
+        //     message rather than crashing later in selectRequirement.
+        if (accepts) {
+            for (let i = 0; i < accepts.length; i++) {
+                const entry = accepts[i];
+                const isObject = !!entry && typeof entry === 'object' && !Array.isArray(entry);
+                if (!isObject) {
+                    throw new McpError(ErrorCode.InvalidParams, `paymentRequirements[${i}] must be an OBJECT (got ${entry === null ? 'null' : Array.isArray(entry) ? 'array' : typeof entry}: ${JSON.stringify(entry)}). Tip: pass the accepts[] array verbatim from x402_discover_payment_requirements. Other arguments like preferredNetwork and maxAmountPerRequest are TOP-LEVEL siblings of paymentRequirements, not array members.`);
+                }
+                const e = entry;
+                const missing = [];
+                if (typeof e.network !== 'string')
+                    missing.push('network');
+                if (typeof e.payTo !== 'string')
+                    missing.push('payTo');
+                if (typeof e.asset !== 'string')
+                    missing.push('asset');
+                if (typeof e.amount !== 'string' && typeof e.maxAmountRequired !== 'string')
+                    missing.push('amount (or maxAmountRequired)');
+                if (missing.length > 0) {
+                    throw new McpError(ErrorCode.InvalidParams, `paymentRequirements[${i}] is missing required string field(s): ${missing.join(', ')}. Expected shape: { scheme, network, payTo, asset, amount, extra: { feePayer, ... } }. Pass the accepts[] entry verbatim from x402_discover_payment_requirements.`);
+                }
+            }
+        }
+        // 1b. Discover if needed
         if (!accepts || accepts.length === 0) {
             const discovered = await X402Manager.discover({ baseURL, path, method, queryParams, body });
             if (!discovered.x402 || !Array.isArray(discovered.accepts) || discovered.accepts.length === 0) {
@@ -331,6 +445,187 @@ export class X402Manager {
             ],
         };
     }
+    // ── Bazaar (discovery) handlers ────────────────────────────────────────────
+    static async handleBazaarList(args) {
+        const network = typeof args.network === 'string' ? friendlyToCaip2Network(args.network) : undefined;
+        const method = typeof args.method === 'string' ? args.method.toUpperCase() : undefined;
+        const merchantId = typeof args.merchantId === 'string' ? args.merchantId : undefined;
+        const limit = typeof args.limit === 'number' ? args.limit : undefined;
+        const offset = typeof args.offset === 'number' ? args.offset : undefined;
+        const full = args.full === true;
+        const params = {};
+        if (network)
+            params.network = network;
+        if (method)
+            params.method = method;
+        if (merchantId)
+            params.merchantId = merchantId;
+        if (limit !== undefined)
+            params.limit = String(limit);
+        if (offset !== undefined)
+            params.offset = String(offset);
+        const body = await X402Manager.bazaarRequest('/discovery/resources', params);
+        const items = Array.isArray(body?.items) ? body.items : [];
+        const pagination = body?.pagination;
+        return X402Manager.textResponse({
+            source: BAZAAR_BASE_URL,
+            pagination,
+            count: items.length,
+            items: full ? items : items.map((it) => X402Manager.summarizeBazaarItem(it)),
+        });
+    }
+    static async handleBazaarSearch(args) {
+        const query = typeof args.query === 'string' ? args.query : '';
+        if (!query || query.length < 1) {
+            throw new McpError(ErrorCode.InvalidParams, '`query` is required and must be a non-empty string.');
+        }
+        const limit = typeof args.limit === 'number' ? args.limit : 10;
+        if (limit < 1 || limit > 20) {
+            throw new McpError(ErrorCode.InvalidParams, '`limit` must be between 1 and 20.');
+        }
+        const network = typeof args.network === 'string' ? friendlyToCaip2Network(args.network) : undefined;
+        const includeTestnets = args.includeTestnets === true;
+        const scheme = typeof args.scheme === 'string' ? args.scheme : undefined;
+        const maxUsdPrice = typeof args.maxUsdPrice === 'number' ? args.maxUsdPrice : undefined;
+        const assetFilter = typeof args.asset === 'string' ? args.asset : undefined;
+        const payToFilter = typeof args.payTo === 'string' ? args.payTo : undefined;
+        const extensionsFilter = typeof args.extensions === 'string' ? args.extensions : undefined;
+        // Server-side params we can forward.
+        const params = { search: query, limit: String(Math.min(100, Math.max(limit * 5, 50))) };
+        if (network)
+            params.network = network;
+        const body = await X402Manager.bazaarRequest('/discovery/resources', params);
+        let items = Array.isArray(body?.items) ? body.items : [];
+        // Client-side filters not supported by the server.
+        if (!includeTestnets) {
+            items = items.filter((it) => Array.isArray(it?.accepts) && it.accepts.some((a) => !X402Manager.isTestnetNetwork(a?.network)));
+        }
+        if (scheme) {
+            items = items.filter((it) => Array.isArray(it?.accepts) && it.accepts.some((a) => a?.scheme === scheme));
+        }
+        if (assetFilter) {
+            items = items.filter((it) => Array.isArray(it?.accepts) && it.accepts.some((a) => String(a?.asset) === assetFilter));
+        }
+        if (payToFilter) {
+            items = items.filter((it) => Array.isArray(it?.accepts) && it.accepts.some((a) => a?.payTo === payToFilter));
+        }
+        if (maxUsdPrice !== undefined) {
+            items = items.filter((it) => {
+                const cheapest = X402Manager.cheapestUsdPrice(it?.accepts);
+                return cheapest !== null && cheapest <= maxUsdPrice;
+            });
+        }
+        if (extensionsFilter) {
+            items = items.filter((it) => {
+                const info = it?.discoveryInfo;
+                if (extensionsFilter === 'bazaar')
+                    return !!info;
+                if (info && typeof info === 'object' && extensionsFilter in info)
+                    return true;
+                return false;
+            });
+        }
+        items = items.slice(0, limit);
+        return X402Manager.textResponse({
+            source: BAZAAR_BASE_URL,
+            query,
+            filtersApplied: { network, includeTestnets, scheme, maxUsdPrice, asset: assetFilter, payTo: payToFilter, extensions: extensionsFilter },
+            count: items.length,
+            items: items.map((it) => X402Manager.summarizeBazaarItem(it)),
+        });
+    }
+    static async handleBazaarGetResourceDetails(args) {
+        const resource = typeof args.resource === 'string' ? args.resource : '';
+        if (!resource) {
+            throw new McpError(ErrorCode.InvalidParams, '`resource` is required (the exact resourceUrl as registered in the Bazaar).');
+        }
+        try {
+            new URL(resource);
+        }
+        catch {
+            throw new McpError(ErrorCode.InvalidParams, `\`resource\` is not a valid URL: ${resource}`);
+        }
+        // The facilitator API has no GET-by-id endpoint; we search by URL substring
+        // and exact-match on resourceUrl client-side.
+        const body = await X402Manager.bazaarRequest('/discovery/resources', { search: resource, limit: '100' });
+        const items = Array.isArray(body?.items) ? body.items : [];
+        const exact = items.find((it) => it?.resourceUrl === resource);
+        if (!exact) {
+            throw new McpError(ErrorCode.InvalidRequest, `No Bazaar resource found with resourceUrl=${resource}. The facilitator returned ${items.length} partial match(es) for the substring search.`);
+        }
+        return X402Manager.textResponse({ source: BAZAAR_BASE_URL, resource: exact });
+    }
+    // ── Bazaar helpers ─────────────────────────────────────────────────────────
+    static async bazaarRequest(path, query) {
+        const base = BAZAAR_BASE_URL.endsWith('/') ? BAZAAR_BASE_URL.slice(0, -1) : BAZAAR_BASE_URL;
+        const tail = path.startsWith('/') ? path : `/${path}`;
+        const url = new URL(base + tail);
+        for (const [k, v] of Object.entries(query))
+            url.searchParams.set(k, v);
+        const response = await fetch(url.toString(), { method: 'GET', headers: { accept: 'application/json' } });
+        const text = await response.text();
+        if (!response.ok) {
+            throw new McpError(ErrorCode.InternalError, `Bazaar request failed (${response.status} ${response.statusText}) for ${url.pathname}${url.search}: ${X402Manager.snippet(text)}`);
+        }
+        const parsed = X402Manager.tryParseJson(text);
+        if (parsed === null) {
+            throw new McpError(ErrorCode.InternalError, `Bazaar returned non-JSON body: ${X402Manager.snippet(text)}`);
+        }
+        return parsed;
+    }
+    static summarizeBazaarItem(item) {
+        const accepts = Array.isArray(item?.accepts) ? item.accepts : [];
+        const algorandAccepts = accepts
+            .filter(a => typeof a?.network === 'string' && a.network.startsWith('algorand:'))
+            .map(a => ({
+            network: a.network,
+            mcpNetwork: caip2ToNetwork(a.network) ?? null,
+            scheme: a.scheme,
+            amount: a.amount ?? a.maxAmountRequired,
+            asset: a.asset,
+            payTo: a.payTo,
+            usdPrice: X402Manager.usdPriceOfAccept(a),
+        }));
+        return {
+            resourceUrl: item?.resourceUrl,
+            method: item?.method,
+            description: item?.description,
+            merchantId: item?.merchantId,
+            algorandPayable: algorandAccepts.length > 0,
+            algorandAccepts,
+            totalAcceptedNetworks: accepts.length,
+            otherNetworks: accepts.filter(a => !algorandAccepts.find(ao => ao.network === a.network)).map(a => a?.network).filter(Boolean),
+            hasDiscoveryInfo: !!item?.discoveryInfo,
+            popularity: { verifyCount: item?.verifyCount ?? 0, settleCount: item?.settleCount ?? 0 },
+            firstSeen: item?.firstSeen,
+            lastSeen: item?.lastSeen,
+            id: item?.id,
+        };
+    }
+    /** USDC has 6 decimals; assume non-USDC assets are USDC-like for ballpark filtering. */
+    static usdPriceOfAccept(accept) {
+        const amountStr = accept?.amount ?? accept?.maxAmountRequired;
+        const decimals = typeof accept?.extra?.decimals === 'number' ? accept.extra.decimals : 6;
+        const n = Number(amountStr);
+        if (!Number.isFinite(n))
+            return null;
+        return n / Math.pow(10, decimals);
+    }
+    static cheapestUsdPrice(accepts) {
+        if (!Array.isArray(accepts) || accepts.length === 0)
+            return null;
+        const prices = accepts.map(a => X402Manager.usdPriceOfAccept(a)).filter((p) => p !== null);
+        if (prices.length === 0)
+            return null;
+        return Math.min(...prices);
+    }
+    static isTestnetNetwork(caip2) {
+        if (typeof caip2 !== 'string')
+            return false;
+        if (caip2 === NETWORK_TO_CAIP2.testnet)
+            return true;
+        return /sepolia|devnet|testnet/i.test(caip2);
+    }
 }
 X402Manager.x402Tools = [
     {
@@ -343,6 +638,21 @@ X402Manager.x402Tools = [
         description: 'Call an x402-protected HTTP endpoint with automatic USDC/ALGO payment from the active wallet. If `paymentRequirements` is not supplied, this tool runs discovery internally (one extra request). Builds an atomic 2-transaction group (facilitator fee-payer + wallet payment), signs the payment leg with the wallet, and resends with the `PAYMENT-SIGNATURE` header.',
         inputSchema: withCommonParams(x402ToolSchemas.makeHttpRequestWithX402),
     },
+    {
+        name: 'bazaar_list',
+        description: 'Browse paid API resources cataloged in the Bazaar (the discovery directory hosted by the configured facilitator). Returns a compact summary per resource by default; pass `full: true` for the verbatim facilitator response. Supports filtering by `network`, `method`, `merchantId`, plus standard `limit`/`offset` pagination.',
+        inputSchema: withCommonParams(x402ToolSchemas.bazaarList),
+    },
+    {
+        name: 'bazaar_search',
+        description: 'Search Bazaar paid API resources by keyword. Hits the same /discovery/resources endpoint as bazaar_list but with the `search` query forwarded to the facilitator. Additional filters (`scheme`, `maxUsdPrice`, `asset`, `payTo`, `extensions`, `includeTestnets`) are applied client-side after the response. Defaults to mainnet-only.',
+        inputSchema: withCommonParams(x402ToolSchemas.bazaarSearch),
+    },
+    {
+        name: 'bazaar_get_resource_details',
+        description: 'Fetch full details for a single Bazaar resource by its exact `resource` URL. Internally calls /discovery/resources?search=<url> and exact-matches against resourceUrl. Returns the verbatim resource record (accepts[], discoveryInfo / extensions, popularity counters) or an error if no match is found.',
+        inputSchema: withCommonParams(x402ToolSchemas.bazaarGetResourceDetails),
+    },
 ];
 // extractNetwork is imported above but the x402 tools do not currently use the
 // generic `network` arg — they derive the working network from the chosen

package/dist/types.d.ts

@@ -47,16 +47,16 @@ export declare const AccountDetailsSchema: z.ZodObject<{
     }>, "many">;
     authAddress: z.ZodOptional<z.ZodString>;
 }, "strip", z.ZodTypeAny, {
-    address: string;
     amount: number | bigint;
+    address: string;
     assets: {
         assetId: number | bigint;
         amount: number | bigint;
     }[];
     authAddress?: string | undefined;
 }, {
-    address: string;
     amount: number | bigint;
+    address: string;
     assets: {
         assetId: number | bigint;
         amount: number | bigint;
@@ -74,16 +74,16 @@ export declare const TransactionInfoSchema: z.ZodObject<{
     timestamp: z.ZodString;
 }, "strip", z.ZodTypeAny, {
     sender: string;
-    type: string;
     id: string;
+    type: string;
     timestamp: string;
     assetId?: number | bigint | undefined;
     amount?: number | bigint | undefined;
     receiver?: string | undefined;
 }, {
     sender: string;
-    type: string;
     id: string;
+    type: string;
     timestamp: string;
     assetId?: number | bigint | undefined;
     amount?: number | bigint | undefined;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@goplausible/algorand-mcp",
-  "version": "4.3.2",
+  "version": "4.4.0",
   "publishConfig": {
     "access": "public"
   },