@haven_ai/mcp 0.1.7-alpha → 0.1.10-alpha.0

package/dist/cli.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
-import { composeDescription, toolDescriptions as toolDescriptions$1, HavenClient, HavenPaymentStateError, HavenSigningError, HavenApiError, AgentPaymentNextAction, HavenError } from '@haven_ai/sdk';
+import { composeDescription, toolDescriptions as toolDescriptions$1, HavenClient, HavenApiError, HavenPaymentStateError, HavenSigningError, AgentPaymentNextAction, HavenError } from '@haven_ai/sdk';
 import { readFile, mkdir, writeFile, stat } from 'fs/promises';
 import { z } from 'zod/v3';
 import { createHash } from 'crypto';
@@ -216,6 +216,18 @@ async function warnIfCredentialFilePermissive(path, log = (message) => process.s
 }
 var headersSchema = z.record(z.string(), z.string()).optional();
 var toolSchemas = {
+  haven_send: {
+    asset: z.enum(["ETH", "USDC"]),
+    recipient: z.string().min(1),
+    amount: z.string().min(1),
+    idempotencyKey: z.string().optional()
+  },
+  haven_pay_mcp_tool: {
+    merchant_url: z.string().url(),
+    tool_name: z.string().min(1),
+    arguments: z.record(z.string(), z.unknown()).optional(),
+    idempotencyKey: z.string().optional()
+  },
   haven_quote_x402: {
     url: z.string().url(),
     method: z.string().optional(),
@@ -262,11 +274,18 @@ var toolSchemas = {
   },
   haven_get_agent: {},
   haven_get_allowances: {},
+  haven_sweep_delegate: {},
+  haven_discover_tools: {
+    category: z.string().optional(),
+    rail: z.enum(["x402", "mpp"]).optional()
+  },
   haven_list_receipts: {
     limit: z.number().int().min(1).max(100).optional()
   }
 };
 var toolDescriptions = {
+  haven_send: composeDescription(toolDescriptions$1.send),
+  haven_pay_mcp_tool: composeDescription(toolDescriptions$1.payMcpTool),
   haven_quote_x402: composeDescription(toolDescriptions$1.quoteX402),
   haven_pay_x402_quote: composeDescription(toolDescriptions$1.payX402),
   haven_pay_x402: composeDescription(toolDescriptions$1.payX402OneShot),
@@ -278,16 +297,98 @@ var toolDescriptions = {
   haven_get_resume_state: composeDescription(toolDescriptions$1.getResumeState),
   haven_get_agent: composeDescription(toolDescriptions$1.getAgent),
   haven_get_allowances: composeDescription(toolDescriptions$1.getAllowances),
+  haven_sweep_delegate: composeDescription(toolDescriptions$1.sweep_delegate),
+  haven_discover_tools: composeDescription(toolDescriptions$1.discoverTools),
   haven_list_receipts: composeDescription(toolDescriptions$1.listReceipts)
 };
 function createToolHandlers(haven) {
   return {
+    haven_send: async (input) => {
+      return runTool(async () => {
+        const args = objectInput("haven_send", input);
+        try {
+          const result = await haven.pay({
+            token: args.asset,
+            amount: args.amount,
+            to: args.recipient
+          });
+          return {
+            payment_id: result.paymentId,
+            status: result.status,
+            tx_hash: result.txHash ?? null,
+            asset: args.asset,
+            amount: args.amount,
+            recipient: args.recipient
+          };
+        } catch (err) {
+          if (err instanceof HavenPaymentStateError && isPendingApproval(err.status)) {
+            return {
+              payment_id: err.paymentId,
+              status: "pending_approval",
+              asset: args.asset,
+              amount: args.amount,
+              recipient: args.recipient
+            };
+          }
+          throw err;
+        }
+      });
+    },
+    haven_pay_mcp_tool: async (input) => {
+      return runTool(async () => {
+        const args = objectInput("haven_pay_mcp_tool", input);
+        const envelope = buildMcpToolsCallEnvelope(args.tool_name, args.arguments);
+        const response = await haven.fetch(
+          args.merchant_url,
+          {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify(envelope)
+          },
+          { idempotencyKey: args.idempotencyKey }
+        );
+        return responsePayload(response);
+      });
+    },
     haven_quote_x402: async (input) => {
       const args = objectInput("haven_quote_x402", input);
-      return runTool(async () => haven.quoteX402(args.url, requestInit(args), { idempotencyKey: args.idempotencyKey }));
+      try {
+        return { success: true, data: await haven.quoteX402(args.url, requestInit(args), { idempotencyKey: args.idempotencyKey }) };
+      } catch (err) {
+        if (err instanceof HavenApiError && err.message.includes("quoteX402 only supports standard x402")) {
+          return wrongTool(
+            "WRONG_RAIL",
+            "The URL responds with an MPP machine-payment challenge, not an x402 payment. Use haven_quote_mpp to inspect this merchant.",
+            "haven_quote_mpp"
+          );
+        }
+        return normalizeError(err);
+      }
     },
     haven_pay_x402_quote: async (input) => {
       const args = objectInput("haven_pay_x402_quote", input);
+      const quote = args.quote;
+      if (!quote || typeof quote !== "object") {
+        return wrongTool(
+          "WRONG_TOOL",
+          "The quote argument is missing or is not a valid x402 quote object. Call haven_quote_x402 first to obtain a quote, or use haven_pay_x402 to handle the full probe \u2192 pay \u2192 retry round trip automatically.",
+          "haven_quote_x402"
+        );
+      }
+      if (!quote.paymentRequired && quote.rail === "mpp") {
+        return wrongTool(
+          "WRONG_TOOL",
+          "The quote is for the MPP rail. Use haven_pay_mpp_challenge to pay an MPP quote.",
+          "haven_pay_mpp_challenge"
+        );
+      }
+      if (!quote.paymentRequired) {
+        return wrongTool(
+          "WRONG_TOOL",
+          "The quote is missing the required paymentRequired field. Call haven_quote_x402 first to obtain a valid x402 quote.",
+          "haven_quote_x402"
+        );
+      }
       return runTool(async () => {
         const response = await haven.payX402Quote(args.quote, { idempotencyKey: args.idempotencyKey });
         return responsePayload(response);
@@ -302,6 +403,16 @@ function createToolHandlers(haven) {
     },
     haven_resume_x402_payment: async (input) => {
       const args = objectInput("haven_resume_x402_payment", input);
+      if (args.resume_state && typeof args.resume_state === "object") {
+        const stateRail = args.resume_state.rail;
+        if (stateRail && stateRail !== "x402") {
+          return wrongTool(
+            "WRONG_TOOL",
+            `The resume state is for the '${stateRail}' rail, not x402. Use haven_resume_mpp_payment instead.`,
+            "haven_resume_mpp_payment"
+          );
+        }
+      }
       return runTool(async () => {
         const state = await resumeState(args, "x402");
         const response = await haven.resumeX402Payment(state);
@@ -310,20 +421,54 @@ function createToolHandlers(haven) {
     },
     haven_quote_mpp: async (input) => {
       const args = objectInput("haven_quote_mpp", input);
-      return runTool(async () => {
+      try {
         if (args.challenge) {
-          return haven.quoteMpp(args.challenge, requestInit(args), {
-            idempotencyKey: args.idempotencyKey
-          });
+          return {
+            success: true,
+            data: await haven.quoteMpp(args.challenge, requestInit(args), {
+              idempotencyKey: args.idempotencyKey
+            })
+          };
         }
         if (!args.url) {
-          throw new HavenApiError("haven_quote_mpp requires either url or challenge.", 400);
+          return normalizeError(new HavenApiError("haven_quote_mpp requires either url or challenge.", 400));
         }
-        return haven.quoteMpp(args.url, requestInit(args), { idempotencyKey: args.idempotencyKey });
-      });
+        return { success: true, data: await haven.quoteMpp(args.url, requestInit(args), { idempotencyKey: args.idempotencyKey }) };
+      } catch (err) {
+        if (err instanceof Error && err.message.includes("No MACHINE-PAYMENT-CHALLENGE header found")) {
+          return wrongTool(
+            "WRONG_RAIL",
+            "The URL responds with an x402 payment requirement, not an MPP machine-payment challenge. Use haven_quote_x402 to inspect this merchant.",
+            "haven_quote_x402"
+          );
+        }
+        return normalizeError(err);
+      }
     },
     haven_pay_mpp_challenge: async (input) => {
       const args = objectInput("haven_pay_mpp_challenge", input);
+      const quote = args.quote;
+      if (!quote || typeof quote !== "object") {
+        return wrongTool(
+          "WRONG_TOOL",
+          "The quote argument is missing or is not a valid MPP quote object. Call haven_quote_mpp first to obtain a quote.",
+          "haven_quote_mpp"
+        );
+      }
+      if (quote.paymentRequired || quote.rail === "x402") {
+        return wrongTool(
+          "WRONG_TOOL",
+          "The quote is for the x402 rail. Use haven_pay_x402_quote to pay an x402 quote.",
+          "haven_pay_x402_quote"
+        );
+      }
+      if (!quote.challenge) {
+        return wrongTool(
+          "WRONG_TOOL",
+          "The quote is missing the required challenge field. Call haven_quote_mpp first to obtain a valid MPP quote.",
+          "haven_quote_mpp"
+        );
+      }
       return runTool(async () => {
         const response = await haven.payMppChallenge(args.quote, { idempotencyKey: args.idempotencyKey });
         return responsePayload(response);
@@ -331,6 +476,16 @@ function createToolHandlers(haven) {
     },
     haven_resume_mpp_payment: async (input) => {
       const args = objectInput("haven_resume_mpp_payment", input);
+      if (args.resume_state && typeof args.resume_state === "object") {
+        const stateRail = args.resume_state.rail;
+        if (stateRail && stateRail !== "mpp") {
+          return wrongTool(
+            "WRONG_TOOL",
+            `The resume state is for the '${stateRail}' rail, not mpp. Use haven_resume_x402_payment instead.`,
+            "haven_resume_x402_payment"
+          );
+        }
+      }
       return runTool(async () => {
         const state = await resumeState(args, "mpp");
         const response = await haven.resumeMppPayment(state);
@@ -347,6 +502,34 @@ function createToolHandlers(haven) {
     },
     haven_get_agent: async () => runTool(async () => haven.getAgent()),
     haven_get_allowances: async () => runTool(async () => haven.getAllowances()),
+    haven_sweep_delegate: async () => runTool(async () => haven.sweepDelegate()),
+    haven_discover_tools: async (input) => {
+      const args = objectInput("haven_discover_tools", input);
+      return runTool(async () => {
+        const entries = await haven.discoverTools({
+          category: typeof args.category === "string" ? args.category : void 0,
+          rail: args.rail === "x402" || args.rail === "mpp" ? args.rail : void 0
+        });
+        return entries.map((entry) => ({
+          id: entry.id,
+          name: entry.name,
+          description: entry.description,
+          category: entry.category,
+          resource_url: entry.resourceUrl,
+          rail: entry.rail,
+          protocol: entry.protocol,
+          tool_name: entry.toolName,
+          price_display: entry.priceDisplay,
+          price_atomic: entry.priceAtomic,
+          asset: entry.asset,
+          network: entry.network,
+          status: entry.status,
+          verified_at: entry.verifiedAt,
+          // Which Haven pay tool reaches this entry from the local MCP surface.
+          suggested_tool: entry.protocol === "mcp" ? "haven_pay_mcp_tool" : entry.rail === "x402" ? "haven_pay_x402" : "haven_quote_mpp"
+        }));
+      });
+    },
     haven_list_receipts: async (input) => {
       const args = objectInput("haven_list_receipts", input);
       return runTool(async () => haven.listReceipts({ limit: args.limit }));
@@ -363,6 +546,23 @@ function createToolHandlers(haven) {
     return state;
   }
 }
+function isPendingApproval(status) {
+  return status === "pending" || status === "pending_approval";
+}
+function wrongTool(code, message, suggested_tool) {
+  return { success: false, code, message, suggested_tool };
+}
+function buildMcpToolsCallEnvelope(toolName, args) {
+  return {
+    jsonrpc: "2.0",
+    id: `haven-mcp-${Date.now()}`,
+    method: "tools/call",
+    params: {
+      name: toolName,
+      arguments: args ?? {}
+    }
+  };
+}
 function objectInput(name, input) {
   return z.object(toolSchemas[name]).parse(input ?? {});
 }
@@ -638,7 +838,7 @@ async function resolveHavenClient(options = {}) {
   return { client, credentials };
 }
 var MCP_NAME = "@haven_ai/mcp";
-var MCP_VERSION = "0.1.7-alpha";
+var MCP_VERSION = "0.1.10-alpha.0";
 function buildMcpServer(haven) {
   const server = new McpServer({
     name: MCP_NAME,