@aibtc/mcp-server 1.70.0 → 1.71.0

package/dist/services/x402-discovery.service.js

@@ -0,0 +1,170 @@
+/**
+ * Live x402 endpoint discovery.
+ *
+ * x402.aibtc.com and stx402.com publish an OpenAPI spec, and stx402.com runs a
+ * directory of x402 endpoints registered by third parties. Reading those at call
+ * time keeps `list_x402_endpoints` in step with what the hosts actually serve,
+ * instead of a hand-maintained list that goes stale when routes move.
+ *
+ * Results are cached briefly. A failed fetch is never cached and never replaced
+ * with stale or invented entries: the source is reported as unavailable.
+ */
+import { NETWORK } from "../config/networks.js";
+export const OPENAPI_SOURCES = [
+    {
+        source: "x402.aibtc.com",
+        baseUrl: { mainnet: "https://x402.aibtc.com", testnet: "https://x402.aibtc.dev" },
+    },
+    {
+        source: "stx402.com",
+        baseUrl: { mainnet: "https://stx402.com" },
+    },
+];
+const DIRECTORY_URL = "https://stx402.com/registry/list";
+const DIRECTORY_PAGE_SIZE = 50;
+/** Hard stop so a misbehaving `total` cannot turn one call into hundreds of requests. */
+const DIRECTORY_MAX_PAGES = 20;
+export const DISCOVERY_CACHE_TTL_MS = 10 * 60 * 1000;
+const FETCH_TIMEOUT_MS = 10_000;
+const cache = new Map();
+async function cached(key, load) {
+    const hit = cache.get(key);
+    if (hit && Date.now() - hit.at < DISCOVERY_CACHE_TTL_MS) {
+        return hit.value;
+    }
+    const value = await load();
+    cache.set(key, { at: Date.now(), value });
+    return value;
+}
+/** Test seam. */
+export function clearDiscoveryCache() {
+    cache.clear();
+}
+async function fetchJson(url) {
+    const response = await fetch(url, {
+        headers: { Accept: "application/json" },
+        signal: AbortSignal.timeout(FETCH_TIMEOUT_MS),
+    });
+    if (!response.ok) {
+        throw new Error(`GET ${url} returned HTTP ${response.status}`);
+    }
+    return response.json();
+}
+const METHODS = ["get", "post", "put", "delete"];
+/**
+ * Summaries on these hosts lead with the pricing tier, e.g. "(paid, standard) Decode a
+ * transaction" or "(free) List models". Split that into a cost label and a description.
+ * The exact price is only known from the 402 challenge, so it is not guessed here.
+ */
+export function parseSummary(summary) {
+    const match = summary.match(/^\((free|paid)(?:,\s*([^)]+))?\)\s*(.*)$/i);
+    if (match) {
+        const [, kind, tier, rest] = match;
+        return {
+            cost: kind.toLowerCase() === "free" ? "FREE" : `paid${tier ? ` (${tier.trim()})` : ""}`,
+            description: rest,
+        };
+    }
+    if (/\(free\)/i.test(summary)) {
+        return { cost: "FREE", description: summary.replace(/\s*\(free\)/i, "") };
+    }
+    return { cost: "see probe_x402_endpoint", description: summary };
+}
+/** Map an OpenAPI spec to endpoint entries. Admin-only operations are left out. */
+export function endpointsFromOpenApi(spec, source) {
+    const endpoints = [];
+    for (const [path, operations] of Object.entries(spec.paths ?? {})) {
+        for (const method of METHODS) {
+            const op = operations[method];
+            if (!op)
+                continue;
+            const tags = op.tags ?? [];
+            if (tags.some((tag) => /admin/i.test(tag)))
+                continue;
+            const { cost, description } = parseSummary(op.summary ?? op.description ?? "");
+            // tokenType selects the payment asset; execute_x402_endpoint handles that itself.
+            const params = Object.fromEntries((op.parameters ?? [])
+                .filter((p) => p.name !== "tokenType")
+                .map((p) => [p.name, p.description ?? p.in]));
+            const schema = op.requestBody?.content?.["application/json"]?.schema;
+            const required = new Set(schema?.required ?? []);
+            const body = Object.fromEntries(Object.entries(schema?.properties ?? {}).map(([name, prop]) => [
+                name,
+                `${prop.description ?? name}${required.has(name) ? "" : " (optional)"}`,
+            ]));
+            endpoints.push({
+                path,
+                method: method.toUpperCase(),
+                description,
+                cost,
+                category: tags[0] ?? "Other",
+                source,
+                ...(Object.keys(params).length > 0 && { params }),
+                ...(Object.keys(body).length > 0 && { body }),
+            });
+        }
+    }
+    return endpoints;
+}
+/** Fetch one host's endpoints from its OpenAPI spec. */
+export function fetchOpenApiEndpoints(source, network = NETWORK) {
+    const baseUrl = source.baseUrl[network];
+    if (!baseUrl) {
+        return Promise.reject(new Error(`${source.source} has no ${network} deployment`));
+    }
+    return cached(`openapi:${baseUrl}`, async () => {
+        const spec = (await fetchJson(`${baseUrl}/openapi.json`));
+        if (!spec.paths) {
+            throw new Error(`${baseUrl}/openapi.json has no paths`);
+        }
+        return endpointsFromOpenApi(spec, source.source);
+    });
+}
+/** Fetch every entry in the stx402.com endpoint directory (mainnet only). */
+export function fetchDirectoryEntries() {
+    return cached("directory", async () => {
+        const entries = [];
+        let total = Infinity;
+        for (let page = 0; page < DIRECTORY_MAX_PAGES && entries.length < total; page++) {
+            const offset = page * DIRECTORY_PAGE_SIZE;
+            const data = (await fetchJson(`${DIRECTORY_URL}?limit=${DIRECTORY_PAGE_SIZE}&offset=${offset}`));
+            if (!Array.isArray(data.entries)) {
+                throw new Error(`${DIRECTORY_URL} response has no entries array`);
+            }
+            total = data.total ?? entries.length + data.entries.length;
+            for (const e of data.entries) {
+                if (!e.url)
+                    continue;
+                entries.push({
+                    name: e.name ?? e.url,
+                    url: e.url,
+                    category: e.category ?? "other",
+                    status: e.status ?? "unknown",
+                    owner: e.owner ?? "",
+                });
+            }
+            if (data.entries.length < DIRECTORY_PAGE_SIZE)
+                break;
+        }
+        return entries;
+    });
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+/** Fetch every OpenAPI source in parallel, reporting failures per source. */
+export async function discoverOpenApiEndpoints(sources = OPENAPI_SOURCES, network = NETWORK) {
+    const results = await Promise.allSettled(sources.map((s) => fetchOpenApiEndpoints(s, network)));
+    const endpoints = [];
+    const unavailable = [];
+    results.forEach((result, i) => {
+        if (result.status === "fulfilled") {
+            endpoints.push(...result.value);
+        }
+        else {
+            unavailable.push({ source: sources[i].source, error: errorMessage(result.reason) });
+        }
+    });
+    return { endpoints, unavailable };
+}
+//# sourceMappingURL=x402-discovery.service.js.map

package/dist/tools/defi.tools.js

@@ -12,7 +12,7 @@ export function registerDefiTools(server) {
         description: `Get a swap quote from ALEX DEX.
 
 Returns the expected output amount for swapping tokenX to tokenY.
-Use full contract IDs for tokens (e.g., 'SP3K8BC0PPEVCV7NZ6QSRWPQ2JE9E5B6N3PA0KBR9.token-wstx-v2').
+Use full contract IDs for tokens (e.g., 'SP102V8P0F7JX67ARQ77WEA3D3CFB5XW39REDT0AM.token-wstx-v2').
 
 Note: ALEX DEX is only available on mainnet.`,
         inputSchema: {

package/dist/tools/earning.tools.js

@@ -15,9 +15,9 @@ export const EARNING_STRATEGIES = [
         id: "stacking",
         name: "Bitcoin Stacking (PoX)",
         assets: ["STX"],
-        returns: "BTC / sBTC rewards per PoX cycle",
-        summary: "Lock STX to support Stacks consensus and earn Bitcoin rewards. Dual Stacking routes the yield as sBTC.",
-        start_with: ["get_stacking_status", "stack_stx", "dual_stacking_enroll"],
+        returns: "sBTC rewards per PoX cycle",
+        summary: "Lock STX with a PoX-5 signer manager to support Stacks consensus and earn sBTC rewards (or BTC via the manager's payout address). Dual Stacking routes the yield as sBTC.",
+        start_with: ["list_stacking_signers", "stack_stx", "get_stacking_status", "dual_stacking_enroll"],
     },
     {
         id: "defi_yield",

package/dist/tools/endpoint.tools.js

@@ -1,12 +1,12 @@
 import { z } from "zod";
 import { createApiClient, API_URL, probeEndpoint, formatPaymentAmount, checkSufficientBalance, generateDedupKey, checkDedupCache, recordTransaction, X402_DEDUP_TTL_MS, NETWORK } from "../services/x402.service.js";
-import { ALL_ENDPOINTS, searchEndpoints, formatEndpointsTable, getEndpointsBySource, getCategories, } from "../endpoints/registry.js";
+import { STATIC_ENDPOINTS, formatEndpointsTable } from "../endpoints/registry.js";
+import { discoverOpenApiEndpoints, fetchDirectoryEntries, } from "../services/x402-discovery.service.js";
 import { createJsonResponse, createErrorResponse } from "../utils/index.js";
-import { X402_HEADERS } from "../utils/x402-protocol.js";
+import { X402_HEADERS, decodePaymentResponse } from "../utils/x402-protocol.js";
 import { extractPaymentIdFromPaymentSignature, extractTxidFromPaymentSignature, pollTransactionConfirmation, } from "../utils/x402-recovery.js";
 import { formatCanonicalPaymentStatus } from "../utils/x402-payment-state.js";
 import { emitPaymentLog } from "../utils/x402-payment-logging.js";
-const ALL_SOURCES = "x402.biwas.xyz, x402.aibtc.com, stx402.com, aibtc.com";
 /**
  * Parse and validate endpoint URL from either a full URL or path+apiUrl combination.
  * Merges any query parameters from the URL into the provided params.
@@ -130,27 +130,26 @@ function formatProbeResponse(result, method, fullUrl, callWithOptions, messagePr
 export function registerEndpointTools(server) {
     // List x402 endpoints
     server.registerTool("list_x402_endpoints", {
-        description: `List known x402 API endpoints from ${ALL_SOURCES}.
-
-The agent can:
-1. Execute x402 endpoints from these sources (paid API calls with automatic payment handling)
-2. Execute direct Stacks transactions (transfer STX, call contracts, deploy contracts)
+        description: `List x402 API endpoints. x402.aibtc.com and stx402.com are read live from their OpenAPI specs; the stx402.com directory lists x402 endpoints registered by third parties.
 
 Sources:
 - x402.biwas.xyz: DeFi analytics, market data, wallet analysis, Zest/ALEX protocols
-- x402.aibtc.com: AI inference, OpenRouter integration, Stacks utilities, hashing, storage
-- stx402.com: AI services, cryptography, storage, utilities, agent registry
-- aibtc.com: Inbox messaging system`,
+- x402.aibtc.com: AI inference, Stacks utilities, hashing, storage (live)
+- stx402.com: x402 endpoint registry, agent registry (ERC-8004), links (live)
+- aibtc.com: Inbox messaging
+- directory: third-party endpoints registered at stx402.com (live, mainnet). Unverified entries are hidden unless includeUnverified is true — probe before paying.
+
+Costs from live specs are tiers ("paid (standard)", "paid (dynamic)"); use probe_x402_endpoint for the exact price.`,
         inputSchema: {
             source: z
-                .enum(["x402.biwas.xyz", "x402.aibtc.com", "stx402.com", "aibtc.com", "all"])
+                .enum(["x402.biwas.xyz", "x402.aibtc.com", "stx402.com", "aibtc.com", "directory", "all"])
                 .optional()
                 .default("all")
                 .describe("Filter by API source"),
             category: z
                 .string()
                 .optional()
-                .describe("Filter by category (use without value to see available categories)"),
+                .describe("Filter by category (case-insensitive)"),
             search: z
                 .string()
                 .optional()
@@ -163,12 +162,42 @@ Sources:
                 .boolean()
                 .optional()
                 .describe("Only show paid endpoints (require x402 payment)"),
+            includeUnverified: z
+                .boolean()
+                .optional()
+                .default(false)
+                .describe("Include unverified third-party entries from the stx402.com directory"),
         },
-    }, async ({ source, category, search, showFreeOnly, showPaidOnly }) => {
+    }, async ({ source, category, search, showFreeOnly, showPaidOnly, includeUnverified }) => {
         try {
-            let endpoints = ALL_ENDPOINTS;
-            if (source && source !== "all") {
-                endpoints = getEndpointsBySource(source);
+            const wanted = source ?? "all";
+            const unavailable = [];
+            let endpoints = STATIC_ENDPOINTS.filter((ep) => wanted === "all" || ep.source === wanted);
+            if (wanted === "all" || wanted === "x402.aibtc.com" || wanted === "stx402.com") {
+                const live = await discoverOpenApiEndpoints();
+                endpoints.push(...live.endpoints.filter((ep) => wanted === "all" || ep.source === wanted));
+                unavailable.push(...live.unavailable.filter((u) => wanted === "all" || u.source === wanted));
+            }
+            let directory = [];
+            // Directory entries carry no method or price, so they only answer
+            // unfiltered or keyword/category browsing, not free/paid filters.
+            if ((wanted === "all" || wanted === "directory") && !showFreeOnly && !showPaidOnly) {
+                if (NETWORK !== "mainnet") {
+                    if (wanted === "directory") {
+                        unavailable.push({ source: "directory", error: "the stx402.com directory lists mainnet endpoints only" });
+                    }
+                }
+                else {
+                    try {
+                        directory = (await fetchDirectoryEntries()).filter((e) => includeUnverified || e.status === "verified");
+                    }
+                    catch (error) {
+                        unavailable.push({
+                            source: "directory",
+                            error: error instanceof Error ? error.message : String(error),
+                        });
+                    }
+                }
             }
             if (showFreeOnly) {
                 endpoints = endpoints.filter((ep) => ep.cost === "FREE");
@@ -177,38 +206,51 @@ Sources:
                 endpoints = endpoints.filter((ep) => ep.cost !== "FREE");
             }
             if (category) {
-                endpoints = endpoints.filter((ep) => ep.category.toLowerCase() === category.toLowerCase());
+                const c = category.toLowerCase();
+                endpoints = endpoints.filter((ep) => ep.category.toLowerCase() === c);
+                directory = directory.filter((e) => e.category.toLowerCase() === c);
             }
             if (search) {
-                const searchResults = searchEndpoints(search);
-                endpoints = endpoints.filter((ep) => searchResults.includes(ep));
+                const q = search.toLowerCase();
+                endpoints = endpoints.filter((ep) => ep.path.toLowerCase().includes(q) ||
+                    ep.description.toLowerCase().includes(q) ||
+                    ep.category.toLowerCase().includes(q));
+                directory = directory.filter((e) => e.name.toLowerCase().includes(q) ||
+                    e.url.toLowerCase().includes(q) ||
+                    e.category.toLowerCase().includes(q));
             }
-            if (endpoints.length === 0) {
-                const categories = getCategories();
+            const unavailableText = unavailable.length > 0
+                ? `\n\n## Unavailable sources\n${unavailable.map((u) => `- ${u.source}: ${u.error}`).join("\n")}`
+                : "";
+            if (endpoints.length === 0 && directory.length === 0) {
                 return {
                     content: [
                         {
                             type: "text",
-                            text: `No endpoints found matching your criteria.
-
-Available categories: ${categories.join(", ")}
-
-Sources: ${ALL_SOURCES}
-
-If you're looking to perform a direct blockchain action (transfer STX, call a contract), those are available via separate tools.`,
+                            text: `No endpoints found matching your criteria (source: ${wanted}).` +
+                                unavailableText +
+                                `\n\nIf you're looking to perform a direct blockchain action (transfer STX, call a contract), those are available via separate tools.`,
                         },
                     ],
                 };
             }
-            const formatted = formatEndpointsTable(endpoints);
-            const sourceInfo = source === "all"
-                ? `Sources: ${ALL_SOURCES}`
-                : `Source: ${source}`;
+            const directoryText = directory.length > 0
+                ? `\n\n## Directory (stx402.com, third-party)\n` +
+                    directory
+                        .map((e) => `- ${e.name} [${e.category}, ${e.status}]\n  ${e.url}`)
+                        .join("\n")
+                : "";
             return {
                 content: [
                     {
                         type: "text",
-                        text: `# Available x402 Endpoints (${endpoints.length} total)\n\n${sourceInfo}\nDefault API: ${API_URL}\n${formatted}\n\n---\nUse execute_x402_endpoint to call any of these endpoints.`,
+                        text: `# Available x402 Endpoints (${endpoints.length + directory.length} total)\n\n` +
+                            `Source: ${wanted}\nDefault API: ${API_URL}\n` +
+                            (endpoints.length > 0 ? `\n${formatEndpointsTable(endpoints)}` : "") +
+                            directoryText +
+                            unavailableText +
+                            `\n\n---\nUse execute_x402_endpoint to call an endpoint (full url for directory entries). ` +
+                            `Use probe_x402_endpoint first to see the exact price.`,
                     },
                 ],
             };
@@ -224,7 +266,7 @@ If you're looking to perform a direct blockchain action (transfer STX, call a co
 Supported sources:
 - x402.biwas.xyz (default): Use path like "/api/pools/trending"
 - x402.aibtc.com (mainnet) / x402.aibtc.dev (testnet): Use apiUrl="https://x402.aibtc.com" with path like "/inference/openrouter/chat"
-- stx402.com: Use apiUrl="https://stx402.com" with path like "/ai/dad-joke"
+- stx402.com: Use apiUrl="https://stx402.com" with path like "/registry/list"
 - aibtc.com (mainnet) / aibtc.dev (testnet): Use apiUrl="https://aibtc.com" with path like "/api/inbox/{address}"
 - Any x402-compatible URL: Use url parameter with full endpoint URL
 
@@ -240,7 +282,7 @@ For aibtc.com inbox messages, use send_inbox_message_direct instead — it signs
                 .string()
                 .url()
                 .optional()
-                .describe("Full endpoint URL (e.g., 'https://stx402.com/ai/dad-joke'). Takes precedence over path+apiUrl."),
+                .describe("Full endpoint URL (e.g., 'https://x402.aibtc.com/hashing/sha256'). Takes precedence over path+apiUrl."),
             path: z
                 .string()
                 .optional()
@@ -317,8 +359,13 @@ For aibtc.com inbox messages, use send_inbox_message_direct instead — it signs
                 },
             });
             const response = await api.request({ method, url: parsed.requestPath, params, data });
+            const paymentResponseTxid = decodePaymentResponse(response.headers?.[X402_HEADERS.PAYMENT_RESPONSE])?.transaction ||
+                undefined;
+            const paymentBodyTxid = response.data?.payment?.txid;
             const rawTxid = response.data?.txid ||
                 response.data?.payment_txid ||
+                paymentResponseTxid ||
+                (typeof paymentBodyTxid === "string" ? paymentBodyTxid : undefined) ||
                 response.headers?.['x-transaction-id'] ||
                 undefined;
             // Detect whether a payment was made by checking for the payment-signature
@@ -459,7 +506,7 @@ After probing a paid endpoint, use execute_x402_endpoint to actually execute and
 Supported sources:
 - x402.biwas.xyz (default): Use path like "/api/pools/trending"
 - x402.aibtc.com (mainnet) / x402.aibtc.dev (testnet): Use apiUrl="https://x402.aibtc.com" with path like "/inference/openrouter/chat"
-- stx402.com: Use apiUrl="https://stx402.com" with path like "/ai/dad-joke"
+- stx402.com: Use apiUrl="https://stx402.com" with path like "/registry/list"
 - aibtc.com (mainnet) / aibtc.dev (testnet): Use apiUrl="https://aibtc.com" with path like "/api/inbox/{address}"
 - Any x402-compatible URL: Use url parameter with full endpoint URL`,
         inputSchema: {
@@ -471,7 +518,7 @@ Supported sources:
                 .string()
                 .url()
                 .optional()
-                .describe("Full endpoint URL (e.g., 'https://stx402.com/ai/dad-joke'). Takes precedence over path+apiUrl."),
+                .describe("Full endpoint URL (e.g., 'https://x402.aibtc.com/hashing/sha256'). Takes precedence over path+apiUrl."),
             path: z
                 .string()
                 .optional()

package/dist/tools/index.js

@@ -32,6 +32,8 @@ import { registerTeneroTools } from "./tenero.tools.js";
 import { registerOrdinalsP2PTools } from "./ordinals-p2p.tools.js";
 import { registerOrdinalsMarketplaceTools } from "./ordinals-marketplace.tools.js";
 import { registerTaprootMultisigTools } from "./taproot-multisig.tools.js";
+import { registerPsbtTools } from "./psbt.tools.js";
+import { registerSettingsTools } from "./settings.tools.js";
 import { registerJingswapTools } from "./jingswap.tools.js";
 import { registerSigningTools } from "./signing.tools.js";
 import { registerInferenceMarketplaceTools } from "./inference-marketplace.tools.js";
@@ -161,13 +163,17 @@ export function registerAllTools(server) {
     registerOrdinalsMarketplaceTools(server);
     // Taproot Multisig (M-of-N coordination via OP_CHECKSIGADD, BIP-341/342)
     registerTaprootMultisigTools(server);
+    // PSBT sign/broadcast/decode (used by the ordinals marketplace, P2P and taproot multisig flows)
+    registerPsbtTools(server);
+    // Settings (Hiro API key, custom Stacks API URL, server version)
+    registerSettingsTools(server);
     // Jingswap Auction (blind batch auctions for STX/sBTC)
     registerJingswapTools(server);
     // Message Signing (BTC BIP-322, Stacks SIWS, SIP-018 structured data, Nostr NIP-01)
     registerSigningTools(server);
     // AIBTC Inference Marketplace (list/manage a paid model endpoint via wallet signature)
     registerInferenceMarketplaceTools(server);
-    // AIBTC News (signal feed, leaderboard, file signals)
+    // AIBTC News (deprecated — API retired; each tool redirects to legion_*)
     registerNewsTools(server);
     // AIBTC News Legion (mainnet aibtc-news-gov — inscribe, propose, vote, conclude)
     registerLegionTools(server);

package/dist/tools/news.tools.d.ts

@@ -1,36 +1,10 @@
 /**
- * AIBTC News Tools
+ * AIBTC News tools — deprecated.
  *
- * Tools for interacting with the aibtc.news decentralized intelligence network.
- * Agents can read signal feeds, check correspondent standings, and file signals
- * authenticated via BIP-322 signatures (bc1q P2WPKH addresses only).
- *
- * Correspondent tools (read-only, no auth required):
- * - news_list_signals  — Browse the signal feed with optional filters
- * - news_front_page    — Get the latest compiled intelligence brief
- * - news_leaderboard   — Ranked correspondents with signal counts and streaks
- * - news_check_status  — Signal counts, streak, and earnings for a BTC address
- * - news_list_beats    — List all registered beats
- * - news_list_editors  — List editors registered on a beat
- *
- * Authenticated tools (require unlocked wallet with bc1q/tb1q address):
- * - news_file_signal                — File a signal on a beat (BIP-322 signed)
- * - news_claim_beat                 — Create or join a beat (BIP-322 signed)
- * - news_editor_review_signal       — Approve or reject a signal (editor or publisher)
- * - news_editor_file_review         — Submit structured editorial review for a signal
- * - news_editor_check_earnings      — Check editor earnings for an address
- * - news_register_editor            — Register an editor on a beat (publisher only)
- * - news_deactivate_editor          — Deactivate an editor on a beat (publisher only)
- * - news_file_correction            — File a correction on a signal
- * - news_publisher_compile_brief    — Compile the daily intelligence brief (publisher only)
- * - news_publisher_set_beat_config  — Update beat details and config (publisher only)
- * - news_record_editor_payout       — Record payout txid for an editor earning (publisher only)
- *
- * Authentication: BIP-322 simple signature (P2WPKH, bc1q mainnet / tb1q testnet).
- * Message format: "METHOD /path:unix_timestamp"
- * Headers: X-BTC-Address, X-BTC-Signature, X-BTC-Timestamp
- *
- * Reference: https://aibtc.news/api (GET /api for full spec)
+ * aibtc.news migrated from an off-chain newsroom API to on-chain governance, and
+ * every endpoint these tools called now answers 410 Gone. The tool names stay
+ * registered so an agent that still calls one is told where the workflow moved
+ * (the legion_* tools) instead of getting "unknown tool".
  */
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 export declare function registerNewsTools(server: McpServer): void;