paygate-mcp 10.2.0 → 10.3.0

package/dist/server.js

@@ -126,6 +126,7 @@ const config_profiles_1 = require("./config-profiles");
 const scheduled_reports_1 = require("./scheduled-reports");
 const approval_workflows_1 = require("./approval-workflows");
 const gateway_hooks_1 = require("./gateway-hooks");
+const dynamic_discovery_1 = require("./dynamic-discovery");
 /** Max request body size: 1MB */
 const MAX_BODY_SIZE = 1_048_576;
 /**
@@ -495,6 +496,8 @@ class PayGateServer {
     scheduledReports;
     approvalWorkflows;
     gatewayHooks;
+    /** Cached backend tool list for dynamic discovery mode. */
+    cachedBackendTools = null;
     /** The active request handler — either proxy or router */
     get handler() {
         return (this.router || this.proxy);
@@ -1996,6 +1999,130 @@ class PayGateServer {
             }
             return;
         }
+        // ─── Dynamic Discovery Mode ──────────────────────────────────────────────
+        // When discoveryMode === 'dynamic', intercept tools/list and meta-tool calls.
+        if (this.config.discoveryMode === 'dynamic') {
+            // Intercept tools/list → return meta-tools instead of backend tools
+            if (request.method === 'tools/list') {
+                // Cache backend tools on first tools/list (lazy initialization)
+                if (!this.cachedBackendTools) {
+                    try {
+                        const backendResponse = await this.handler.handleRequest(request, apiKey, clientIp, scopedTokenTools, countryCode);
+                        const backendResult = backendResponse.result;
+                        this.cachedBackendTools = (backendResult?.tools || []).map(t => ({
+                            name: t.name,
+                            description: t.description,
+                            inputSchema: t.inputSchema,
+                        }));
+                    }
+                    catch {
+                        this.cachedBackendTools = [];
+                    }
+                }
+                const metaTools = (0, dynamic_discovery_1.getMetaTools)();
+                const rateLimitHeaders = this.buildRateLimitHeaders(apiKey, request);
+                const accept = req.headers['accept'] || '';
+                const wantsSse = accept.includes('text/event-stream');
+                const metaResponse = {
+                    jsonrpc: '2.0',
+                    id: request.id,
+                    result: { tools: metaTools },
+                };
+                if (wantsSse) {
+                    (0, session_1.writeSseHeaders)(res, { 'Mcp-Session-Id': sessionId, ...rateLimitHeaders });
+                    (0, session_1.writeSseEvent)(res, metaResponse, 'message');
+                    res.end();
+                }
+                else {
+                    res.writeHead(200, {
+                        'Content-Type': 'application/json',
+                        'Mcp-Session-Id': sessionId,
+                        ...rateLimitHeaders,
+                    });
+                    res.end(JSON.stringify(metaResponse));
+                }
+                return;
+            }
+            // Intercept tools/call for meta-tools
+            if (request.method === 'tools/call') {
+                const metaToolName = request.params?.name || '';
+                if (metaToolName === 'paygate_call_tool') {
+                    // Unwrap paygate_call_tool → rewrite as a regular tools/call
+                    const metaArgs = request.params?.arguments || {};
+                    const realToolName = String(metaArgs.name || '');
+                    const realArgs = metaArgs.arguments || {};
+                    if (!realToolName) {
+                        const rateLimitHeaders = this.buildRateLimitHeaders(apiKey, request);
+                        const accept = req.headers['accept'] || '';
+                        const wantsSse = accept.includes('text/event-stream');
+                        const errResp = {
+                            jsonrpc: '2.0',
+                            id: request.id,
+                            error: { code: -32602, message: 'paygate_call_tool requires "name" argument' },
+                        };
+                        if (wantsSse) {
+                            (0, session_1.writeSseHeaders)(res, { 'Mcp-Session-Id': sessionId, ...rateLimitHeaders });
+                            (0, session_1.writeSseEvent)(res, errResp, 'message');
+                            res.end();
+                        }
+                        else {
+                            res.writeHead(200, { 'Content-Type': 'application/json', 'Mcp-Session-Id': sessionId, ...rateLimitHeaders });
+                            res.end(JSON.stringify(errResp));
+                        }
+                        return;
+                    }
+                    // Rewrite the request to call the real tool
+                    request = {
+                        ...request,
+                        params: { name: realToolName, arguments: realArgs },
+                    };
+                }
+                else if (metaToolName === 'paygate_list_tools' || metaToolName === 'paygate_search_tools') {
+                    // Handle list/search meta-tools locally (no credits charged, no gating)
+                    if (!this.cachedBackendTools) {
+                        try {
+                            const listReq = { jsonrpc: '2.0', id: 'discovery-init', method: 'tools/list', params: {} };
+                            const backendResponse = await this.handler.handleRequest(listReq, null, clientIp);
+                            const backendResult = backendResponse.result;
+                            this.cachedBackendTools = (backendResult?.tools || []).map(t => ({
+                                name: t.name,
+                                description: t.description,
+                                inputSchema: t.inputSchema,
+                            }));
+                        }
+                        catch {
+                            this.cachedBackendTools = [];
+                        }
+                    }
+                    const metaArgs = request.params?.arguments || {};
+                    const discoveryConfig = {
+                        defaultCreditsPerCall: this.config.defaultCreditsPerCall,
+                        toolPricing: this.config.toolPricing,
+                        globalRateLimitPerMin: this.config.globalRateLimitPerMin,
+                    };
+                    const metaResult = (0, dynamic_discovery_1.handleMetaToolCall)(metaToolName, metaArgs, this.cachedBackendTools, discoveryConfig);
+                    const rateLimitHeaders = this.buildRateLimitHeaders(apiKey, request);
+                    const accept = req.headers['accept'] || '';
+                    const wantsSse = accept.includes('text/event-stream');
+                    const metaResponse = {
+                        jsonrpc: '2.0',
+                        id: request.id,
+                        result: metaResult || { content: [{ type: 'text', text: '{}' }] },
+                    };
+                    if (wantsSse) {
+                        (0, session_1.writeSseHeaders)(res, { 'Mcp-Session-Id': sessionId, ...rateLimitHeaders });
+                        (0, session_1.writeSseEvent)(res, metaResponse, 'message');
+                        res.end();
+                    }
+                    else {
+                        res.writeHead(200, { 'Content-Type': 'application/json', 'Mcp-Session-Id': sessionId, ...rateLimitHeaders });
+                        res.end(JSON.stringify(metaResponse));
+                    }
+                    return;
+                }
+                // If not a meta-tool, fall through to normal tools/call handling
+            }
+        }
         // Plugin: beforeToolCall — let plugins modify the request before forwarding
         let pluginRequest = request;
         if (this.plugins.count > 0 && request.method === 'tools/call') {