@haven_ai/mcp 0.10.0-alpha.0 → 0.11.0-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, havenClientIdentity, isSupportedNodeVersion, unsupportedNodeVersionMessage, resolveTokenBySymbol, formatTokenAmount, HavenApiError, HavenPaymentStateError, HavenSigningError, AgentPaymentNextAction, HavenError, AgentPaymentFailureCode, verifyPaymentReceipt, catalogFundingLegExpected, discoverMerchantMcpUrl, sameUrl, resolveTokenFromAddress, TASK_SIGN_CONTEXT_VERSION, connectorUpgradeCommand } from '@haven_ai/sdk';
+import { composeDescription, toolDescriptions as toolDescriptions$1, HavenClient, havenClientIdentity, isSupportedNodeVersion, unsupportedNodeVersionMessage, x402AuthorizationAmount, AgentPaymentNextAction, resolveTokenBySymbol, formatTokenAmount, HavenApiError, selectErc7710PaymentOption, selectStandardPaymentOption, HavenPaymentStateError, HavenSigningError, MerchantEgressRefusedError, HavenError, AgentPaymentFailureCode, verifyPaymentReceipt, catalogFundingLegExpected, discoverMerchantMcpUrl, sameUrl, resolveTokenFromAddress, TASK_SIGN_CONTEXT_VERSION, connectorUpgradeCommand } from '@haven_ai/sdk';
 import { readFile, mkdir, writeFile, stat } from 'fs/promises';
 import { z } from 'zod/v3';
 import { createHash } from 'crypto';
@@ -236,6 +236,18 @@ async function warnIfCredentialFilePermissive(path, log = (message) => process.s
     );
   }
 }
+function chainRpcsFromEnv(env) {
+  const chainRpcs = {};
+  for (const [name, value] of Object.entries(env)) {
+    const match = /^HAVEN_RPC_URL_(\d+)$/.exec(name);
+    if (!match) continue;
+    const chainId = Number.parseInt(match[1], 10);
+    if (!Number.isSafeInteger(chainId) || chainId <= 0) continue;
+    const url = value?.trim();
+    if (url) chainRpcs[chainId] = url;
+  }
+  return chainRpcs;
+}
 var TASK_BUDGET_MIN_SIGNER_VERSION = "0.6.0-alpha.0";
 var SIGNER_CAPABILITY_KEY = "haven/signer-compatibility";
 function taskSignerCompatibilityNotice() {
@@ -248,6 +260,20 @@ function taskSignerCompatibilityNotice() {
   };
 }
 var headersSchema = z.record(z.string(), z.string()).optional();
