agenticbtc-mcp 1.0.9 → 1.0.10

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agenticbtc-mcp",
-  "version": "1.0.9",
+  "version": "1.0.10",
   "description": "Privacy-intelligent payments for AI agents — your privacy, your choice. Universal payment router with Lightning, Strike, Coinbase, PayPal, Venmo support.",
   "keywords": [
     "bitcoin",

package/src/server.js

@@ -771,6 +771,107 @@ server.tool(
   }
 );
 
+// Tool: Universal send_payment — auto-detects recipient type
+server.tool(
+  "send_payment",
+  "Send a payment to any recipient. Automatically detects recipient type: BOLT11 Lightning invoice (lnbc.../lntb...), Lightning address (user@domain.com), or Strike handle ($username). Routes through the optimal payment rail.",
+  {
+    recipient: z.string().describe("Where to send: Lightning invoice (lnbc.../lntb...), Lightning address (user@domain.com), or Strike handle ($username)"),
+    amount_sats: z.number().optional().describe("Amount in satoshis (required for Lightning address and Strike handle; optional for BOLT11 invoices which encode the amount)"),
+    amount_usd: z.number().optional().describe("Amount in USD (for Strike handle payments; alternative to amount_sats)"),
+    memo: z.string().optional().default("").describe("Optional payment memo or comment"),
+    agent: z.string().optional().describe("Agent wallet name or ID for spending policy enforcement"),
+  },
+  async ({ recipient, amount_sats, amount_usd, memo, agent }) => {
+    // Detect recipient type
+    const isBolt11 = /^lnbc|^lntb|^lnbcrt/i.test(recipient);
+    const isStrikeHandle = recipient.startsWith("$");
+    const isLightningAddress = !isBolt11 && !isStrikeHandle && recipient.includes("@");
+
+    // Resolve agent for spending policy
+    let resolvedAgent = null;
+    if (agent) {
+      resolvedAgent = await resolveAgent(agent);
+      if (!resolvedAgent) return { content: [{ type: "text", text: `Error: Agent '${agent}' not found` }] };
+      if (!resolvedAgent.enabled) return { content: [{ type: "text", text: `Error: Agent '${resolvedAgent.name}' is disabled` }] };
+    }
+    if (!resolvedAgent) {
+      const auth = await getAuthLevel();
+      if (auth.agent_id) resolvedAgent = { id: auth.agent_id, name: auth.agent_name || auth.agent_id };
+    }
+
+    if (isBolt11) {
+      // Delegate to router via pay_lightning_invoice logic
+      if (resolvedAgent) {
+        const policy = await checkSpendingPolicy(resolvedAgent.id, amount_sats || 0);
+        if (!policy.allowed) return { content: [{ type: "text", text: `Payment blocked: ${policy.reason}` }] };
+      }
+      const { status, data } = await apiCall("/api/v1/payments", {
+        method: "POST",
+        body: JSON.stringify({ invoice: recipient, fee_limit_sats: 100 }),
+      });
+      if (status === 200 && data.success) {
+        return { content: [{ type: "text", text: JSON.stringify({ success: true, type: "lightning_invoice", amount_sats: data.amount_sats, fee_sats: data.fee_sats || 0, rail: data.rail, payment_hash: data.payment_hash }) }] };
+      }
+      return { content: [{ type: "text", text: `Payment failed: ${data?.detail || data?.error || JSON.stringify(data)}` }] };
+
+    } else if (isLightningAddress) {
+      if (!amount_sats) return { content: [{ type: "text", text: "Error: amount_sats required for Lightning address payments" }] };
+      if (resolvedAgent) {
+        const policy = await checkSpendingPolicy(resolvedAgent.id, amount_sats);
+        if (!policy.allowed) return { content: [{ type: "text", text: `Payment blocked: ${policy.reason}` }] };
+      }
+      // LNURL resolve → pay via router
+      const [user, domain] = recipient.split("@");
+      const lnurlRes = await fetch(`https://${domain}/.well-known/lnurlp/${user}`);
+      if (!lnurlRes.ok) return { content: [{ type: "text", text: `Error: Could not resolve Lightning address ${recipient}` }] };
+      const lnurlData = await lnurlRes.json();
+      const minSats = Math.ceil((lnurlData.minSendable || 1000) / 1000);
+      const maxSats = Math.floor((lnurlData.maxSendable || 100000000000) / 1000);
+      if (amount_sats < minSats || amount_sats > maxSats) {
+        return { content: [{ type: "text", text: `Error: Amount must be between ${minSats} and ${maxSats} sats for this address` }] };
+      }
+      let callbackUrl = `${lnurlData.callback}${lnurlData.callback.includes("?") ? "&" : "?"}amount=${amount_sats * 1000}`;
+      if (memo && lnurlData.commentAllowed) callbackUrl += `&comment=${encodeURIComponent(memo)}`;
+      const invoiceRes = await fetch(callbackUrl);
+      if (!invoiceRes.ok) return { content: [{ type: "text", text: `Error: Failed to get invoice from ${domain}` }] };
+      const invoiceData = await invoiceRes.json();
+      if (!invoiceData.pr) return { content: [{ type: "text", text: `Error: No invoice returned from ${domain}` }] };
+      const { status, data } = await apiCall("/api/v1/payments", {
+        method: "POST",
+        body: JSON.stringify({ invoice: invoiceData.pr, fee_limit_sats: Math.max(100, Math.floor(amount_sats * 0.01)) }),
+      });
+      if (status === 200 && data.success) {
+        return { content: [{ type: "text", text: JSON.stringify({ success: true, type: "lightning_address", recipient, amount_sats, fee_sats: data.fee_sats || 0, payment_hash: data.payment_hash, message: `Sent ${amount_sats} sats to ${recipient} ⚡` }) }] };
+      }
+      return { content: [{ type: "text", text: `Payment failed: ${data?.detail || data?.error || JSON.stringify(data)}` }] };
+
+    } else if (isStrikeHandle) {
+      const handle = recipient.slice(1); // strip "$"
+      if (!amount_usd && !amount_sats) return { content: [{ type: "text", text: "Error: amount_usd or amount_sats required for Strike payments" }] };
+      if (resolvedAgent && amount_sats) {
+        const policy = await checkSpendingPolicy(resolvedAgent.id, amount_sats);
+        if (!policy.allowed) return { content: [{ type: "text", text: `Payment blocked: ${policy.reason}` }] };
+      }
+      const body = { handle, description: memo || `Payment to $${handle}` };
+      if (amount_usd) body.amount_usd = amount_usd;
+      if (amount_sats) body.amount_sats = amount_sats;
+      if (resolvedAgent) body.agent_id = resolvedAgent.id;
+      const { status, data } = await apiCall("/api/v1/strike/pay", {
+        method: "POST",
+        body: JSON.stringify(body),
+      });
+      if (status === 200 && data.success) {
+        return { content: [{ type: "text", text: JSON.stringify({ success: true, type: "strike_handle", recipient, amount_usd: data.amount_usd, fee_usd: data.fee_usd || 0, payment_id: data.payment_id, message: `Sent to ${recipient} via Strike 💸` }) }] };
+      }
+      return { content: [{ type: "text", text: `Payment failed: ${data?.detail || data?.error || JSON.stringify(data)}` }] };
+
+    } else {
+      return { content: [{ type: "text", text: `Error: Unrecognized recipient format. Use a BOLT11 invoice (lnbc.../lntb...), Lightning address (user@domain.com), or Strike handle ($username).` }] };
+    }
+  }
+);
+
 // Tool: Decode Lightning invoice
 server.tool(
   "decode_invoice",