@haven_ai/sdk 0.1.23-alpha.0 → 0.1.23-alpha.2

package/dist/index.js

@@ -701,73 +701,6 @@ function stableStringify(value) {
   const object = value;
   return `{${Object.keys(object).sort().map((key) => `${JSON.stringify(key)}:${stableStringify(object[key])}`).join(",")}}`;
 }
-function normalizeChallenge(value) {
-  const candidate = value;
-  if (!candidate || typeof candidate !== "object" || candidate.rail !== "mpp_demo" || typeof candidate.version !== "string" || typeof candidate.challengeId !== "string" || typeof candidate.resource !== "string" || typeof candidate.description !== "string" || // TODO: relax these checks when non-demo machine payment rails are added.
-  candidate.network?.chainId !== 8453 || candidate.network?.name !== "base" || candidate.asset?.symbol !== "USDC" || typeof candidate.asset?.address !== "string" || candidate.asset.decimals !== 6 || typeof candidate.amount?.display !== "string" || typeof candidate.amount?.atomic !== "string" || typeof candidate.recipient !== "string" || typeof candidate.expiresAt !== "string") {
-    return null;
-  }
-  return {
-    rail: candidate.rail,
-    version: candidate.version,
-    challengeId: candidate.challengeId,
-    resource: candidate.resource,
-    description: candidate.description,
-    network: candidate.network,
-    asset: candidate.asset,
-    amount: candidate.amount,
-    recipient: candidate.recipient,
-    expiresAt: candidate.expiresAt,
-    metadata: candidate.metadata
-  };
-}
-function parseMachinePaymentChallenge(response) {
-  const header = response.headers.get("MACHINE-PAYMENT-CHALLENGE");
-  if (!header) {
-    throw new Error("No MACHINE-PAYMENT-CHALLENGE header found in 402 response.");
-  }
-  const parsed = normalizeChallenge(
-    decodeBase64Json(header, "MACHINE-PAYMENT-CHALLENGE header")
-  );
-  if (!parsed) throw new Error("Invalid machine payment challenge");
-  return parsed;
-}
-async function parseMachinePaymentChallengeResponse(response) {
-  try {
-    return parseMachinePaymentChallenge(response);
-  } catch (headerErr) {
-    try {
-      const body = await response.clone().json();
-      const parsed = normalizeChallenge(body.challenge);
-      if (parsed) return parsed;
-    } catch {
-    }
-    throw headerErr;
-  }
-}
-function buildMachinePaymentIdempotencyKey(challenge) {
-  const material = [
-    challenge.rail,
-    challenge.challengeId,
-    challenge.resource,
-    challenge.recipient.toLowerCase(),
-    challenge.asset.address.toLowerCase(),
-    challenge.amount.atomic,
-    challenge.network.chainId
-  ].join("|");
-  return `${challenge.rail}:${createHash("sha256").update(material).digest("hex").slice(0, 16)}`;
-}
-function encodeMachinePaymentProof(receipt) {
-  return encodeBase64Json({
-    rail: receipt.rail,
-    challengeId: receipt.challengeId,
-    paymentId: receipt.paymentId,
-    txHash: receipt.txHash,
-    settledVia: "haven",
-    payer: receipt.payer,
-    chainId: receipt.chainId
-  });
-}
 function createJsonRpcProvider(url) {
   return new ethers.JsonRpcProvider(url);
 }
