@haven_ai/mcp 0.1.37-alpha.0 → 0.2.1-alpha.0

package/README.md

@@ -36,12 +36,17 @@ Create a private JSON file from the values in the Haven agent handoff:
   "api_key": "sk_agent_...",
   "delegate_key": "0x...",
   "agent_id": "agent-id",
-  "safe_address": "0xYourHavenWallet",
+  "account_address": "0xYourHavenWallet",
   "api_url": "https://havenbackend.example"
 }
 ```
 
 `delegate_key` is required. Without it the MCP server cannot sign locally.
+`account_address` is the name the connector writes since #2908; a file that
+still says `safe_address` (or `safeAddress`) is read the same way, permanently.
+The same holds for the environment: `HAVEN_ACCOUNT_ADDRESS` is read first, and
+the older `HAVEN_WALLET_ADDRESS` / `HAVEN_SAFE_ADDRESS` are accepted for one
+release (#2914 removes them).
 
 The Haven connector may also write split credentials:
 

package/dist/cli.cjs

@@ -50,11 +50,13 @@ async function loadCredentialsFromFile(path) {
   if (!delegateKey) {
     throw new Error("Haven MCP requires delegate_key so payments can be signed locally.");
   }
+  const accountAddress = readAccountAddressField(raw);
   return {
     apiKey,
     delegateKey,
     agentId: stringField(raw.agent_id ?? raw.agentId),
-    safeAddress: stringField(raw.safe_address ?? raw.safeAddress),
+    accountAddress,
+    safeAddress: accountAddress,
     delegateAddress: stringField(raw.delegate_address ?? raw.delegateAddress),
     chainId: numberField(raw.chain_id ?? raw.chainId),
     network: stringField(raw.network),
@@ -84,11 +86,13 @@ async function loadCredentialsFromSplitFiles(identityPath, signerPath) {
       identity.agent_id ?? identity.agentId,
       signer.agent_id ?? signer.agentId
     ),
-    safeAddress: matchingStringField(
-      "safe_address",
-      identity.safe_address ?? identity.safeAddress,
-      signer.safe_address ?? signer.safeAddress,
-      { caseInsensitive: true }
+    ...accountAddressTwins(
+      matchingStringField(
+        "account_address",
+        readAccountAddressField(identity),
+        readAccountAddressField(signer),
+        { caseInsensitive: true }
+      )
     ),
     delegateAddress: matchingStringField(
       "delegate_address",
@@ -143,12 +147,21 @@ function loadCredentialsFromEnv() {
     apiKey,
     delegateKey,
     agentId: stringField(process.env.HAVEN_AGENT_ID),
-    safeAddress: stringField(process.env.HAVEN_SAFE_ADDRESS),
+    ...accountAddressTwins(readAccountAddressEnv(process.env)),
     chainId: numberField(process.env.HAVEN_CHAIN_ID),
     network: stringField(process.env.HAVEN_NETWORK),
     apiUrl: stringField(process.env.HAVEN_API_URL)
   };
 }
+function readAccountAddressField(raw) {
+  return stringField(raw.account_address ?? raw.safe_address ?? raw.safeAddress);
+}
+function readAccountAddressEnv(env) {
+  return stringField(env.HAVEN_ACCOUNT_ADDRESS ?? env.HAVEN_WALLET_ADDRESS ?? env.HAVEN_SAFE_ADDRESS);
+}
+function accountAddressTwins(address) {
+  return { accountAddress: address, safeAddress: address };
+}
 function stringField(value) {
   return typeof value === "string" && value.trim() ? value.trim() : void 0;
 }
@@ -361,6 +374,8 @@ function createToolHandlers(haven) {
         const attempt = () => haven.fetch(merchantUrl, init, { idempotencyKey });
         let response = await attempt();
         if (!response.ok) {
+          const notReady = await merchantNotReadyErrorFor(response);
+          if (notReady) throw notReady;
           const discovered = await sdk.discoverMerchantMcpUrl(merchantUrl);
           if (!discovered || sdk.sameUrl(discovered, merchantUrl)) {
             throw discoveryMissError(response, merchantUrl, discovered);
@@ -369,6 +384,8 @@ function createToolHandlers(haven) {
           merchantUrl = discovered;
           const retryResponse = await attempt();
           if (!retryResponse.ok) {
+            const notReadyAtDiscovered = await merchantNotReadyErrorFor(retryResponse);
+            if (notReadyAtDiscovered) throw notReadyAtDiscovered;
             throw discoveryMissError(retryResponse, merchantUrl, discovered, inputUrl);
           }
           response = retryResponse;
@@ -602,12 +619,50 @@ function parseMaybeJson(text) {
     return text;
   }
 }
+var MerchantNotReadyError = class extends Error {
+  code = sdk.AgentPaymentFailureCode.MerchantNotReady;
+  statusCode = 503;
+  nextAction = sdk.AgentPaymentNextAction.StopAndTellUser;
+  // Genuinely retryable — unlike a rejection, nothing about THIS call was
+  // wrong; the merchant's own wallet needs to recover first.
+  retryWithNewQuote = true;
+  constructor(message) {
+    super(message);
+    this.name = "MerchantNotReadyError";
+  }
+};
+async function merchantNotReadyErrorFor(response) {
+  if (response.status !== 503) return null;
+  let body;
+  try {
+    body = await response.clone().json();
+  } catch {
+    return null;
+  }
+  if (!body || typeof body !== "object" || body.error !== "merchant_not_ready") {
+    return null;
+  }
+  const { reason_code, settlements_remaining, retry_after_s } = body;
+  return new MerchantNotReadyError(
+    "The merchant refused this call: it cannot settle a payment right now" + (typeof reason_code === "string" ? ` (reason_code: ${reason_code})` : "") + (typeof settlements_remaining === "number" ? `, settlements_remaining: ${settlements_remaining}` : "") + ". No payment was created." + (typeof retry_after_s === "number" ? ` Retry after approximately ${retry_after_s}s.` : " This is often transient; retry later.")
+  );
+}
 function discoveryMissError(response, merchantUrl, discovered, discoveredFromUrl) {
   const base = discoveredFromUrl ? `Merchant call to ${merchantUrl} failed with HTTP ${response.status} (at the DISCOVERED endpoint ${merchantUrl}, resolved from ${discoveredFromUrl} via the merchant discovery document).` : `Merchant call to ${merchantUrl} failed with HTTP ${response.status}.`;
   const guidance = discoveredFromUrl ? "" : discovered ? ` Same-origin discovery resolved the same URL (${discovered}), which still did not answer successfully.` : ` No same-origin discovery document was found at /.well-known/haven-demo-merchant or /. If ${merchantUrl} is a base merchant URL, pass the exact MCP endpoint instead (often <origin>/mcp).`;
   return new sdk.HavenApiError(`${base}${guidance}`, response.status || 400);
 }
 function normalizeError(err) {
+  if (err instanceof MerchantNotReadyError) {
+    return {
+      success: false,
+      code: err.code,
+      message: err.message,
+      statusCode: err.statusCode,
+      nextAction: err.nextAction,
+      retry_with_new_quote: err.retryWithNewQuote
+    };
+  }
   if (err instanceof sdk.HavenPaymentStateError) {
     return {
       success: false,
@@ -801,7 +856,7 @@ async function consentInputFromClient(haven, seed, toolNames) {
     const summary = await haven.getAllowances();
     const list = isAllowanceSummary(summary) ? summary.allowances : Array.isArray(summary) ? summary : [];
     if (isAllowanceSummary(summary)) {
-      safeAddress = summary.safeAddress ?? safeAddress;
+      safeAddress = summary.accountAddress ?? summary.safeAddress ?? safeAddress;
       delegateAddress = summary.delegateAddress;
       chainId = typeof summary.chainId === "number" ? summary.chainId : chainId;
     }
@@ -851,7 +906,7 @@ async function resolveHavenClient(options = {}) {
   return { client, credentials };
 }
 var MCP_NAME = "@haven_ai/mcp";
-var MCP_VERSION = "0.1.37-alpha.0";
+var MCP_VERSION = "0.2.1-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",
@@ -924,7 +979,7 @@ async function runConsentGate(haven, credentials, options) {
       apiKey: credentials.apiKey,
       apiUrl: credentials.apiUrl,
       agentId: credentials.agentId,
-      safeAddress: credentials.safeAddress,
+      safeAddress: credentials.accountAddress ?? credentials.safeAddress,
       delegateAddress: credentials.delegateAddress,
       chainId: credentials.chainId,
       allowanceSummary: credentials.allowanceSummary