+function selectQuoteOption(accepts, agent) {
+  if (agent.executionRail === "delegation") {
+    const erc7710 = selectErc7710PaymentOption(accepts);
+    if (erc7710) return erc7710;
+  }
+  return selectStandardPaymentOption(accepts);
+}
+function humanDecimalToAtomic(human, decimals) {
+  const match = /^([0-9]+)(?:\.([0-9]+))?$/.exec(human);
+  if (!match) return null;
+  const fraction = match[2] ?? "";
+  if (fraction.length > decimals) return null;
+  return BigInt(match[1] + fraction.padEnd(decimals, "0"));
+}
 var toolSchemas = {
   haven_send: {
     asset: z.enum(["ETH", "USDC"]),
@@ -279,6 +305,17 @@ var toolSchemas = {
     headers: headersSchema,
     body: z.string().optional(),
     idempotency_key: z.string().optional(),
+    /**
+     * #3967: the price the agent EXPECTS, in whole tokens ("0.10" = 0.1 USDC),
+     * compared against the amount of the option pay will actually select. A
+     * mismatch stops the agent — the same stop signals the hosted quote
+     * carries. Local parity: a hosted-only input would split the two tools'
+     * contracts. Same shape and name as the hosted surface's.
+     */
+    expected_amount: z.string().regex(
+      /^[0-9]+(\.[0-9]+)?$/,
+      'expected_amount must be a plain decimal amount in whole tokens, e.g. "0.10"'
+    ).optional(),
     /** REMOVED (#3411): declared only so the resolver can refuse it by name, never accepted. */
     idempotencyKey: z.string().optional().describe("REMOVED (#3411): refused \u2014 send idempotency_key")
   },
@@ -625,8 +662,39 @@ function createToolHandlers(haven) {
       const pf = preflight("haven_quote_x402", input);
       if ("success" in pf) return pf;
       const { args, warnings } = pf;
+      const agentPromise = args.expected_amount !== void 0 ? haven.getAgent().then(
+        (a) => a,
+        () => void 0
+      ) : null;
       try {
         const data = await haven.quoteX402(args.url, requestInit(args), { idempotencyKey: args.resolvedIdempotencyKey });
+        if (args.expected_amount !== void 0) {
+          const agent = agentPromise ? await agentPromise : void 0;
+          const option = agent ? selectQuoteOption(data.paymentRequired.accepts, agent) : null;
+          if (option && data.decimals !== null) {
+            const expectedAtomic = humanDecimalToAtomic(args.expected_amount, data.decimals);
+            let optionAmount = null;
+            try {
+              optionAmount = BigInt(x402AuthorizationAmount(option));
+            } catch {
+              optionAmount = null;
+            }
+            if (optionAmount !== null && expectedAtomic !== null) {
+              const priceDiffers = optionAmount !== expectedAtomic;
+              const payload = {
+                ...data,
+                price_differs_from_expected: priceDiffers,
+                ...priceDiffers ? {
+                  safe_to_continue: false,
+                  next_action: AgentPaymentNextAction.StopAndTellUser,
+                  next_tool_omitted_reason: "no Haven tool follows: the quoted price does not match the stated expectation \u2014 the user decides before any payment",
+                  reason: `The merchant's quoted price (${data.amount} ${data.asset}) does not match the expected price (${args.expected_amount}) stated with this quote. Stop and tell the user before any payment; do not re-quote, re-pay, or poll. If the x402 challenge itself is wrong and nothing has been paid via x402 on this invoice, the invoice's own deposit address MAY be an alternative \u2014 but only with the user's explicit go-ahead, never automatically, and never once anything has been paid via x402.`
+                } : {}
+              };
+              return warnings.length > 0 ? { success: true, data: payload, warnings } : { success: true, data: payload };
+            }
+          }
+        }
         return warnings.length > 0 ? { success: true, data, warnings } : { success: true, data };
       } catch (err) {
         return normalizeError(err);
@@ -1082,6 +1150,24 @@ function normalizeError(err) {
       message: err.message
     };
   }
+  if (err instanceof MerchantEgressRefusedError && !err.beforeRequest && err.paymentId) {
+    const noFundingLeg = err.settlementScheme === "erc7710";
+    const nextAction = noFundingLeg ? AgentPaymentNextAction.CheckStatusLater : AgentPaymentNextAction.SweepStrandedFunds;
+    return {
+      success: false,
+      code: err.code,
+      message: err.message,
+      statusCode: err.statusCode,
+      paymentId: err.paymentId,
+      status: "merchant_unresponsive_after_funding",
+      phase: noFundingLeg ? "not_delivered" : "funded_but_unsettled",
+      nextAction,
+      next_action: nextAction,
+      next_tool: "haven_get_payment_status",
+      next_arguments: { payment_id: err.paymentId },
+      suggested_tool: "haven_get_payment_status"
+    };
+  }
   if (err instanceof HavenApiError) {
     const body = err.body;
     return {
@@ -1324,10 +1410,14 @@ async function resolveHavenClient(options = {}) {
     signerPath: options.signerPath
   } : void 0;
   const credentials = options.credentials ?? await loadCredentials(credentialSource);
+  const chainRpcs = chainRpcsFromEnv(process.env);
   const client = new HavenClient({
     apiKey: credentials.apiKey,
     delegateKey: credentials.delegateKey,
     baseUrl: credentials.apiUrl,
+    // Only added when non-empty so the unset-variable construction is byte-for-byte
+    // today's: the SDK defaults `chainRpcs` to `{}` either way.
+    ...Object.keys(chainRpcs).length > 0 ? { chainRpcs } : {},
     // #3303: name this package, not the SDK inside it, so the backend's
     // update hint and refusal speak about what the user actually installed.
     clientIdentity: havenClientIdentity(MCP_NAME, MCP_VERSION)
@@ -1335,7 +1425,7 @@ async function resolveHavenClient(options = {}) {
   return { client, credentials };
 }
 var MCP_NAME = "@haven_ai/mcp";
-var MCP_VERSION = "0.10.0-alpha.0";
+var MCP_VERSION = "0.11.0-alpha.0";
 var MCP_INSTRUCTIONS = [
   "Haven local MCP server: signs in-process with the delegate key it holds on",
   "this machine \u2014 the key never leaves this process. Call haven_get_agent",