@aibtc/mcp-server 1.70.1 → 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/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, 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()
@@ -464,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: {
@@ -476,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/pillar-direct.tools.js

@@ -88,6 +88,21 @@ function formatSigAuthForApi(sigAuth) {
             : "0x" + sigAuth.pubkey,
     };
 }
+/**
+ * The Pillar smart wallet's Fast Pool functions are hardcoded to pox-4
+ * (`pox-4.allow-contract-caller` + `pox4-fast-pool-v3.delegate-stx`, and
+ * `pox-4.revoke-delegate-stx`). Once PoX has moved past pox-4 those calls abort
+ * on chain, so refuse before signing instead of burning gas on a sure failure.
+ */
+async function assertFastPoolPoxActive(action) {
+    const pox = await getHiroApi(NETWORK).getPoxInfo();
+    if (!pox.contract_id.endsWith(".pox-4")) {
+        throw new Error(`${action} is unavailable: the Pillar smart wallet's Fast Pool path calls pox-4, but the ` +
+            `active PoX contract is ${pox.contract_id}, so the transaction would abort on chain. ` +
+            `This needs a Pillar wallet contract update. For STX staking on PoX-5, use stack_stx ` +
+            `with a signer manager (see list_stacking_signers).`);
+    }
+}
 // ============================================================================
 // Tool Registration
 // ============================================================================
@@ -1041,7 +1056,8 @@ export function registerPillarDirectTools(server) {
     server.registerTool("pillar_direct_stack_stx", {
         description: "Stack STX from your Pillar smart wallet via Fast Pool or Stacking DAO. " +
             "Agent-signed, no browser needed. Backend sponsors gas. " +
-            "Fast Pool delegates STX to the pox4-fast-pool-v3 contract. " +
+            "Fast Pool delegates STX to the pox4-fast-pool-v3 contract through pox-4, and is refused while " +
+            "pox-4 is not the active PoX contract (PoX-5 is live; use stack_stx for PoX-5 staking). " +
             "Stacking DAO deposits STX into Stacking DAO core for stSTX yield. " +
             "Your wallet must be enrolled in dual stacking first (automatic for v2 wallets with sBTC).",
         inputSchema: {
@@ -1056,6 +1072,9 @@ export function registerPillarDirectTools(server) {
         },
     }, async ({ stxAmount, pool }) => {
         try {
+            if (pool === "fast-pool") {
+                await assertFastPoolPoxActive("Fast Pool stacking");
+            }
             const { keyService, session } = await requireActiveKey();
             const authId = generateAuthId();
             // Build SIP-018 structured data matching the contract's hash builder.
@@ -1099,12 +1118,14 @@ export function registerPillarDirectTools(server) {
     });
     // --- pillar_direct_revoke_fast_pool ---
     server.registerTool("pillar_direct_revoke_fast_pool", {
-        description: "Revoke Fast Pool STX delegation from your Pillar smart wallet. " +
+        description: "Revoke Fast Pool STX delegation from your Pillar smart wallet (pox-4 revoke-delegate-stx; " +
+            "refused while pox-4 is not the active PoX contract). " +
             "Agent-signed, no browser needed. Backend sponsors gas. " +
             "After revoking, STX stays locked until the current PoX cycle ends, then returns to liquid.",
         inputSchema: {},
     }, async () => {
         try {
+            await assertFastPoolPoxActive("Revoking Fast Pool");
             const { keyService, session } = await requireActiveKey();
             const authId = generateAuthId();
             const structuredData = tupleCV({

package/dist/tools/sbtc.tools.js

@@ -1,4 +1,3 @@
-import * as btc from "@scure/btc-signer";
 import { z } from "zod";
 import { getAccount, getWalletAddress, NETWORK } from "../services/x402.service.js";
 import { getSbtcService } from "../services/sbtc.service.js";
@@ -8,26 +7,8 @@ import { getContracts, parseContractId } from "../config/contracts.js";
 import { createJsonResponse, createErrorResponse, resolveFee } from "../utils/index.js";
 import { getWalletManager } from "../services/wallet-manager.js";
 import { MempoolApi, getMempoolTxUrl } from "../services/mempool-api.js";
-import { getBtcNetwork } from "../transactions/bitcoin-builder.js";
 import { sponsoredSchema } from "./schemas.js";
-function parseBtcRecipientTuple(btcRecipientAddress) {
-    const decoded = btc.Address(getBtcNetwork(NETWORK)).decode(btcRecipientAddress);
-    if (decoded.type === "tr" && decoded.pubkey) {
-        return { version: 0x06, hashbytesHex: Buffer.from(decoded.pubkey).toString("hex") };
-    }
-    switch (decoded.type) {
-        case "pkh":
-            return { version: 0x00, hashbytesHex: Buffer.from(decoded.hash).toString("hex") };
-        case "sh":
-            return { version: 0x01, hashbytesHex: Buffer.from(decoded.hash).toString("hex") };
-        case "wpkh":
-            return { version: 0x04, hashbytesHex: Buffer.from(decoded.hash).toString("hex") };
-        case "wsh":
-            return { version: 0x05, hashbytesHex: Buffer.from(decoded.hash).toString("hex") };
-        default:
-            throw new Error("Unsupported BTC recipient address type. Supported: P2PKH, P2SH, P2WPKH, P2WSH, P2TR.");
-    }
-}
+import { btcAddressToPoxAddr } from "../utils/bitcoin.js";
 function getReadonlySenderAddress() {
     const contracts = getContracts(NETWORK);
     return parseContractId(contracts.SBTC_REGISTRY).address;
@@ -107,7 +88,7 @@ Example: To send 0.001 sBTC, use amount "100000" (satoshis).`,
         const sbtcService = getSbtcService(NETWORK);
         const account = await getAccount();
         const resolvedFee = await resolveFee(fee, NETWORK, "contract_call");
-        const recipientTuple = parseBtcRecipientTuple(btcRecipientAddress);
+        const recipientTuple = btcAddressToPoxAddr(btcRecipientAddress, NETWORK);
         const result = await sbtcService.initiateWithdrawal(account, BigInt(amount), BigInt(maxFee), recipientTuple, resolvedFee, sponsored);
         let requestId = null;
         try {

package/dist/tools/skill-mappings.js

@@ -68,6 +68,10 @@ export const TOOL_SKILL_MAP = {
     get_stacking_status: "stacking",
     stack_stx: "stacking",
     extend_stacking: "stacking",
+    list_stacking_signers: "stacking",
+    unstake_stx: "stacking",
+    get_stacking_rewards: "stacking",
+    claim_stacking_rewards: "stacking",
     // dual-stacking skill — sBTC Dual Stacking yield protocol
     dual_stacking_status: "dual-stacking",
     dual_stacking_get_rewards: "dual-stacking",