adloop 0.29.2__tar.gz → 0.30.0__tar.gz

{adloop-0.29.2 → adloop-0.30.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: adloop
-Version: 0.29.2
+Version: 0.30.0
 Summary: The AI command center for Google Ads, Reddit Ads, GA4, and tracking code.
 Keywords: mcp,google-ads,reddit-ads,google-analytics,ga4,cursor,marketing
 Author: Daniel Klose
@@ -136,6 +136,7 @@ The best features come from real workflows. If you're using AdLoop and find your
 | `get_asset_group_signals` | A PMax asset group's search themes and audience signal, plus the audiences available for it |
 | `get_detailed_asset_performance` | Top-performing asset combinations — which headline+description+image combos Google selects most |
 | `get_audience_performance` | Audience segment performance — remarketing, in-market, affinity, demographics |
+| `get_shopping_product_performance` | Spend, conversions, CPA and ROAS per product across Shopping and Performance Max, plus products that spent without converting |
 | `get_change_history` | What changed before the drop: who changed what and when, through which client (UI, API, scripts, auto-applied recommendations), last 30 days |
 | `get_demographic_targeting` | List demographic criteria (age/gender/parental status/income) on an ad group or campaign |
 | `get_audience_lists` | The account's remarketing and customer lists (size, eligibility, open/closed), custom and combined segments |
@@ -239,6 +240,7 @@ The Google account also needs **Edit** permission on the container (and **Publis
 |------|-------------|
 | `list_merchant_accounts` | Discover accessible Merchant Center accounts |
 | `get_merchant_feed_health` | Feed health — approved/pending/disapproved counts per reporting context, top product issues with docs, account-level issues. Disapprovals silently starve Shopping/PMax. |
+| `get_merchant_product_issues` | The products behind the feed-health counts: which are disapproved, limited or pending, and each issue with its attribute and affected countries |
 
 > **Setup for Merchant Center tools** — Enable the **Merchant API** in your GCP project (the Content API for Shopping is deprecated). The Merchant API has no read-only scope; AdLoop uses it strictly read-only. Upgrading OAuth users re-authorize once.
 

{adloop-0.29.2 → adloop-0.30.0}/README.md

@@ -108,6 +108,7 @@ The best features come from real workflows. If you're using AdLoop and find your
 | `get_asset_group_signals` | A PMax asset group's search themes and audience signal, plus the audiences available for it |
 | `get_detailed_asset_performance` | Top-performing asset combinations — which headline+description+image combos Google selects most |
 | `get_audience_performance` | Audience segment performance — remarketing, in-market, affinity, demographics |
+| `get_shopping_product_performance` | Spend, conversions, CPA and ROAS per product across Shopping and Performance Max, plus products that spent without converting |
 | `get_change_history` | What changed before the drop: who changed what and when, through which client (UI, API, scripts, auto-applied recommendations), last 30 days |
 | `get_demographic_targeting` | List demographic criteria (age/gender/parental status/income) on an ad group or campaign |
 | `get_audience_lists` | The account's remarketing and customer lists (size, eligibility, open/closed), custom and combined segments |
@@ -211,6 +212,7 @@ The Google account also needs **Edit** permission on the container (and **Publis
 |------|-------------|
 | `list_merchant_accounts` | Discover accessible Merchant Center accounts |
 | `get_merchant_feed_health` | Feed health — approved/pending/disapproved counts per reporting context, top product issues with docs, account-level issues. Disapprovals silently starve Shopping/PMax. |
+| `get_merchant_product_issues` | The products behind the feed-health counts: which are disapproved, limited or pending, and each issue with its attribute and affected countries |
 
 > **Setup for Merchant Center tools** — Enable the **Merchant API** in your GCP project (the Content API for Shopping is deprecated). The Merchant API has no read-only scope; AdLoop uses it strictly read-only. Upgrading OAuth users re-authorize once.
 

{adloop-0.29.2 → adloop-0.30.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "adloop"
-version = "0.29.2"
+version = "0.30.0"
 description = "The AI command center for Google Ads, Reddit Ads, GA4, and tracking code."
 readme = "README.md"
 requires-python = ">=3.11"

{adloop-0.29.2 → adloop-0.30.0}/pyproject.toml.orig

@@ -1,6 +1,6 @@
 [project]
 name = "adloop"
-version = "0.29.2"
+version = "0.30.0"
 description = "The AI command center for Google Ads, Reddit Ads, GA4, and tracking code."
 readme = "README.md"
 authors = [

{adloop-0.29.2 → adloop-0.30.0}/src/adloop/ads/shopping.py

@@ -282,3 +282,131 @@ def apply_create_shopping_campaign(client: object, cid: str, changes: dict) -> d
             "with enable_entity(entity_type='campaign')."
         ),
     }
+
+
+# ---------------------------------------------------------------------------
+# Product performance (Shopping and Performance Max)
+# ---------------------------------------------------------------------------
+
+_MAX_PRODUCT_ROWS = 10000
+
+
+def get_shopping_product_performance(
+    config: AdLoopConfig,
+    *,
+    customer_id: str = "",
+    date_range_start: str = "",
+    date_range_end: str = "",
+    campaign_id: str = "",
+    limit: int = 50,
+) -> dict:
+    """Spend, clicks, conversions and value per product across Shopping and PMax.
+
+    Reads shopping_performance_view and sums each product (item id) over
+    the campaigns it ran in. Returns the top products by spend with CPA and
+    ROAS, plus the products that spent without converting.
+    """
+    from adloop.ads.currency import get_currency_code
+    from adloop.ads.gaql import execute_query
+    from adloop.ads.read import _date_clause
+
+    campaign_id = str(campaign_id or "").strip()
+    if campaign_id and not campaign_id.isdigit():
+        return {"error": "campaign_id must be a numeric Google Ads id"}
+    limit = max(1, min(int(limit or 50), 200))
+    campaign_filter = f"AND campaign.id = {campaign_id} " if campaign_id else ""
+    rows = execute_query(
+        config,
+        customer_id,
+        "SELECT segments.product_item_id, segments.product_title, segments.product_brand, campaign.id, "
+        "campaign.name, campaign.advertising_channel_type, metrics.impressions, metrics.clicks, "
+        "metrics.cost_micros, metrics.conversions, metrics.conversions_value FROM shopping_performance_view "
+        f"WHERE metrics.impressions > 0 {campaign_filter}{_date_clause(date_range_start, date_range_end)} "
+        f"ORDER BY metrics.cost_micros DESC LIMIT {_MAX_PRODUCT_ROWS}",
+    )
+    currency = get_currency_code(config, customer_id)
+
+    products: dict[str, dict] = {}
+    for row in rows:
+        item = str(row.get("segments.product_item_id") or "").strip()
+        if not item:
+            continue
+        product = products.setdefault(item, {
+            "item_id": item,
+            "title": row.get("segments.product_title") or "",
+            "brand": row.get("segments.product_brand") or "",
+            "campaigns": set(),
+            "channels": set(),
+            "impressions": 0, "clicks": 0, "cost_micros": 0, "conversions": 0.0, "conversions_value": 0.0,
+        })
+        product["campaigns"].add(row.get("campaign.name") or str(row.get("campaign.id")))
+        product["channels"].add(str(row.get("campaign.advertising_channel_type") or ""))
+        product["impressions"] += int(row.get("metrics.impressions") or 0)
+        product["clicks"] += int(row.get("metrics.clicks") or 0)
+        product["cost_micros"] += int(row.get("metrics.cost_micros") or 0)
+        product["conversions"] += float(row.get("metrics.conversions") or 0)
+        product["conversions_value"] += float(row.get("metrics.conversions_value") or 0)
+
+    out = []
+    for p in products.values():
+        cost = p["cost_micros"] / 1_000_000
+        out.append({
+            "item_id": p["item_id"],
+            "title": p["title"],
+            "brand": p["brand"],
+            "campaigns": sorted(p["campaigns"]),
+            "channels": sorted(c for c in p["channels"] if c),
+            "impressions": p["impressions"],
+            "clicks": p["clicks"],
+            "cost": round(cost, 2),
+            "conversions": round(p["conversions"], 2),
+            "conversions_value": round(p["conversions_value"], 2),
+            "cpa": round(cost / p["conversions"], 2) if p["conversions"] else None,
+            "roas": round(p["conversions_value"] / cost, 2) if cost and p["conversions_value"] else None,
+        })
+    out.sort(key=lambda p: p["cost"], reverse=True)
+
+    total_cost = round(sum(p["cost"] for p in out), 2)
+    total_value = round(sum(p["conversions_value"] for p in out), 2)
+    totals = {
+        "products": len(out),
+        "cost": total_cost,
+        "clicks": sum(p["clicks"] for p in out),
+        "conversions": round(sum(p["conversions"] for p in out), 2),
+        "conversions_value": total_value,
+        "roas": round(total_value / total_cost, 2) if total_cost and total_value else None,
+        "currency": currency,
+    }
+    # Spenders without a conversion, from the products that took at least
+    # 1% of the spend (a few cents on one product is noise).
+    threshold = max(total_cost * 0.01, 0.01)
+    no_conversions = [p for p in out if p["conversions"] == 0 and p["cost"] >= threshold]
+    insights = []
+    if not out:
+        insights.append(
+            "No Shopping or Performance Max product data in this period: the account has no product ads "
+            "running, or the campaigns did not serve."
+        )
+    if no_conversions:
+        wasted = round(sum(p["cost"] for p in no_conversions), 2)
+        insights.append(
+            f"{len(no_conversions)} product(s) spent {wasted} {currency} without a conversion. Check the "
+            "landing page and price first; in Performance Max, draft_pmax_product_exclusions can take "
+            "the worst ones out, in Shopping a lower product bid."
+        )
+    if totals["roas"] is not None:
+        weak = [p for p in out if p["roas"] is not None and p["roas"] < totals["roas"] / 2 and p["cost"] >= threshold]
+        if weak:
+            insights.append(
+                f"{len(weak)} converting product(s) return less than half the account's ROAS ({totals['roas']})."
+            )
+    if len(rows) >= _MAX_PRODUCT_ROWS:
+        insights.append("The period has more product rows than one report returns; narrow the dates or pass campaign_id.")
+
+    return {
+        "date_range": {"start": date_range_start or "LAST_30_DAYS", "end": date_range_end or ""},
+        "totals": totals,
+        "products": out[:limit],
+        "no_conversion_spenders": no_conversions[:20],
+        "insights": insights,
+    }

{adloop-0.29.2 → adloop-0.30.0}/src/adloop/merchant/client.py

@@ -22,6 +22,8 @@ _BASE = "https://merchantapi.googleapis.com"
 # states its sub-API and API_ACCOUNTS is only the default.
 API_ACCOUNTS = "accounts/v1"
 API_ISSUE_RESOLUTION = "issueresolution/v1"
+# Product-level reporting (MCQL queries over product_view and friends).
+API_REPORTS = "reports/v1"
 
 # Google blocks every Merchant API call from a GCP project that is not
 # registered as a developer with the merchant account (401 UNAUTHENTICATED,

{adloop-0.29.2 → adloop-0.30.0}/src/adloop/merchant/read.py

@@ -124,27 +124,9 @@ def get_merchant_feed_health(
         register_gcp,
     )
 
-    account_id = str(account_id or "").strip() or config.merchant.account_id.strip()
-    if not account_id:
-        from adloop.runtime import default_setting_hint
-
-        return {
-            "error": (
-                "account_id is required: no Merchant Center account was "
-                "passed and no default is configured."
-            ),
-            "hint": (
-                "Call list_merchant_accounts to find the numeric Merchant "
-                "Center ID and pass it as account_id, or "
-                + default_setting_hint("merchant.account_id", "Settings → Google & accounts")
-                + "."
-            ),
-        }
-    if not account_id.isdigit():
-        return {
-            "error": "account_id must be a numeric Merchant Center ID — "
-                     "call list_merchant_accounts first."
-        }
+    account_id, error = _account_or_error(config, account_id)
+    if error:
+        return error
 
     def _fetch() -> tuple[dict, dict]:
         return (
@@ -245,3 +227,176 @@ def get_merchant_feed_health(
         "top_item_issues": top_item_issues[:15],
         "insights": insights,
     }
+
+
+# ---------------------------------------------------------------------------
+# Product-level issues (Reports API, product_view)
+# ---------------------------------------------------------------------------
+
+_STATUS_FILTERS = {
+    "disapproved": "NOT_ELIGIBLE_OR_DISAPPROVED",
+    "limited": "ELIGIBLE_LIMITED",
+    "pending": "PENDING",
+}
+_CLICK_ORDER = {"HIGH": 0, "MEDIUM": 1, "LOW": 2}
+_MAX_PRODUCTS = 200
+
+
+def _account_or_error(config: AdLoopConfig, account_id: str) -> tuple[str, dict | None]:
+    account_id = str(account_id or "").strip() or config.merchant.account_id.strip()
+    if not account_id:
+        from adloop.runtime import default_setting_hint
+
+        return "", {
+            "error": "account_id is required: no Merchant Center account was passed and no default is configured.",
+            "hint": (
+                "Call list_merchant_accounts to find the numeric Merchant Center ID and pass it as account_id, or "
+                + default_setting_hint("merchant.account_id", "Settings → Google & accounts")
+                + "."
+            ),
+        }
+    if not account_id.isdigit():
+        return "", {"error": "account_id must be a numeric Merchant Center ID — call list_merchant_accounts first."}
+    return account_id, None
+
+
+def _issue_entry(issue: dict) -> dict:
+    severity = issue.get("severity") or {}
+    contexts = [
+        {
+            "reporting_context": ctx.get("reportingContext", ""),
+            "disapproved_countries": ctx.get("disapprovedCountries", []) or [],
+            "demoted_countries": ctx.get("demotedCountries", []) or [],
+        }
+        for ctx in severity.get("severityPerReportingContext", []) or []
+    ]
+    return {
+        "code": (issue.get("type") or {}).get("code", ""),
+        "attribute": (issue.get("type") or {}).get("canonicalAttribute", ""),
+        "severity": severity.get("aggregatedSeverity", ""),
+        "resolution": issue.get("resolution", ""),
+        "where": contexts,
+    }
+
+
+def get_merchant_product_issues(
+    config: AdLoopConfig,
+    *,
+    account_id: str = "",
+    status: str = "disapproved",
+    issue_code: str = "",
+    limit: int = 50,
+) -> dict:
+    """The products behind the feed-health counts, with each product's issues.
+
+    Queries product_view through the Reports API: offer id, title, brand,
+    status, click potential and item issues (code, attribute, severity per
+    reporting context with the affected countries, and whether the merchant
+    has to act). Products with high click potential come first, because
+    fixing them recovers the most traffic.
+    """
+    from adloop.merchant.client import API_REPORTS, MerchantNotRegistered, merchant_post, register_gcp
+
+    account_id, error = _account_or_error(config, account_id)
+    if error:
+        return error
+    if status not in (*_STATUS_FILTERS, "any"):
+        return {"error": "status must be disapproved (default), limited, pending or any"}
+    limit = max(1, min(int(limit or 50), _MAX_PRODUCTS))
+    issue_code = str(issue_code or "").strip()
+
+    where = f" WHERE aggregated_reporting_context_status = '{_STATUS_FILTERS[status]}'" if status in _STATUS_FILTERS else ""
+    query = (
+        "SELECT id, offer_id, title, brand, feed_label, availability, click_potential, "
+        f"aggregated_reporting_context_status, item_issues FROM product_view{where}"
+    )
+
+    def _fetch() -> dict:
+        return merchant_post(
+            config,
+            f"accounts/{account_id}/reports:search",
+            {"query": query, "pageSize": 1000},
+            api=API_REPORTS,
+        )
+
+    try:
+        payload = _fetch()
+    except MerchantNotRegistered:
+        try:
+            register_gcp(config, account_id)
+        except Exception as e:
+            return _registration_failed(account_id, e)
+        try:
+            payload = _fetch()
+        except MerchantNotRegistered:
+            return _registered_retry_later(account_id)
+
+    products = []
+    by_code: dict[str, dict] = {}
+    for row in payload.get("results", []) or []:
+        view = row.get("productView") or {}
+        issues = [_issue_entry(i) for i in view.get("itemIssues", []) or []]
+        if status == "any" and not issues:
+            continue
+        if issue_code and not any(i["code"] == issue_code for i in issues):
+            continue
+        product = {
+            "offer_id": view.get("offerId", ""),
+            "product_id": view.get("id", ""),
+            "title": view.get("title", ""),
+            "brand": view.get("brand", ""),
+            "feed_label": view.get("feedLabel", ""),
+            "availability": view.get("availability", ""),
+            "status": view.get("aggregatedReportingContextStatus", ""),
+            "click_potential": view.get("clickPotential", ""),
+            "issues": issues,
+        }
+        products.append(product)
+        for issue in issues:
+            entry = by_code.setdefault(issue["code"], {
+                "code": issue["code"],
+                "attribute": issue["attribute"],
+                "severity": issue["severity"],
+                "merchant_action": issue["resolution"] == "MERCHANT_ACTION",
+                "products": 0,
+            })
+            entry["products"] += 1
+    products.sort(key=lambda p: (_CLICK_ORDER.get(p["click_potential"], 3), p["title"]))
+    summary = sorted(by_code.values(), key=lambda e: e["products"], reverse=True)
+
+    insights = []
+    if not products:
+        insights.append(
+            f"No products with status {status}." if status != "any" else "No product has an item issue."
+        )
+    high = [p for p in products if p["click_potential"] == "HIGH"]
+    if high and status == "disapproved":
+        insights.append(
+            f"{len(high)} disapproved product(s) have HIGH click potential: fixing them recovers the most traffic first."
+        )
+    if summary:
+        top = summary[0]
+        insights.append(
+            f"Most common issue: {top['code']}"
+            + (f" on attribute {top['attribute']}" if top["attribute"] else "")
+            + f" ({top['products']} product(s))."
+        )
+    waiting = [e["code"] for e in summary if not e["merchant_action"]]
+    if waiting:
+        insights.append(
+            "Pending Google's processing, nothing to do yet: " + ", ".join(waiting[:5]) + "."
+        )
+    if payload.get("nextPageToken"):
+        insights.append("More than 1,000 products matched; narrow with issue_code to see the rest.")
+
+    return {
+        "account_id": account_id,
+        "status": status,
+        "products": products[:limit],
+        "shown": min(limit, len(products)),
+        "matched": len(products),
+        "issues_by_code": summary[:20],
+        "insights": insights,
+        "note": "Product data lags about 30 minutes behind feed changes.",
+    }
+

{adloop-0.29.2 → adloop-0.30.0}/src/adloop/rules/adloop.md

@@ -57,6 +57,7 @@ You have access to AdLoop MCP tools that connect Google Ads, Reddit Ads and Goog
 | `get_pmax_assets` | Per-asset details for PMax — field type, serving status, content. Use with `get_detailed_asset_performance` for quality signals | `campaign_id` (optional) |
 | `get_asset_group_signals` | A PMax asset group's search themes and audience signal (with `signal_id` and approval status), plus the account's audiences that can become its signal | `asset_group_id` |
 | `get_detailed_asset_performance` | Top-performing asset combinations — which headline+description+image combos Google selects most | `campaign_id` (optional) |
+| `get_shopping_product_performance` | Spend, clicks, conversions, CPA and ROAS per product (item id) across Shopping and PMax, plus the products that spent without converting | `date_range_start`, `date_range_end`, `campaign_id` (optional), `limit` |
 | `get_audience_performance` | Audience segment metrics — remarketing, in-market, affinity, demographics | `date_range_start`, `date_range_end`, `campaign_id` (optional) |
 | `get_change_history` | What changed in the account and who changed it: time, user email, client (UI, API, scripts, Editor, auto-applied recommendations), resource type, operation, changed fields, campaign/ad group. The first stop for "what changed before the drop?" (30 days of history) | `date_range_start`, `date_range_end`, `campaign_id` (optional), `resource_types` (optional), `limit` (optional, max 10000) |
 | `get_demographic_targeting` | List current demographic criteria (age/gender/parental status/income) on an ad group or campaign — returns each criterion's `remove_id` for use with `remove_entity` | exactly one of `ad_group_id` or `campaign_id` |
@@ -172,10 +173,12 @@ These tools call both APIs internally and return unified results with computed `
 |------|-------------|----------------|
 | `list_merchant_accounts` | Discovery — which Merchant Center accounts the connected user can reach | (none) |
 | `get_merchant_feed_health` | Shopping/PMax underperforming or dead — check feed disapprovals FIRST, before touching bids/budgets | `account_id` (numeric; from list_merchant_accounts — optional when `merchant.account_id` is configured) |
+| `get_merchant_product_issues` | Which products are disapproved, limited or pending, and why: offer id, title, click potential, and each issue's code, attribute, affected countries and whether the merchant has to act | `account_id`, `status` (disapproved/limited/pending/any), `issue_code`, `limit` |
 
 - **Disapproved feed items are the #1 silent PMax/Shopping killer.** When a Shopping or PMax campaign has impressions collapsing or zero delivery, check `get_merchant_feed_health` before any campaign-side diagnosis.
 - The Merchant API has no read-only scope; AdLoop's merchant tools are read-only by design — never propose feed edits through these tools. Product-status data lags ~30 minutes — say so when the user just changed the feed.
 - Item issues come ranked by affected products and include Google's resolution documentation links — surface the top 3 with their doc links.
+- To name the products behind the counts, call `get_merchant_product_issues`: products with HIGH click potential come first, because fixing them recovers the most traffic. `issues_by_code` groups the products per issue; an issue whose resolution is `PENDING_PROCESSING` needs no action, Google is still reviewing. Filter with `issue_code` to list every product of one issue (e.g. all missing GTINs) for the user to fix in the feed.
 
 ### Reddit Ads Read Tools
 
@@ -465,7 +468,7 @@ Most websites (especially in the EU) use a GDPR cookie consent banner. This has
 
 ### When user wants a Shopping campaign
 
-1. `list_merchant_accounts` for the Merchant Center id, then `get_merchant_feed_health`: a feed with many disapproved products needs fixing first, a campaign cannot advertise them
+1. `list_merchant_accounts` for the Merchant Center id, then `get_merchant_feed_health`: a feed with many disapproved products needs fixing first, a campaign cannot advertise them; `get_merchant_product_issues` names those products and their issues
 2. The Merchant Center account must be linked to the Google Ads account (Merchant Center → Settings → Apps and services); `draft_shopping_campaign` checks it and says which accounts are linked
 3. Ask for countries if not stated. Shopping takes no language targeting and no keywords: the feed's language applies, and search terms are controlled with negative keywords after launch
 4. Bidding: MANUAL_CPC with a modest `product_bid` to start, TARGET_ROAS once the account has conversion value history, TARGET_SPEND (Maximize clicks) to gather data quickly. `product_bid` is always required (Google sets it on the product group)
@@ -606,6 +609,7 @@ Reddit's structure is campaign → ad group (budget, bid, pixel, targeting) →
    - Ensure asset diversity: at least 5 headlines, 5 descriptions, 5 marketing images (landscape AND square), a logo, ideally a YouTube video. The preview's `counts_after` shows the result per type
    - Signals: `get_asset_group_signals`, then `draft_asset_group_signals` to add search themes (what customers search for the products) or set an audience signal. Signals guide PMax; they do not restrict it
    - Products that must not be advertised (out of stock, low margin, a brand you may not advertise): `draft_pmax_product_exclusions` with the COMPLETE list of excluded item ids, brands or custom labels. Check `get_merchant_feed_health` first: disapproved products are a feed problem, not an exclusion
+   - Which products earn and which only spend: `get_shopping_product_performance`. Its `no_conversion_spenders` are the candidates to check (landing page, price, stock) before excluding them; one or two weeks without a conversion can be normal for expensive products
    - Pause an underperforming asset group with `pause_entity(entity_type="asset_group")` rather than removing it
    - Check that final URLs point to relevant, working landing pages
 6. New PMax campaigns cannot be built through AdLoop yet (the campaign, asset group and full asset set have to be created in one request); building them stays a job for Google Ads. Editing existing ones works as above.

{adloop-0.29.2 → adloop-0.30.0}/src/adloop/server.py

@@ -1221,6 +1221,39 @@ def get_merchant_feed_health(account_id: str = "") -> dict:
     return _impl(current_config(), account_id=account_id)
 
 
+@_tool(title="Merchant Center product issues", annotations=_READONLY, tags={"merchant"})
+@_safe
+def get_merchant_product_issues(
+    account_id: str = "",
+    status: str = "disapproved",
+    issue_code: str = "",
+    limit: int = 50,
+) -> dict:
+    """The products behind the feed-health counts, each with its issues.
+
+    Lists products by status with offer id, title, brand, click potential
+    and every item issue: its code, the attribute it concerns, severity per
+    reporting context with the affected countries, and whether the
+    merchant has to act or Google is still processing. Products with high
+    click potential come first, because fixing them recovers the most
+    traffic. issues_by_code counts the products per issue. Data lags feed
+    changes by about 30 minutes.
+
+    Args:
+        account_id: Numeric Merchant Center ID from list_merchant_accounts.
+            Defaults to merchant.account_id in the config.
+        status: "disapproved" (default, not serving), "limited" (serving
+            with restrictions), "pending" (still in review) or "any"
+            (every product with at least one issue).
+        issue_code: Only products with this issue code (from
+            issues_by_code or get_merchant_feed_health).
+        limit: Maximum number of products to return (1-200, default 50).
+    """
+    from adloop.merchant.read import get_merchant_product_issues as _impl
+
+    return _impl(current_config(), account_id=account_id, status=status, issue_code=issue_code, limit=limit)
+
+
 @_tool(title="List Google Ads accounts", annotations=_READONLY, tags={"ads"})
 @_safe
 def list_accounts(limit: int = 200) -> dict:
@@ -2805,6 +2838,42 @@ def draft_audience_attachment(
     )
 
 
+@_tool(title="Shopping product performance", annotations=_READONLY, tags={"ads"})
+@_safe
+def get_shopping_product_performance(
+    date_range_start: str = "",
+    date_range_end: str = "",
+    campaign_id: str = "",
+    limit: int = 50,
+    customer_id: str = "",
+) -> dict:
+    """Spend, clicks, conversions, CPA and ROAS per product across Shopping and Performance Max.
+
+    Each product (item id) is summed over the campaigns it ran in. Returns
+    the account totals, the top products by spend, and the products that
+    spent without a conversion, with insights on what to do with them.
+
+    Args:
+        date_range_start: Start date "YYYY-MM-DD". Both dates empty means
+            the last 30 days.
+        date_range_end: End date "YYYY-MM-DD" (inclusive).
+        campaign_id: Optional numeric campaign id to limit the report to.
+        limit: Maximum number of products to return (1-200, default 50).
+        customer_id: Google Ads customer ID (digits, dashes optional).
+            Defaults to the configured account.
+    """
+    from adloop.ads.shopping import get_shopping_product_performance as _impl
+
+    return _impl(
+        current_config(),
+        customer_id=customer_id or current_config().ads.customer_id,
+        date_range_start=date_range_start,
+        date_range_end=date_range_end,
+        campaign_id=campaign_id,
+        limit=limit,
+    )
+
+
 @_tool(title="Asset group signals", annotations=_READONLY, tags={"ads"})
 @_safe
 def get_asset_group_signals(asset_group_id: str, customer_id: str = "") -> dict: