meta-ads-mcp 0.7.7__tar.gz → 0.7.9__tar.gz

{meta_ads_mcp-0.7.7 → meta_ads_mcp-0.7.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: meta-ads-mcp
-Version: 0.7.7
+Version: 0.7.9
 Summary: Model Context Protocol (MCP) plugin for interacting with Meta Ads API
 Project-URL: Homepage, https://github.com/pipeboard-co/meta-ads-mcp
 Project-URL: Bug Tracker, https://github.com/pipeboard-co/meta-ads-mcp/issues

meta_ads_mcp-0.7.9/RELEASE.md

@@ -0,0 +1,166 @@
+# Release Process
+
+This repository uses GitHub Actions to automatically publish releases to PyPI. Here's the optimized release process:
+
+## 🚀 Quick Release (Recommended)
+
+### Prerequisites
+- ✅ **Trusted Publishing Configured**: Repository uses PyPI trusted publishing with OIDC tokens
+- ✅ **GitHub CLI installed**: `gh` command available for streamlined releases
+- ✅ **Clean working directory**: No uncommitted changes
+
+### Optimal Release Process
+
+1. **Update version in both files** (use consistent versioning):
+   
+   ```bash
+   # Update pyproject.toml
+   sed -i '' 's/version = "0.7.7"/version = "0.7.8"/' pyproject.toml
+   
+   # Update __init__.py  
+   sed -i '' 's/__version__ = "0.7.7"/__version__ = "0.7.8"/' meta_ads_mcp/__init__.py
+   ```
+   
+   Or manually edit:
+   - `pyproject.toml`: `version = "0.7.8"`
+   - `meta_ads_mcp/__init__.py`: `__version__ = "0.7.8"`
+
+2. **Commit and push version changes**:
+   ```bash
+   git add pyproject.toml meta_ads_mcp/__init__.py
+   git commit -m "Bump version to 0.7.8"
+   git push origin main
+   ```
+
+3. **Create GitHub release** (triggers automatic PyPI publishing):
+   ```bash
+   # Use bash wrapper if gh has issues in Cursor
+   bash -c "gh release create 0.7.8 --title '0.7.8' --generate-notes"
+   ```
+
+4. **Verify release** (optional):
+   ```bash
+   # Check GitHub release
+   curl -s "https://api.github.com/repos/pipeboard-co/meta-ads-mcp/releases/latest" | grep -E '"tag_name"|"name"'
+   
+   # Check PyPI availability (wait 2-3 minutes)
+   curl -s "https://pypi.org/pypi/meta-ads-mcp/json" | grep -E '"version"|"0.7.8"'
+   ```
+
+## 📋 Detailed Release Process
+
+### Version Management Best Practices
+
+- **Semantic Versioning**: Follow `MAJOR.MINOR.PATCH` (e.g., 0.7.8)
+- **Synchronized Files**: Always update BOTH version files
+- **Commit Convention**: Use `"Bump version to X.Y.Z"` format
+- **Release Tag**: GitHub release tag matches version (no "v" prefix)
+
+### Pre-Release Checklist
+
+```bash
+# 1. Ensure clean working directory
+git status
+
+# 2. Run tests locally (optional but recommended)
+uv run python -m pytest tests/ -v
+
+# 3. Check current version
+grep -E "version =|__version__" pyproject.toml meta_ads_mcp/__init__.py
+```
+
+### Release Commands (One-liner)
+
+```bash
+# Complete release in one sequence
+VERSION="0.7.8" && \
+sed -i '' "s/version = \"0.7.7\"/version = \"$VERSION\"/" pyproject.toml && \
+sed -i '' "s/__version__ = \"0.7.7\"/__version__ = \"$VERSION\"/" meta_ads_mcp/__init__.py && \
+git add pyproject.toml meta_ads_mcp/__init__.py && \
+git commit -m "Bump version to $VERSION" && \
+git push origin main && \
+bash -c "gh release create $VERSION --title '$VERSION' --generate-notes"
+```
+
+## 🔄 Workflows
+
+### `publish.yml` (Automatic)
+- **Trigger**: GitHub release creation
+- **Purpose**: Build and publish to PyPI
+- **Security**: OIDC tokens (no API keys)
+- **Status**: ✅ Fully automated
+
+### `test.yml` (Validation)
+- **Trigger**: Push to main/master
+- **Purpose**: Package structure validation
+- **Matrix**: Python 3.10, 3.11, 3.12
+- **Note**: Build tests only, not pytest
+
+## 🛠️ Troubleshooting
+
+### Common Issues
+
+1. **gh command issues in Cursor**:
+   ```bash
+   # Use bash wrapper
+   bash -c "gh release create 0.7.8 --title '0.7.8' --generate-notes"
+   ```
+
+2. **Version mismatch**:
+   ```bash
+   # Verify both files have same version
+   grep -E "version =|__version__" pyproject.toml meta_ads_mcp/__init__.py
+   ```
+
+3. **PyPI not updated**:
+   ```bash
+   # Check if package is available (wait 2-3 minutes)
+   curl -s "https://pypi.org/pypi/meta-ads-mcp/json" | grep '"version"'
+   ```
+
+### Manual Deployment (Fallback)
+
+```bash
+# Install build tools
+pip install build twine
+
+# Build package
+python -m build
+
+# Upload to PyPI (requires API token)
+python -m twine upload dist/*
+```
+
+## 📊 Release Verification
+
+### GitHub Release
+- ✅ Release created with correct tag
+- ✅ Auto-generated notes from commits
+- ✅ Actions tab shows successful workflow
+
+### PyPI Package
+- ✅ Package available for installation
+- ✅ Correct version displayed
+- ✅ All dependencies listed
+
+### Installation Test
+```bash
+# Test new version installation
+pip install meta-ads-mcp==0.7.8
+# or
+uvx meta-ads-mcp@0.7.8
+```
+
+## 🔒 Security Notes
+
+- **Trusted Publishing**: Uses GitHub OIDC tokens (no API keys needed)
+- **Isolated Builds**: All builds run in GitHub-hosted runners
+- **Access Control**: Only maintainers can create releases
+- **Audit Trail**: All releases tracked in GitHub Actions
+
+## 📈 Release Metrics
+
+Track successful releases:
+- **GitHub Releases**: https://github.com/pipeboard-co/meta-ads-mcp/releases
+- **PyPI Package**: https://pypi.org/project/meta-ads-mcp/
+- **Actions History**: https://github.com/pipeboard-co/meta-ads-mcp/actions 

{meta_ads_mcp-0.7.7 → meta_ads_mcp-0.7.9}/meta_ads_mcp/__init__.py

@@ -7,7 +7,7 @@ with the Claude LLM.
 
 from meta_ads_mcp.core.server import main
 
-__version__ = "0.7.7"
+__version__ = "0.7.9"
 
 __all__ = [
     'get_ad_accounts',

{meta_ads_mcp-0.7.7 → meta_ads_mcp-0.7.9}/meta_ads_mcp/core/accounts.py

@@ -36,29 +36,58 @@ async def get_account_info(access_token: str = None, account_id: str = None) ->
     
     Args:
         access_token: Meta API access token (optional - will use cached token if not provided)
-        account_id: Meta Ads account ID (format: act_XXXXXXXXX)
+        account_id: Meta Ads account ID (format: act_XXXXXXXXX) - REQUIRED
     """
-    # If no account ID is specified, try to get the first one for the user
     if not account_id:
-        accounts_json = await get_ad_accounts("me", json.dumps({"limit": 1}), access_token)
-        accounts_data = json.loads(accounts_json)
-        
-        if "data" in accounts_data and accounts_data["data"]:
-            account_id = accounts_data["data"][0]["id"]
-        else:
-            return json.dumps({"error": "No account ID specified and no accounts found for user"}, indent=2)
+        return {
+            "error": {
+                "message": "Account ID is required",
+                "details": "Please specify an account_id parameter",
+                "example": "Use account_id='act_123456789' or account_id='123456789'"
+            }
+        }
     
     # Ensure account_id has the 'act_' prefix for API compatibility
     if not account_id.startswith("act_"):
         account_id = f"act_{account_id}"
     
+    # First, check if the account is accessible to the user
+    endpoint = "me/adaccounts"
+    params = {
+        "fields": "id,name,account_id,account_status,amount_spent,balance,currency,age,business_city,business_country_code",
+        "limit": 50
+    }
+    accessible_accounts_data = await make_api_request(endpoint, access_token, params)
+    
+    if "data" in accessible_accounts_data:
+        accessible_account_ids = [acc["id"] for acc in accessible_accounts_data["data"]]
+        if account_id not in accessible_account_ids:
+            # Provide a helpful error message with accessible accounts
+            accessible_accounts = [
+                {"id": acc["id"], "name": acc["name"]} 
+                for acc in accessible_accounts_data["data"][:10]  # Show first 10
+            ]
+            return {
+                "error": {
+                    "message": f"Account {account_id} is not accessible to your user account",
+                    "details": "This account either doesn't exist or you don't have permission to access it",
+                    "accessible_accounts": accessible_accounts,
+                    "total_accessible_accounts": len(accessible_accounts_data["data"]),
+                    "suggestion": "Try using one of the accessible account IDs listed above"
+                }
+            }
+    
     endpoint = f"{account_id}"
     params = {
-        "fields": "id,name,account_id,account_status,amount_spent,balance,currency,age,funding_source_details,business_city,business_country_code,timezone_name,owner"
+        "fields": "id,name,account_id,account_status,amount_spent,balance,currency,age,business_city,business_country_code,timezone_name"
     }
     
     data = await make_api_request(endpoint, access_token, params)
     
+    # Check if the API request returned an error
+    if "error" in data:
+        return data
+    
     # Add DSA requirement detection
     if "business_country_code" in data:
         european_countries = ["DE", "FR", "IT", "ES", "NL", "BE", "AT", "IE", "DK", "SE", "FI", "NO"]
@@ -69,4 +98,4 @@ async def get_account_info(access_token: str = None, account_id: str = None) ->
             data["dsa_required"] = False
             data["dsa_compliance_note"] = "This account is not subject to European DSA requirements"
     
-    return json.dumps(data, indent=2) 
+    return data 

{meta_ads_mcp-0.7.7 → meta_ads_mcp-0.7.9}/meta_ads_mcp/core/ads.py

@@ -171,7 +171,7 @@ async def get_ad_creatives(access_token: str = None, ad_id: str = None) -> str:
         
     endpoint = f"{ad_id}/adcreatives"
     params = {
-        "fields": "id,name,status,thumbnail_url,image_url,image_hash,object_story_spec" # Added image_hash
+        "fields": "id,name,status,thumbnail_url,image_url,image_hash,object_story_spec,asset_feed_spec,image_urls_for_viewing"
     }
     
     data = await make_api_request(endpoint, access_token, params)
@@ -279,14 +279,26 @@ async def get_ad_image(access_token: str = None, ad_id: str = None) -> Image:
             if "data" in creative_data and creative_data["data"]:
                 creative = creative_data["data"][0]
                 
-                # Try image_urls_for_viewing first (usually higher quality)
+                # Prioritize higher quality image URLs in this order:
+                # 1. image_urls_for_viewing (usually highest quality)
+                # 2. image_url (direct field)
+                # 3. object_story_spec.link_data.picture (usually full size)
+                # 4. thumbnail_url (last resort - often profile thumbnail)
+                
                 if "image_urls_for_viewing" in creative and creative["image_urls_for_viewing"]:
                     image_url = creative["image_urls_for_viewing"][0]
                     print(f"Using image_urls_for_viewing: {image_url}")
-                # Fall back to thumbnail_url
+                elif "image_url" in creative and creative["image_url"]:
+                    image_url = creative["image_url"]
+                    print(f"Using image_url: {image_url}")
+                elif "object_story_spec" in creative and "link_data" in creative["object_story_spec"]:
+                    link_data = creative["object_story_spec"]["link_data"]
+                    if "picture" in link_data and link_data["picture"]:
+                        image_url = link_data["picture"]
+                        print(f"Using object_story_spec.link_data.picture: {image_url}")
                 elif "thumbnail_url" in creative and creative["thumbnail_url"]:
                     image_url = creative["thumbnail_url"]
-                    print(f"Using thumbnail_url: {image_url}")
+                    print(f"Using thumbnail_url (fallback): {image_url}")
             
             if not image_url:
                 return "Error: No image URLs found in creative"

{meta_ads_mcp-0.7.7 → meta_ads_mcp-0.7.9}/meta_ads_mcp/core/auth.py

@@ -25,7 +25,7 @@ from .pipeboard_auth import pipeboard_auth_manager
 # Auth constants
 # Scope includes pages_show_list and pages_read_engagement to fix issue #16
 # where get_account_pages failed for regular users due to missing page permissions
-AUTH_SCOPE = "ads_management,ads_read,business_management,public_profile,pages_show_list,pages_read_engagement"
+AUTH_SCOPE = "business_management,public_profile,pages_show_list,pages_read_engagement"
 AUTH_REDIRECT_URI = "http://localhost:8888/callback"
 AUTH_RESPONSE_TYPE = "token"
 
@@ -159,11 +159,41 @@ class AuthManager:
         try:
             with open(cache_path, "r") as f:
                 data = json.load(f)
+                
+                # Validate the cached data structure
+                required_fields = ["access_token", "created_at"]
+                if not all(field in data for field in required_fields):
+                    logger.warning("Cached token data is missing required fields")
+                    return False
+                
+                # Check if the token looks valid (basic format check)
+                if not data.get("access_token") or len(data["access_token"]) < 20:
+                    logger.warning("Cached token appears malformed")
+                    return False
+                
                 self.token_info = TokenInfo.deserialize(data)
                 
                 # Check if token is expired
                 if self.token_info.is_expired():
-                    logger.info("Cached token is expired")
+                    logger.info("Cached token is expired, removing cache file")
+                    # Remove the expired cache file
+                    try:
+                        cache_path.unlink()
+                        logger.info(f"Removed expired token cache: {cache_path}")
+                    except Exception as e:
+                        logger.warning(f"Could not remove expired cache file: {e}")
+                    self.token_info = None
+                    return False
+                
+                # Additional validation: check if token is too old (more than 60 days)
+                current_time = int(time.time())
+                if self.token_info.created_at and (current_time - self.token_info.created_at) > (60 * 24 * 3600):
+                    logger.warning("Cached token is too old (more than 60 days), removing cache file")
+                    try:
+                        cache_path.unlink()
+                        logger.info(f"Removed old token cache: {cache_path}")
+                    except Exception as e:
+                        logger.warning(f"Could not remove old cache file: {e}")
                     self.token_info = None
                     return False
                 
@@ -171,6 +201,12 @@ class AuthManager:
                 return True
         except Exception as e:
             logger.error(f"Error loading cached token: {e}")
+            # If there's any error reading the cache, try to remove the corrupted file
+            try:
+                cache_path.unlink()
+                logger.info(f"Removed corrupted token cache: {cache_path}")
+            except Exception as cleanup_error:
+                logger.warning(f"Could not remove corrupted cache file: {cleanup_error}")
             return False
     
     def _save_token_to_cache(self) -> None:

{meta_ads_mcp-0.7.7 → meta_ads_mcp-0.7.9}/meta_ads_mcp/core/pipeboard_auth.py

@@ -151,6 +151,18 @@ class PipeboardAuthManager:
             with open(cache_path, "r") as f:
                 logger.debug(f"Reading token cache from {cache_path}")
                 data = json.load(f)
+                
+                # Validate the cached data structure
+                required_fields = ["access_token"]
+                if not all(field in data for field in required_fields):
+                    logger.warning("Cached token data is missing required fields")
+                    return False
+                
+                # Check if the token looks valid (basic format check)
+                if not data.get("access_token") or len(data["access_token"]) < 20:
+                    logger.warning("Cached token appears malformed")
+                    return False
+                
                 self.token_info = TokenInfo.deserialize(data)
                 
                 # Log token details (partial token for security)
@@ -159,7 +171,25 @@ class PipeboardAuthManager:
                 
                 # Check if token is expired
                 if self.token_info.is_expired():
-                    logger.info("Cached token is expired")
+                    logger.info("Cached token is expired, removing cache file")
+                    # Remove the expired cache file
+                    try:
+                        cache_path.unlink()
+                        logger.info(f"Removed expired token cache: {cache_path}")
+                    except Exception as e:
+                        logger.warning(f"Could not remove expired cache file: {e}")
+                    self.token_info = None
+                    return False
+                
+                # Additional validation: check if token is too old (more than 60 days)
+                current_time = int(time.time())
+                if self.token_info.created_at and (current_time - self.token_info.created_at) > (60 * 24 * 3600):
+                    logger.warning("Cached token is too old (more than 60 days), removing cache file")
+                    try:
+                        cache_path.unlink()
+                        logger.info(f"Removed old token cache: {cache_path}")
+                    except Exception as e:
+                        logger.warning(f"Could not remove old cache file: {e}")
                     self.token_info = None
                     return False
                 
@@ -174,9 +204,21 @@ class PipeboardAuthManager:
                 logger.debug(f"Raw cache file content (first 100 chars): {raw_content[:100]}")
             except Exception as e2:
                 logger.error(f"Could not read raw cache file: {e2}")
+            # If there's any error reading the cache, try to remove the corrupted file
+            try:
+                cache_path.unlink()
+                logger.info(f"Removed corrupted token cache: {cache_path}")
+            except Exception as cleanup_error:
+                logger.warning(f"Could not remove corrupted cache file: {cleanup_error}")
             return False
         except Exception as e:
             logger.error(f"Error loading cached token: {e}")
+            # If there's any error reading the cache, try to remove the corrupted file
+            try:
+                cache_path.unlink()
+                logger.info(f"Removed corrupted token cache: {cache_path}")
+            except Exception as cleanup_error:
+                logger.warning(f"Could not remove corrupted cache file: {cleanup_error}")
             return False
     
     def _save_token_to_cache(self) -> None:

{meta_ads_mcp-0.7.7 → meta_ads_mcp-0.7.9}/meta_ads_mcp/core/utils.py

@@ -78,23 +78,31 @@ ad_creative_images = {}
 def extract_creative_image_urls(creative: Dict[str, Any]) -> List[str]:
     """
     Extract image URLs from a creative object for direct viewing.
+    Prioritizes higher quality images over thumbnails.
     
     Args:
         creative: Meta Ads creative object
         
     Returns:
-        List of image URLs found in the creative
+        List of image URLs found in the creative, prioritized by quality
     """
     image_urls = []
     
+    # Prioritize higher quality image URLs in this order:
+    # 1. image_urls_for_viewing (usually highest quality)
+    # 2. image_url (direct field)
+    # 3. object_story_spec.link_data.picture (usually full size)
+    # 4. asset_feed_spec images (multiple high-quality images)
+    # 5. thumbnail_url (last resort - often profile thumbnail)
+    
+    # Check for image_urls_for_viewing (highest priority)
+    if "image_urls_for_viewing" in creative and creative["image_urls_for_viewing"]:
+        image_urls.extend(creative["image_urls_for_viewing"])
+    
     # Check for direct image_url field
     if "image_url" in creative and creative["image_url"]:
         image_urls.append(creative["image_url"])
     
-    # Check for thumbnail_url field
-    if "thumbnail_url" in creative and creative["thumbnail_url"]:
-        image_urls.append(creative["thumbnail_url"])
-    
     # Check object_story_spec for image URLs
     if "object_story_spec" in creative:
         story_spec = creative["object_story_spec"]
@@ -103,7 +111,7 @@ def extract_creative_image_urls(creative: Dict[str, Any]) -> List[str]:
         if "link_data" in story_spec:
             link_data = story_spec["link_data"]
             
-            # Check for picture field
+            # Check for picture field (usually full size)
             if "picture" in link_data and link_data["picture"]:
                 image_urls.append(link_data["picture"])
                 
@@ -121,6 +129,10 @@ def extract_creative_image_urls(creative: Dict[str, Any]) -> List[str]:
             if "url" in image and image["url"]:
                 image_urls.append(image["url"])
     
+    # Check for thumbnail_url field (lowest priority)
+    if "thumbnail_url" in creative and creative["thumbnail_url"]:
+        image_urls.append(creative["thumbnail_url"])
+    
     # Remove duplicates while preserving order
     seen = set()
     unique_urls = []

{meta_ads_mcp-0.7.7 → meta_ads_mcp-0.7.9}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "meta-ads-mcp"
-version = "0.7.7"
+version = "0.7.9"
 description = "Model Context Protocol (MCP) plugin for interacting with Meta Ads API"
 readme = "README.md"
 requires-python = ">=3.10"

{meta_ads_mcp-0.7.7 → meta_ads_mcp-0.7.9}/tests/test_dsa_beneficiary.py

@@ -19,10 +19,10 @@ class TestDSABeneficiaryDetection:
     
     @pytest.mark.asyncio
     async def test_dsa_requirement_detection_business_account(self):
-        """Test detection of DSA requirements for business accounts"""
+        """Test DSA requirement detection for European business accounts"""
         mock_account_response = {
             "id": "act_701351919139047",
-            "name": "Test Business Account",
+            "name": "Test European Business Account",
             "account_status": 1,
             "business_country_code": "DE",  # Germany - DSA compliant
             "business_city": "Berlin",
@@ -35,7 +35,12 @@ class TestDSABeneficiaryDetection:
                 mock_api.return_value = mock_account_response
                 
                 result = await get_account_info(account_id="act_701351919139047")
-                result_data = json.loads(result)
+                
+                # Handle new return format (dictionary instead of JSON string)
+                if isinstance(result, dict):
+                    result_data = result
+                else:
+                    result_data = json.loads(result)
                 
                 # Verify account info is retrieved
                 assert result_data["id"] == "act_701351919139047"
@@ -62,7 +67,12 @@ class TestDSABeneficiaryDetection:
                 mock_api.return_value = mock_account_response
                 
                 result = await get_account_info(account_id="act_123456789")
-                result_data = json.loads(result)
+                
+                # Handle new return format (dictionary instead of JSON string)
+                if isinstance(result, dict):
+                    result_data = result
+                else:
+                    result_data = json.loads(result)
                 
                 # Verify no DSA requirement for US accounts
                 assert result_data["business_country_code"] == "US"
@@ -77,7 +87,7 @@ class TestDSABeneficiaryDetection:
                 
                 result = await get_account_info(account_id="act_invalid")
                 
-                # Handle response format - could be dict or JSON string
+                # Handle new return format (dictionary instead of JSON string)
                 if isinstance(result, dict):
                     result_data = result
                 else:
@@ -85,6 +95,60 @@ class TestDSABeneficiaryDetection:
                 
                 # Verify error is properly handled
                 assert "error" in result_data
+    
+    @pytest.mark.asyncio
+    async def test_account_info_requires_account_id(self):
+        """Test that get_account_info requires an account_id parameter"""
+        
+        with patch('meta_ads_mcp.core.api.get_current_access_token', new_callable=AsyncMock) as mock_auth:
+            mock_auth.return_value = "test_access_token"
+            
+            # Test without account_id parameter
+            result = await get_account_info()
+            
+            # Handle new return format (dictionary instead of JSON string)
+            if isinstance(result, dict):
+                result_data = result
+            else:
+                result_data = json.loads(result)
+            
+            # Verify error message for missing account_id
+            assert "error" in result_data
+            assert "Account ID is required" in result_data["error"]["message"]
+            assert "Please specify an account_id parameter" in result_data["error"]["details"]
+            assert "example" in result_data["error"]
+    
+    @pytest.mark.asyncio
+    async def test_account_info_inaccessible_account_error(self):
+        """Test that get_account_info provides helpful error for inaccessible accounts"""
+        
+        # Mock accessible accounts response
+        mock_accessible_accounts = {
+            "data": [
+                {"id": "act_123", "name": "Test Account 1"},
+                {"id": "act_456", "name": "Test Account 2"}
+            ]
+        }
+        
+        with patch('meta_ads_mcp.core.accounts.make_api_request', new_callable=AsyncMock) as mock_api:
+            with patch('meta_ads_mcp.core.api.get_current_access_token', new_callable=AsyncMock) as mock_auth:
+                mock_auth.return_value = "test_access_token"
+                mock_api.return_value = mock_accessible_accounts
+                
+                result = await get_account_info(account_id="act_inaccessible")
+                
+                # Handle new return format (dictionary instead of JSON string)
+                if isinstance(result, dict):
+                    result_data = result
+                else:
+                    result_data = json.loads(result)
+                
+                # Verify helpful error message for inaccessible account
+                assert "error" in result_data
+                assert "not accessible to your user account" in result_data["error"]["message"]
+                assert "accessible_accounts" in result_data["error"]
+                assert "suggestion" in result_data["error"]
+                assert len(result_data["error"]["accessible_accounts"]) == 2
 
 
 class TestDSABeneficiaryParameter: