@haven_ai/sdk 0.1.12-alpha.0 → 0.1.14-alpha.0

package/dist/index.cjs

@@ -1614,6 +1614,54 @@ var HavenClient = class {
     });
     return retryResponse;
   }
+  /**
+   * Deliver an already-signed x402 payment header to the merchant and return
+   * the merchant's response. Used by the hosted MCP server to complete the
+   * merchant leg of an MCP tool payment after the edge signer has built the
+   * `X-PAYMENT` header.
+   *
+   * Custody note: this never needs the delegate key. It relays a signed,
+   * amount/merchant/nonce-bound EIP-3009 authorization the edge signer already
+   * produced — the hosted server cannot mint or reuse signing authority.
+   *
+   * When the URL is MCP-shaped (`/mcp` path), runs a fresh `initialize`
+   * handshake (the quote-time session is gone once funding confirms; the x402
+   * challenge is stateless w.r.t. the MCP session, so a fresh session is
+   * accepted), threads the session + wallet headers, sets `X-PAYMENT`, and
+   * collapses an SSE JSON-RPC response to its `result`.
+   *
+   * Limitation: detects MCP only by the `/mcp` path convention, not the
+   * Coinbase Bazaar `extensions.bazaar` 402 signal that `fetch()` also honors.
+   * A Bazaar-discoverable merchant on a non-`/mcp` URL would need the standard
+   * `fetch()` path. All current MCP-tool merchants use the `/mcp` convention.
+   */
+  async completeX402MerchantCall(input) {
+    let mcpSessionId;
+    if (isMcpUrl(input.url)) {
+      mcpSessionId = await this.mcpInitialize(input.url, input.init);
+    }
+    let requestInit = this.withX402Wallet(input.init, this.x402PayerAddress()) ?? {};
+    if (mcpSessionId) requestInit = this.withMcpHeaders(requestInit, mcpSessionId);
+    const headers = new Headers(requestInit.headers);
+    headers.set("X-PAYMENT", input.paymentHeader);
+    requestInit = { ...requestInit, headers };
+    const response = await globalThis.fetch(input.url, requestInit);
+    const surfaced = mcpSessionId ? await this.surfaceMcpResult(response) : response;
+    const settlement = parseMerchantSettlement(surfaced.headers.get("PAYMENT-RESPONSE"));
+    const text = await surfaced.text();
+    let body;
+    try {
+      body = text ? JSON.parse(text) : null;
+    } catch {
+      body = text;
+    }
+    return {
+      status: surfaced.status,
+      ok: surfaced.ok,
+      body,
+      settlementTxHash: settlement.settlementTxHash ?? void 0
+    };
+  }
   async authorizeMachinePayment(challenge, options = {}) {
     if (!this.delegateKey) {
       throw new HavenSigningError(
@@ -3084,6 +3132,13 @@ normal, not an error.
   the local Haven signer; follow the tool results \u2014 they tell you the next
   action at every step. Retry the original request only when the result says
   \`retry_original_x402_request\`.
+- **Paid MCP tool call:** \`haven_pay_mcp_tool\` with the merchant URL, tool
+  name, and arguments. Then follow the returned steps: \`haven_sign\` the
+  funding hash, \`haven_submit\` the signature, \`haven_x402_sign_header\` to
+  build the payment header, and finally \`haven_complete_mcp_tool\` to settle
+  with the merchant and get the tool result. Pass \`payment_required\` and
+  \`arguments\` through verbatim from the \`haven_pay_mcp_tool\` result. Do not
+  call the merchant yourself \u2014 Haven completes the merchant leg for you.
 - **Status:** \`haven_get_payment_status\` with a \`payment_id\` to check on
   queued or in-flight payments. Do not poll in a tight loop.