@@ -888,9 +821,6 @@ function messageForState(label, status, paymentId, nextAction) {
 function sameAddress(a, b) {
   return Boolean(a && b && a.toLowerCase() === b.toLowerCase());
 }
-function isMppRail(rail) {
-  return rail === "mpp" || Boolean(rail?.startsWith("mpp_"));
-}
 function decimalFromUsdcAtomic(value) {
   const amount = BigInt(value);
   const whole = amount / 1000000n;
@@ -992,7 +922,6 @@ var HavenClient = class {
   chainRpcs;
   inFlightX402 = /* @__PURE__ */ new Map();
   x402ReceiptCache = /* @__PURE__ */ new Map();
-  inFlightMachinePayments = /* @__PURE__ */ new Map();
   /**
    * Setup-time headers configured via `HavenClientConfig.defaultHeaders`.
    * Read-only after construction — use `withRequestContext` for per-call
@@ -1606,10 +1535,11 @@ var HavenClient = class {
     return { receipt, verification: verifyPaymentReceipt(receipt) };
   }
   /**
-   * Rehydrate the x402/MPP resume-state bundle for a payment id.
+   * Rehydrate the x402 resume-state bundle for a payment id (#1328: the MPP
+   * resume-state variant retired along with the rest of the mpp_demo surface).
    *
    * The server returns stored protocol context only. The client still signs the
-   * merchant proof locally when resumeX402Payment() or resumeMppPayment() runs.
+   * merchant proof locally when resumeX402Payment() runs.
    */
   async getResumeState(paymentId) {
     return this.get(`/payments/${paymentId}/resume_state`);
@@ -1880,22 +1810,11 @@ var HavenClient = class {
     if (response.status !== 402) {
       return mcpSessionId ? this.surfaceMcpResult(response) : response;
     }
-    const machineChallengeHeader = response.headers.get("MACHINE-PAYMENT-CHALLENGE");
-    if (machineChallengeHeader) {
-      const challenge = await parseMachinePaymentChallengeResponse(response);
-      return this.fetchWithMachinePayment(url, requestInit, challenge);
-    }
     let paymentRequired;
     try {
       paymentRequired = await parsePaymentRequiredResponse(response);
     } catch {
-      let challenge;
-      try {
-        challenge = await parseMachinePaymentChallengeResponse(response);
-      } catch {
-        return response;
-      }
-      return this.fetchWithMachinePayment(url, requestInit, challenge);
+      return response;
     }
     if (!mcpSessionId && await responseHasBazaarExtension(response)) {
       mcpSessionId = await this.mcpInitialize(url, init);
@@ -2038,49 +1957,6 @@ var HavenClient = class {
       headers
     });
   }
-  /**
-   * Probe a paid MPP endpoint or inspect an existing challenge without creating
-   * a Haven payment or approval request.
-   */
-  async quoteMpp(challengeOrUrl, init, options = {}) {
-    if (typeof challengeOrUrl !== "string") {
-      const request2 = this.snapshotX402Request(challengeOrUrl.resource, init);
-      return this.buildMppQuote(challengeOrUrl, request2, options.idempotencyKey);
-    }
-    const request = this.snapshotX402Request(challengeOrUrl, init);
-    const response = await this.merchantFetch(challengeOrUrl, init);
-    if (response.status !== 402) {
-      throw new HavenApiError(
-        `Expected an MPP quote response with HTTP 402, got HTTP ${response.status}.`,
-        response.status || 400
-      );
-    }
-    const challenge = await parseMachinePaymentChallengeResponse(response);
-    return this.buildMppQuote(challenge, request, options.idempotencyKey);
-  }
-  /**
-   * Pay a previously inspected MPP quote and retry the exact captured request.
-   */
-  async payMppChallenge(quote, options = {}) {
-    const idempotencyKey = options.idempotencyKey ?? quote.idempotencyKey;
-    try {
-      const receipt = await this.authorizeMachinePayment(quote.challenge, { idempotencyKey });
-      return this.retryMppRequest(
-        quote.request.url,
-        this.requestInitFromSnapshot(quote.request),
-        quote.challenge,
-        receipt
-      );
-    } catch (err) {
-      this.attachResumeState(err, {
-        rail: "mpp",
-        challenge: quote.challenge,
-        idempotencyKey,
-        request: quote.request
-      });
-      throw err;
-    }
-  }
   async retryX402Request(url, initialInit, paymentRequired, receipt) {
     if (!receipt.accepted) {
       throw new HavenApiError("No accepted x402 option was recorded for payment retry", 500);
@@ -2345,151 +2221,13 @@ var HavenClient = class {
       return void 0;
     }
   }
-  async authorizeMachinePayment(challenge, options = {}) {
-    if (!this.delegateKey) {
-      throw new HavenSigningError(
-        "delegateKey is required for machine payments. Pass it in the HavenClient config."
-      );
-    }
-    if (challenge.rail !== "mpp_demo") {
-      throw new HavenApiError(`Unsupported machine payment rail: ${challenge.rail}`, 400);
-    }
-    const idempotencyKey = options.idempotencyKey ?? buildMachinePaymentIdempotencyKey(challenge);
-    const inFlight = this.inFlightMachinePayments.get(idempotencyKey);
-    if (inFlight) return inFlight;
-    const promise = this.authorizeMppDemoPayment(challenge, idempotencyKey);
-    this.inFlightMachinePayments.set(idempotencyKey, promise);
-    try {
-      return await promise;
-    } catch (err) {
-      this.attachResumeState(err, {
-        rail: "mpp",
-        challenge,
-        idempotencyKey
-      });
-      throw err;
-    } finally {
-      this.inFlightMachinePayments.delete(idempotencyKey);
-    }
-  }
-  async authorizeMppDemoPayment(challenge, idempotencyKey) {
-    const raw = await this.post(
-      "/machine-payments/authorize",
-      { challenge, idempotencyKey }
-    );
-    if (raw.success && raw.tx_hash) {
-      return this.mapMachinePaymentReceipt(challenge, raw, raw.tx_hash);
-    }
-    this.throwIfNonSignableAuthorizationState("Machine payment", raw);
-    if (!raw.sign_data?.hash) {
-      throw new HavenApiError("No sign_hash returned from machine payment authorization", 500, raw);
-    }
-    const sig = await this.signForData(raw.sign_data);
-    const execResult = await this.post(
-      `/payments/${raw.payment_id}/sign`,
-      { signature: sig }
-    );
-    if (execResult.status !== "confirmed" || !execResult.tx_hash) {
-      this.throwPaymentStateError("Machine payment", execResult);
-    }
-    return this.mapMachinePaymentReceipt(challenge, raw, execResult.tx_hash, execResult);
-  }
-  async resumeAuthorizedMpp(input) {
-    if (!this.delegateKey) {
-      throw new HavenSigningError(
-        "delegateKey is required for machine payments. Pass it in the HavenClient config."
-      );
-    }
-    const status = await this.getPaymentStatus(input.paymentId);
-    this.assertCanResumeMpp(status, input.challenge);
-    return this.mapMachinePaymentReceiptFromStatus(input.challenge, status);
-  }
-  async resumeMppPayment(input) {
-    const inputInit = "init" in input ? input.init : void 0;
-    const initialInit = inputInit ?? (input.request ? this.requestInitFromSnapshot(input.request) : void 0);
-    let challenge = input.challenge;
-    const url = input.url ?? input.request?.url;
-    if (!challenge) {
-      if (!url) {
-        throw new HavenApiError("MPP resume requires the original URL or a captured request snapshot.", 400);
-      }
-      const response = await this.merchantFetch(url, initialInit);
-      if (response.status !== 402) {
-        throw new HavenApiError("Expected the original MPP request to return HTTP 402 before resuming.", 400);
-      }
-      challenge = await parseMachinePaymentChallengeResponse(response);
-    }
-    const receipt = await this.resumeAuthorizedMpp({
-      paymentId: input.paymentId,
-      challenge,
-      idempotencyKey: input.idempotencyKey
-    });
-    return this.retryMppRequest(url ?? challenge.resource, initialInit, challenge, receipt);
-  }
-  async fetchWithMachinePayment(url, initialInit, challenge) {
-    const request = this.snapshotX402Request(url, initialInit);
-    const idempotencyKey = buildMachinePaymentIdempotencyKey(challenge);
-    let receipt;
-    try {
-      receipt = await this.authorizeMachinePayment(challenge, { idempotencyKey });
-    } catch (err) {
-      this.attachResumeState(err, {
-        rail: "mpp",
-        challenge,
-        idempotencyKey,
-        request
-      });
-      throw err;
-    }
-    return this.retryMppRequest(url, initialInit, challenge, receipt);
-  }
-  async retryMppRequest(url, initialInit, challenge, receipt) {
-    const retryHeaders = new Headers(initialInit?.headers);
-    retryHeaders.set("MACHINE-PAYMENT-PROOF", receipt.proofHeader);
-    const retryResponse = await this.merchantFetch(url, {
-      ...initialInit,
-      headers: retryHeaders
-    });
-    if (!retryResponse.ok) {
-      const merchant = await captureMerchantResponse(retryResponse);
-      await this.recordMerchantRetryRejected({
-        rail: receipt.rail,
-        paymentId: receipt.paymentId,
-        txHash: receipt.txHash,
-        resourceUrl: receipt.resourceUrl,
-        merchant,
-        details: {
-          challenge_id: receipt.challengeId
-        }
-      });
-      throw new HavenApiError(
-        "Machine payment retry failed after Haven sent the payment.",
-        merchant.merchant_status,
-        {
-          marker: "machine_payment_retry_rejected_after_payment",
-          payment_id: receipt.paymentId,
-          tx_hash: receipt.txHash,
-          resource_url: receipt.resourceUrl,
-          rail: receipt.rail,
-          ...merchant
-        }
-      );
-    }
-    await this.reportMachinePaymentEvidence({
-      paymentId: receipt.paymentId,
-      rail: receipt.rail,
-      txHash: receipt.txHash,
-      resourceUrl: receipt.resourceUrl,
-      merchantStatus: retryResponse.status,
-      challengePayload: challenge,
-      paymentProofHeaderName: "MACHINE-PAYMENT-PROOF",
-      paymentProofHeader: receipt.proofHeader,
-      protocolReceiptHeaderName: retryResponse.headers.has("Payment-Receipt") ? "Payment-Receipt" : retryResponse.headers.has("MACHINE-PAYMENT-RESPONSE") ? "MACHINE-PAYMENT-RESPONSE" : void 0,
-      protocolReceiptHeader: retryResponse.headers.get("Payment-Receipt") ?? retryResponse.headers.get("MACHINE-PAYMENT-RESPONSE") ?? void 0
-    });
-    await this.reportMerchantReceipt(receipt.paymentId, retryResponse);
-    return retryResponse;
-  }
+  // #1328: authorizeMachinePayment / authorizeMppDemoPayment / resumeAuthorizedMpp
+  // / resumeMppPayment / fetchWithMachinePayment / retryMppRequest (the
+  // MACHINE-PAYMENT-CHALLENGE / mpp_demo client surface) are retired — the
+  // backend's POST /machine-payments/authorize refuses unconditionally now,
+  // and MACHINE-PAYMENT-CHALLENGE was never produced by any other Haven
+  // surface. Use the x402 flow (authorizeX402 / fetch / quoteX402 / payX402Quote)
+  // for agent-to-merchant payments.
   assertCanResumeX402(status, paymentRequired, option) {
     if (status.rail !== "x402") {
       throw new HavenPaymentStateError(
@@ -2553,68 +2291,6 @@ var HavenClient = class {
       );
     }
   }
-  assertCanResumeMpp(status, challenge) {
-    if (!isMppRail(status.rail)) {
-      throw new HavenPaymentStateError(
-        `Payment ${status.paymentId} is ${status.rail}, not MPP.`,
-        409,
-        status
-      );
-    }
-    if (status.nextAction !== AgentPaymentNextAction.RetryOriginalX402Request) {
-      throw new HavenPaymentStateError(status.message, PAYMENT_STATE_STATUS_CODES[status.status] ?? 409, status);
-    }
-    if (!status.txHash) {
-      throw new HavenApiError(
-        `MPP payment ${status.paymentId} is ready to retry but has no Haven transaction hash.`,
-        502,
-        status,
-        status.paymentId
-      );
-    }
-    if (status.resourceUrl && status.resourceUrl !== challenge.resource) {
-      throw new HavenApiError(
-        "MPP resume request does not match the approved resource URL.",
-        409,
-        { status, challenge },
-        status.paymentId
-      );
-    }
-    if (status.merchantAddress && !sameAddress(status.merchantAddress, challenge.recipient)) {
-      throw new HavenApiError(
-        "MPP resume request does not match the approved merchant.",
-        409,
-        { status, challenge },
-        status.paymentId
-      );
-    }
-    if (status.chainId && status.chainId !== challenge.network.chainId) {
-      throw new HavenApiError(
-        "MPP resume request does not match the approved network.",
-        409,
-        { status, challenge },
-        status.paymentId
-      );
-    }
-    if (status.token && status.token !== challenge.asset.symbol) {
-      throw new HavenApiError(
-        "MPP resume request does not match the approved token.",
-        409,
-        { status, challenge },
-        status.paymentId
-      );
-    }
-    const approvedAmount = status.amount ? normalizeDecimal(status.amount) : "";
-    const requestedAmount = normalizeDecimal(challenge.amount.display);
-    if (approvedAmount && approvedAmount !== requestedAmount) {
-      throw new HavenApiError(
-        "MPP resume request does not match the approved amount.",
-        409,
-        { status, challenge },
-        status.paymentId
-      );
-    }
-  }
   mapX402ReceiptFromAuthorization(paymentRequired, option, paymentHeader, raw, execResult) {
     const txHash = execResult?.tx_hash ?? raw.tx_hash ?? "";
     const chainId = execResult?.chain_id ?? raw.chain_id ?? chainIdFromNetwork(option.network);
@@ -2721,53 +2397,6 @@ var HavenClient = class {
       this.x402ReceiptCache.set(idempotencyKey, { expiresAt, receipt });
     }
   }
-  mapMachinePaymentReceipt(challenge, raw, txHash, execResult) {
-    const receiptWithoutHeader = {
-      success: true,
-      rail: challenge.rail,
-      paymentId: raw.payment_id,
-      challengeId: challenge.challengeId,
-      txHash,
-      token: execResult?.token ?? raw.token ?? challenge.asset.symbol,
-      amount: execResult?.amount ?? raw.amount ?? challenge.amount.display,
-      to: execResult?.to ?? raw.to ?? challenge.recipient,
-      resourceUrl: raw.resource_url ?? challenge.resource,
-      explorerUrl: execResult?.explorer_url ?? raw.explorer_url ?? buildExplorerUrl(execResult?.chain_id ?? raw.chain_id ?? challenge.network.chainId, txHash),
-      payer: raw.payer ?? raw.safe_address,
-      chainId: execResult?.chain_id ?? raw.chain_id ?? challenge.network.chainId
-    };
-    return {
-      ...receiptWithoutHeader,
-      proofHeader: encodeMachinePaymentProof(receiptWithoutHeader)
-    };
-  }
-  mapMachinePaymentReceiptFromStatus(challenge, status) {
-    if (!status.txHash) {
-      throw new HavenApiError(
-        `MPP payment ${status.paymentId} is ready to retry but has no Haven transaction hash.`,
-        502,
-        status,
-        status.paymentId
-      );
-    }
-    const receiptWithoutHeader = {
-      success: true,
-      rail: challenge.rail,
-      paymentId: status.paymentId,
-      challengeId: challenge.challengeId,
-      txHash: status.txHash,
-      token: status.token || challenge.asset.symbol,
-      amount: status.amount || challenge.amount.display,
-      to: status.merchantAddress ?? challenge.recipient,
-      resourceUrl: status.resourceUrl ?? challenge.resource,
-      explorerUrl: explorerUrlOrEmpty(status.chainId || challenge.network.chainId, status.txHash),
-      chainId: status.chainId || challenge.network.chainId
-    };
-    return {
-      ...receiptWithoutHeader,
-      proofHeader: encodeMachinePaymentProof(receiptWithoutHeader)
-    };
-  }
   async recordMerchantRetryRejected(input) {
     try {
       await this.post("/machine-payments/reconciliation-events", {
@@ -3010,63 +2639,18 @@ var HavenClient = class {
       merchantAddress: input.accepted.payTo
     };
   }
-  buildMppQuote(challenge, request, idempotencyKey) {
-    return {
-      rail: "mpp",
-      paymentRail: challenge.rail,
-      idempotencyKey: idempotencyKey ?? buildMachinePaymentIdempotencyKey(challenge),
-      challenge,
-      request,
-      resourceUrl: challenge.resource,
-      description: challenge.description ?? null,
-      amountAtomic: challenge.amount.atomic,
-      amount: challenge.amount.display,
-      token: challenge.asset.symbol,
-      asset: challenge.asset.address,
-      network: challenge.network.name,
-      chainId: challenge.network.chainId,
-      merchantAddress: challenge.recipient,
-      expiresAt: challenge.expiresAt
-    };
-  }
-  buildMppResumeState(input) {
-    const quote = this.buildMppQuote(
-      input.challenge,
-      input.request ?? this.snapshotX402Request(input.challenge.resource),
-      input.idempotencyKey
-    );
-    return {
-      rail: "mpp",
-      paymentRail: quote.paymentRail,
-      paymentId: input.paymentId,
-      idempotencyKey: quote.idempotencyKey,
-      challenge: input.challenge,
-      url: input.request?.url ?? input.challenge.resource,
-      request: input.request,
-      resourceUrl: quote.resourceUrl,
-      description: quote.description,
-      amountAtomic: quote.amountAtomic,
-      amount: quote.amount,
-      token: quote.token,
-      asset: quote.asset,
-      network: quote.network,
-      chainId: quote.chainId,
-      merchantAddress: quote.merchantAddress,
-      expiresAt: quote.expiresAt
-    };
-  }
+  // #1328: attachResumeState's 'mpp' branch (buildMppQuote / buildMppResumeState
+  // / attachMppResumeState) is retired along with the rest of the MPP-demo
+  // client surface — every remaining caller passes rail: 'x402' only, so this
+  // is now a direct alias for attachX402ResumeState rather than a dispatcher.
   attachResumeState(err, input) {
-    if (input.rail === "x402") {
-      this.attachX402ResumeState(
-        err,
-        input.paymentRequired,
-        input.accepted,
-        input.idempotencyKey,
-        input.request
-      );
-      return;
-    }
-    this.attachMppResumeState(err, input.challenge, input.idempotencyKey, input.request);
+    this.attachX402ResumeState(
+      err,
+      input.paymentRequired,
+      input.accepted,
+      input.idempotencyKey,
+      input.request
+    );
   }
   attachX402ResumeState(err, paymentRequired, accepted, idempotencyKey, request) {
     if (!(err instanceof HavenPaymentStateError)) return;
@@ -3079,16 +2663,6 @@ var HavenClient = class {
       request
     });
   }
-  attachMppResumeState(err, challenge, idempotencyKey, request) {
-    if (!(err instanceof HavenPaymentStateError)) return;
-    if (!isMppRail(err.state.rail)) return;
-    err.resumeState = this.buildMppResumeState({
-      paymentId: err.state.paymentId,
-      challenge,
-      idempotencyKey,
-      request
-    });
-  }
   // ── Tool Execution (for agent frameworks) ────────────────────────
   /**
    * Execute a tool call by name and input.
@@ -3147,29 +2721,6 @@ var HavenClient = class {
         return this.toolError(err);
       }
     }
-    if (toolName === "authorize_machine_payment") {
-      const { challenge, idempotencyKey } = input;
-      try {
-        const receipt = await this.authorizeMachinePayment(challenge, { idempotencyKey });
-        return {
-          success: true,
-          payment_id: receipt.paymentId,
-          tx_hash: receipt.txHash,
-          token: receipt.token,
-          amount: receipt.amount,
-          to: receipt.to,
-          resource_url: receipt.resourceUrl,
-          explorer_url: receipt.explorerUrl,
-          proof_header: receipt.proofHeader,
-          rail: receipt.rail,
-          challenge_id: receipt.challengeId,
-          payer: receipt.payer,
-          chain_id: receipt.chainId
-        };
-      } catch (err) {
-        return this.toolError(err);
-      }
-    }
     if (toolName === "get_payment_status") {
       const { payment_id } = input;
       const result = await this.getPaymentStatus(payment_id);
@@ -3517,7 +3068,7 @@ var toolDescriptions = {
   payX402OneShot: {
     summary: "Fetch an x402 paid HTTP resource in a single call. Handles the full probe -> pay -> retry round trip and returns the merchant response.",
     selectionGuidance: "Prefer this over the quote+pay split when the agent just wants the paid resource and does not need to inspect the price first. If you already have a quote from haven_quote_x402, use haven_pay_x402_quote instead. Do not use for read-only allowance, budget, spend-limit, remaining-amount, reset-period, or what-can-I-spend questions; use the allowance lookup tool instead.",
-    behavior: "Calls the URL, parses any HTTP 402 x402 challenge, signs the EIP-3009 payment from the delegate wallet, asks Haven for a Safe AllowanceModule top-up if needed, then retries the original request with the X-PAYMENT header and returns the merchant response. If the resource returns an MPP machine-payment challenge instead of standard x402, the MPP payment path is used automatically. If the resource returns a non-402 status, returns it unchanged without contacting Haven.",
+    behavior: "Calls the URL, parses any HTTP 402 x402 challenge, signs the EIP-3009 payment from the delegate wallet, asks Haven for a Safe AllowanceModule top-up if needed, then retries the original request with the X-PAYMENT header and returns the merchant response. If the resource returns a non-402 status, returns it unchanged without contacting Haven.",
     nextActionGuidance: "If approval is needed, preserve the returned resume_state or paymentId and call the resume tool once nextAction=retry_original_x402_request. If the response carries phase=insufficient_funds and nextAction=fund_safe_or_raise_allowance, the payment cannot be retried until the originating Safe is funded or the agent allowance raised \u2014 stop and tell the user the shortfall reported on the response."
   },
   resumeX402: {
@@ -3525,29 +3076,17 @@ var toolDescriptions = {
     behavior: "Accepts either resume_state or payment_id, validates the original x402 details against the approved Haven funding, and retries the merchant request with the X-PAYMENT header. No new Haven approval is created.",
     nextActionGuidance: "Only use when get_payment_status returns nextAction=retry_original_x402_request; do not start a new merchant session."
   },
-  quoteMpp: {
-    summary: "Inspect a Haven MPP challenge or paid MPP URL without creating a Haven payment, signature, approval, or on-chain transaction.",
-    behavior: "Parses an MPP challenge envelope and returns a typed quote with rail tag, amount, asset, and merchant context. Pure read-only \u2014 Haven is not contacted.",
-    nextActionGuidance: "On success the returned quote is the input to haven_pay_mpp_challenge. Do not call the merchant again \u2014 Haven re-uses the captured request when paying."
-  },
-  payMpp: {
-    summary: "Pay an inspected MPP challenge. The delegate key signs locally; Haven only validates and relays signed, on-chain-constrained payment transactions.",
-    selectionGuidance: "Do not use this for read-only allowance, budget, spend-limit, remaining-amount, reset-period, or what-can-I-spend questions; use the allowance lookup tool instead.",
-    behavior: "Authorizes the payment through Haven within the on-chain allowance, signs the challenge proof, and returns the proof header for retrying the original paid resource.",
-    nextActionGuidance: "If approval is needed, preserve resume_state or payment_id and wait for nextAction=retry_original_x402_request before resuming."
-  },
-  resumeMpp: {
-    summary: "Resume an MPP payment after the Haven wallet owner approved the funding step.",
-    behavior: "Accepts either resume_state or payment_id and retries the original paid resource with the MPP proof header. No new Haven approval is created.",
-    nextActionGuidance: ""
-  },
+  // #1328: quoteMpp / payMpp / resumeMpp (the mpp_demo challenge/quote/resume
+  // fragments) are retired along with the client surface they described —
+  // MACHINE-PAYMENT-CHALLENGE was never produced by anything besides the now
+  // deleted `/demo/mpp/*` route. Use the x402 fragments above instead.
   getPaymentStatus: {
     summary: "Fetch structured Haven payment status, including phase and nextAction taxonomy for agent recovery.",
     behavior: "Accepts a payment intent or approval request id and returns the full state taxonomy (phase, nextAction, rail, amount, merchant, resource url, idempotency key, message).",
     nextActionGuidance: ""
   },
   getResumeState: {
-    summary: "Rehydrate stored x402 or MPP resume_state by payment_id.",
+    summary: "Rehydrate stored x402 resume_state by payment_id.",
     behavior: "Returns the context that the agent originally received in a pending-approval response, reconstructed from Haven's database. This is context only; signing still happens locally when a resume tool is called.",
     nextActionGuidance: ""
   },
@@ -3589,13 +3128,13 @@ var toolDescriptions = {
   },
   sweep_delegate: {
     summary: "Sweep stranded USDC and/or ETH from the delegate wallet back to the originating Safe.",
-    selectionGuidance: "Use this when the user instructs you to recover stranded funds on the delegate wallet, or when a payment status returns nextAction=sweep_stranded_funds. Do NOT use for normal payments \u2014 use haven_pay_x402 or haven_pay_mpp_challenge. Do NOT use to read balances only \u2014 use haven_get_allowances.",
+    selectionGuidance: "Use this when the user instructs you to recover stranded funds on the delegate wallet, or when a payment status returns nextAction=sweep_stranded_funds. Do NOT use for normal payments \u2014 use haven_pay_x402. Do NOT use to read balances only \u2014 use haven_get_allowances.",
     behavior: "Reads the delegate EOA's on-chain USDC and ETH balances. For each non-zero balance, signs and submits a transfer from the delegate EOA to the originating Safe (hardcoded destination). The delegate key signs locally \u2014 Haven never sees it and the backend never constructs signed transactions (CASP/MiCA Red Line #2). Returns tx hashes and recovered amounts. Returns an empty transfers list when nothing is stranded.",
     nextActionGuidance: "If transfers is non-empty, confirm the amounts with the user. No further action required \u2014 funds are on their way back to the Safe."
   },
   send: {
     summary: "Send ETH or USDC directly from the agent's Haven wallet to a recipient address.",
-    selectionGuidance: "Use this for plain transfers \u2014 refunding a user, paying a freelancer, topping up a co-agent's wallet, or moving funds between addresses. Do NOT use for x402 paid endpoints (use haven_pay_x402 instead) or MPP merchant payments (use haven_pay_mpp_challenge). Do NOT use for read-only allowance, budget, or what-can-I-spend questions \u2014 use haven_get_allowances.",
+    selectionGuidance: "Use this for plain transfers \u2014 refunding a user, paying a freelancer, topping up a co-agent's wallet, or moving funds between addresses. Do NOT use for x402 paid endpoints \u2014 use haven_pay_x402 instead. Do NOT use for read-only allowance, budget, or what-can-I-spend questions \u2014 use haven_get_allowances.",
     behavior: "Sends the requested amount through the Safe AllowanceModule. Amounts within the remaining on-chain allowance for the asset execute automatically; amounts that exceed the allowance are queued as pending_approval for the wallet owner to approve in Haven. The agent's signing key signs the AllowanceModule transfer hash; Haven never receives the key.",
     nextActionGuidance: "If pending_approval is returned, preserve the payment_id and wait for the wallet owner to approve in Haven. Poll haven_get_payment_status until nextAction=none."
   }
@@ -3711,22 +3250,11 @@ var resumeX402Schema = {
   },
   required: ["payment_id", "url", "payTo", "amount", "asset", "network"]
 };
-var authorizeMachinePaymentSchema = {
-  type: "object",
-  properties: {
-    challenge: {
-      type: "object",
-      description: "Machine payment challenge returned by a Haven demo endpoint"
-    }
-  },
-  required: ["challenge"]
-};
 var MAKE_PAYMENT_DESCRIPTION = "Request and sign a payment from the user-controlled Safe within approved on-chain limits. For read-only allowance, budget, spend-limit, remaining-amount, or reset-period questions, use get_allowances instead of making a payment. Haven authenticates the agent, validates the signed intent, and relays the Safe AllowanceModule transaction; it does not hold keys or control funds. Gnosis Chain tokens: EURe, USDC.e, xDAI. Base tokens: USDC, ETH.";
 var GET_STATUS_DESCRIPTION = toolDescriptions.getPaymentStatus.summary + " Accepts payment intent IDs and approval request IDs. Returns the current status, phase, next_action, transaction hash if available, and payment details.";
 var GET_ALLOWANCES_DESCRIPTION = composeDescription(toolDescriptions.getAllowances);
 var AUTHORIZE_X402_DESCRIPTION = composeDescription(toolDescriptions.payX402) + " In this SDK tool set, the allowance lookup tool is get_allowances. When a paid API returns x402 payment requirements, use this tool to sign with the agent-owned delegate key and request a policy-limited Safe AllowanceModule top-up when needed. Haven relays signed transactions only; the agent key authorizes payment and on-chain limits enforce spend. If this returns pending_approval, tell the user it is waiting in Haven, preserve the original merchant/MCP session and x402 details, call get_payment_status later, and use resume_x402_payment only when next_action is retry_original_x402_request. Do not start a new merchant session or loop retries while approval is pending. Use the returned payment_header as the X-PAYMENT header on the retry request when doing a manual HTTP retry.";
 var RESUME_X402_DESCRIPTION = toolDescriptions.resumeX402.summary + " Use this only after get_payment_status returns next_action=retry_original_x402_request. It checks the approved payment, validates the original x402 details, and returns a merchant X-PAYMENT header without creating a new approval request or merchant session.";
-var AUTHORIZE_MACHINE_PAYMENT_DESCRIPTION = composeDescription(toolDescriptions.payMpp) + " In this SDK tool set, the allowance lookup tool is get_allowances. Currently scoped to the internal MPP demo rail. The agent signs the payment, Haven relays it within the on-chain allowance, and the tool returns a proof header for the retry request.";
 var SWEEP_DELEGATE_DESCRIPTION = composeDescription(toolDescriptions.sweep_delegate);
 var sweepDelegateSchema = {
   type: "object",
@@ -3760,11 +3288,6 @@ function claudeTools() {
       description: RESUME_X402_DESCRIPTION,
       input_schema: resumeX402Schema
     },
-    {
-      name: "authorize_machine_payment",
-      description: AUTHORIZE_MACHINE_PAYMENT_DESCRIPTION,
-      input_schema: authorizeMachinePaymentSchema
-    },
     {
       name: "haven_sweep_delegate",
       description: SWEEP_DELEGATE_DESCRIPTION,
@@ -3814,14 +3337,6 @@ function openaiTools() {
         parameters: resumeX402Schema
       }
     },
-    {
-      type: "function",
-      function: {
-        name: "authorize_machine_payment",
-        description: AUTHORIZE_MACHINE_PAYMENT_DESCRIPTION,
-        parameters: authorizeMachinePaymentSchema
-      }
-    },
     {
       type: "function",
       function: {
@@ -4214,6 +3729,6 @@ function sameUrl(a, b) {
   }
 }
 
-export { AGENT_PAYMENT_FAILURE_CODE_VALUES, AGENT_PAYMENT_NEXT_ACTION_VALUES, AGENT_PAYMENT_PHASE_VALUES, AGENT_PAYMENT_RAIL_VALUES, AgentPaymentFailureCode, AgentPaymentFailureCodeDescriptions, AgentPaymentFailureCodeSchema, AgentPaymentNextAction, AgentPaymentNextActionDescriptions, AgentPaymentNextActionSchema, AgentPaymentPhase, AgentPaymentPhaseDescriptions, AgentPaymentPhaseSchema, AgentPaymentRail, AgentPaymentRailDescriptions, AgentPaymentRailSchema, AgentPaymentWarningCode, DISCOVERY_MAX_BYTES, HAVEN_MINIMUM_NODE_VERSION, HAVEN_SKILL_MD, HavenApiError, HavenClient, HavenError, HavenPaymentStateError, HavenSigningError, HavenTimeoutError, HavenUnsupportedSignerVersionError, MERCHANT_DISCOVERY_PATHS, MerchantTimeoutError, RECEIPT_VERSION, SIGNER_UPDATE_FALLBACK, SKILL_FOLDER_NAME, SWEEP_BASE_CHAIN_ID, SWEEP_BASE_SEPOLIA_CHAIN_ID, SWEEP_BASE_SEPOLIA_USDC_ADDRESS, SWEEP_BASE_USDC_ADDRESS, SignerRefusalCode, TRANSFER_WITH_AUTHORIZATION_TYPES, X402UnexpectedStatusError, X402_MAX_AUTHORIZATION_WINDOW_SECONDS, X402_SETTLEMENT_FORWARD_MARGIN_SECONDS, addressFromKey, buildMachinePaymentIdempotencyKey, buildSweepAuthorizationMessage, buildSweepTypedData, buildX402ExpectedMessage, compareNodeVersions, composeDescription, decodeBase64Json, decodeBase64Utf8, discoverMerchantMcpUrl, encodeBase64Json, encodeBase64Utf8, encodeMachinePaymentProof, encodePaymentProof, havenTools, isSupportedNodeVersion, isSweepableChain, parseMachinePaymentChallenge, parseMachinePaymentChallengeResponse, parsePaymentRequired, parsePaymentRequiredResponse, resolveTokenFromAddress, sameUrl, selectPaymentOption, selectStandardPaymentOption, signHash, signUserOpTypedDataForDelegation, sweepUsdcAddress, sweepUsdcDomain, toStandardPaymentRequirements, toolDescriptions, unsupportedNodeVersionMessage, verifyPaymentReceipt, verifySignature, x402AuthorizationAmount };
+export { AGENT_PAYMENT_FAILURE_CODE_VALUES, AGENT_PAYMENT_NEXT_ACTION_VALUES, AGENT_PAYMENT_PHASE_VALUES, AGENT_PAYMENT_RAIL_VALUES, AgentPaymentFailureCode, AgentPaymentFailureCodeDescriptions, AgentPaymentFailureCodeSchema, AgentPaymentNextAction, AgentPaymentNextActionDescriptions, AgentPaymentNextActionSchema, AgentPaymentPhase, AgentPaymentPhaseDescriptions, AgentPaymentPhaseSchema, AgentPaymentRail, AgentPaymentRailDescriptions, AgentPaymentRailSchema, AgentPaymentWarningCode, DISCOVERY_MAX_BYTES, HAVEN_MINIMUM_NODE_VERSION, HAVEN_SKILL_MD, HavenApiError, HavenClient, HavenError, HavenPaymentStateError, HavenSigningError, HavenTimeoutError, HavenUnsupportedSignerVersionError, MERCHANT_DISCOVERY_PATHS, MerchantTimeoutError, RECEIPT_VERSION, SIGNER_UPDATE_FALLBACK, SKILL_FOLDER_NAME, SWEEP_BASE_CHAIN_ID, SWEEP_BASE_SEPOLIA_CHAIN_ID, SWEEP_BASE_SEPOLIA_USDC_ADDRESS, SWEEP_BASE_USDC_ADDRESS, SignerRefusalCode, TRANSFER_WITH_AUTHORIZATION_TYPES, X402UnexpectedStatusError, X402_MAX_AUTHORIZATION_WINDOW_SECONDS, X402_SETTLEMENT_FORWARD_MARGIN_SECONDS, addressFromKey, buildSweepAuthorizationMessage, buildSweepTypedData, buildX402ExpectedMessage, compareNodeVersions, composeDescription, decodeBase64Json, decodeBase64Utf8, discoverMerchantMcpUrl, encodeBase64Json, encodeBase64Utf8, encodePaymentProof, havenTools, isSupportedNodeVersion, isSweepableChain, parsePaymentRequired, parsePaymentRequiredResponse, resolveTokenFromAddress, sameUrl, selectPaymentOption, selectStandardPaymentOption, signHash, signUserOpTypedDataForDelegation, sweepUsdcAddress, sweepUsdcDomain, toStandardPaymentRequirements, toolDescriptions, unsupportedNodeVersionMessage, verifyPaymentReceipt, verifySignature, x402AuthorizationAmount };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map