mcp-google-ads 1.1.0 → 1.2.2

package/dist/index.js

@@ -12,6 +12,32 @@ import {
 } from "@modelcontextprotocol/sdk/types.js";
 import { tools } from "./tools.js";
 import { validateRsa } from "./validateRsa.js";
+import {
+  validateRemoveInput,
+  buildRemovePreview,
+  orderRemovalsChildUp,
+  normalizeRemoveArgs,
+  coerceStringArray
+} from "./removeHelpers.js";
+import {
+  normalizeUpdateAssetUrlsArgs,
+  normalizePauseAssetLinksArgs,
+  buildUpdateUrlsDryRun,
+  buildPauseLinksDryRun
+} from "./assetHelpers.js";
+import {
+  buildCampaignCreatePayload
+} from "./campaignBuilder.js";
+import {
+  buildAdGroupCreatePayload
+} from "./adGroupBuilder.js";
+import {
+  prepareImageForUpload
+} from "./imageAsset.js";
+import {
+  validateDemandGenAd,
+  buildDemandGenAdPayload
+} from "./validateDemandGenAd.js";
 import { GoogleAdsApi, enums } from "google-ads-api";
 import { readFileSync, existsSync } from "fs";
 import v8 from "v8";
@@ -113,6 +139,16 @@ import {
   validateResolvedCredentials
 } from "./credentials.js";
 import { onPosixSignal } from "./platform.js";
+function mimeToAssetMimeEnum(mime) {
+  switch (mime) {
+    case "image/png":
+      return enums.MimeType.IMAGE_PNG;
+    case "image/jpeg":
+      return enums.MimeType.IMAGE_JPEG;
+    case "image/gif":
+      return enums.MimeType.IMAGE_GIF;
+  }
+}
 class GoogleAdsManager {
   api;
   config;
@@ -426,6 +462,21 @@ class GoogleAdsManager {
           }
           break;
         }
+        case "asset": {
+          const customer = this.getCustomer(customerId);
+          const customerAssetLabels = customer.customerAssetLabels || customer.assetLabels;
+          if (customerAssetLabels?.create) {
+            const ops = resourceNames.map((rn) => ({ asset: rn, label: labelRN }));
+            try {
+              await withResilience(() => customerAssetLabels.create(ops), "labelAssets");
+            } catch (e) {
+              console.error(`[WARN] asset labeling failed: ${e.message}`);
+            }
+          } else {
+            console.error(`[INFO] customerAssetLabels endpoint not available \u2014 skipping auto-label for asset`);
+          }
+          break;
+        }
       }
       return labelName;
     } catch (e) {
@@ -497,53 +548,125 @@ class GoogleAdsManager {
       };
     }
   }
-  // Create a campaign (paused by default)
+  // Create a campaign (paused by default). Supports SEARCH (back-compat) and
+  // DEMAND_GEN channels, plus richer bidding strategies, geo/language targeting,
+  // and start/end dates. The pure payload shape is built by
+  // buildCampaignCreatePayload (see campaignBuilder.ts) so it can be unit-tested
+  // independently of the live API.
   async createCampaign(customerId, campaign) {
     const customer = this.getCustomer(customerId);
+    const cleanId = customerId.replace(/-/g, "");
+    const plan = buildCampaignCreatePayload(campaign);
     const budgetResult = await withResilience(
-      () => customer.campaignBudgets.create([{
-        name: `${campaign.name} Budget`,
-        amount_micros: campaign.budget_amount_micros,
-        delivery_method: enums.BudgetDeliveryMethod.STANDARD
-      }]),
+      () => customer.campaignBudgets.create([plan.budget]),
       "createCampaign.budget"
     );
     const budgetResourceName = budgetResult.results[0].resource_name;
     const campaignResult = await withResilience(
       () => customer.campaigns.create([{
-        name: campaign.name,
-        status: enums.CampaignStatus.PAUSED,
-        // Always create paused
-        advertising_channel_type: enums.AdvertisingChannelType.SEARCH,
-        campaign_budget: budgetResourceName,
-        manual_cpc: {}
-        // Default to manual CPC
+        ...plan.campaign,
+        campaign_budget: budgetResourceName
       }]),
       "createCampaign"
     );
     const campaignRNs = (campaignResult.results || []).map((r) => r.resource_name).filter(Boolean);
+    if (plan.criteria.length > 0 && campaignRNs.length > 0) {
+      const campaignResourceName = campaignRNs[0];
+      const criterionPayloads = plan.criteria.map((c) => ({
+        ...c,
+        campaign: campaignResourceName
+      }));
+      await withResilience(
+        () => customer.campaignCriteria.create(criterionPayloads),
+        "createCampaign.criteria"
+      );
+    }
     await this.autoLabelCreated(customerId, campaignRNs, "campaign");
     return campaignResult;
   }
-  // Create an ad group (paused by default)
+  // Create an ad group (paused by default). Supports SEARCH_STANDARD (default,
+  // back-compat) and DEMAND_GEN_MULTI_ASSET_AD_GROUP. DG path flows through
+  // mutateResources because the v23 client enum map is missing the DG value;
+  // see adGroupBuilder.ts for details.
   async createAdGroup(customerId, adGroup) {
     const customer = this.getCustomer(customerId);
-    const result = await withResilience(
-      () => customer.adGroups.create([{
-        name: adGroup.name,
-        campaign: `customers/${customerId.replace(/-/g, "")}/campaigns/${adGroup.campaign_id}`,
-        status: enums.AdGroupStatus.PAUSED,
-        // Always create paused
-        cpc_bid_micros: adGroup.cpc_bid_micros || 1e6,
-        // $1.00 default
-        type: enums.AdGroupType.SEARCH_STANDARD
-      }]),
-      "createAdGroup"
-    );
+    const cleanId = customerId.replace(/-/g, "");
+    const payload = buildAdGroupCreatePayload({
+      customer_id_clean: cleanId,
+      name: adGroup.name,
+      campaign_id: adGroup.campaign_id,
+      cpc_bid_micros: adGroup.cpc_bid_micros,
+      type: adGroup.type
+    });
+    let result;
+    if (adGroup.type === "DEMAND_GEN_MULTI_ASSET_AD_GROUP") {
+      const mutateResp = await withResilience(
+        () => customer.mutateResources([
+          {
+            entity: "ad_group",
+            operation: "create",
+            resource: payload
+          }
+        ]),
+        "createAdGroup.demandGen"
+      );
+      result = {
+        results: (mutateResp.mutate_operation_responses || []).map((r) => r.ad_group_result).filter(Boolean)
+      };
+    } else {
+      result = await withResilience(
+        () => customer.adGroups.create([payload]),
+        "createAdGroup"
+      );
+    }
     const adGroupRNs = (result.results || []).map((r) => r.resource_name).filter(Boolean);
     await this.autoLabelCreated(customerId, adGroupRNs, "ad_group");
     return result;
   }
+  // Create an image asset for use in Demand Gen (or other image-capable) ads.
+  // Validates mime type (PNG/JPEG/GIF), size (≤5MB), and min dimensions (600x314)
+  // before hitting the API. Auto-labels the created asset.
+  async createImageAsset(customerId, input) {
+    const prepared = prepareImageForUpload(input);
+    if (!prepared.valid) {
+      throw new Error("Image validation failed:\n" + prepared.errors.join("\n"));
+    }
+    const customer = this.getCustomer(customerId);
+    const result = await withResilience(
+      () => customer.assets.create([
+        {
+          name: input.name,
+          type: enums.AssetType.IMAGE,
+          image_asset: {
+            data: prepared.bytes,
+            file_size: prepared.bytes.length,
+            mime_type: mimeToAssetMimeEnum(prepared.mime_type),
+            full_size: {
+              width_pixels: prepared.width,
+              height_pixels: prepared.height,
+              url: ""
+            }
+          }
+        }
+      ]),
+      "createImageAsset"
+    );
+    const results = result.results || [];
+    const resourceName = results[0]?.resource_name;
+    const assetId = resourceName ? resourceName.split("/").pop() : void 0;
+    if (resourceName) {
+      await this.autoLabelCreated(customerId, [resourceName], "asset");
+    }
+    return {
+      asset_id: assetId,
+      resource_name: resourceName,
+      name: input.name,
+      bytes: prepared.bytes.length,
+      mime_type: prepared.mime_type,
+      width: prepared.width,
+      height: prepared.height
+    };
+  }
   // Create a responsive search ad (paused by default)
   async createResponsiveSearchAd(customerId, ad) {
     const customer = this.getCustomer(customerId);
@@ -593,6 +716,68 @@ class GoogleAdsManager {
     await this.autoLabelCreated(customerId, adRNs, "ad");
     return result;
   }
+  // Create a Demand Gen multi-asset ad (paused by default). Validates character
+  // limits and count caps before hitting the API. Fails fast if the ad_group
+  // isn't a DEMAND_GEN_MULTI_ASSET_AD_GROUP. Uses mutateResources because the
+  // v23 typed helper doesn't know about DG ad types.
+  async createDemandGenMultiAssetAd(customerId, input) {
+    const validation = validateDemandGenAd(input);
+    if (!validation.valid) {
+      throw new Error("Demand Gen ad validation failed:\n" + validation.errors.join("\n"));
+    }
+    const customer = this.getCustomer(customerId);
+    const cleanId = customerId.replace(/-/g, "");
+    const agRows = await withResilience(
+      () => customer.query(
+        `SELECT ad_group.id, ad_group.type FROM ad_group WHERE ad_group.id = ${sanitizeNumericId(
+          input.ad_group_id
+        )}`
+      ),
+      "createDemandGenMultiAssetAd.adGroupLookup"
+    );
+    if (!agRows || agRows.length === 0) {
+      throw new Error(`Ad group ${input.ad_group_id} not found`);
+    }
+    const agType = agRows[0]?.ad_group?.type;
+    const isDgAdGroup = agType === 21 || agType === "DEMAND_GEN_MULTI_ASSET_AD_GROUP" || agType === "21";
+    if (!isDgAdGroup) {
+      throw new Error(
+        `Ad group ${input.ad_group_id} has type '${agType}', not DEMAND_GEN_MULTI_ASSET_AD_GROUP. Use google_ads_create_ad_group with type=DEMAND_GEN_MULTI_ASSET_AD_GROUP first.`
+      );
+    }
+    const payload = buildDemandGenAdPayload({
+      customer_id_clean: cleanId,
+      ad_group_id: input.ad_group_id,
+      input
+    });
+    const mutateResp = await withResilience(
+      () => customer.mutateResources([
+        {
+          entity: "ad_group_ad",
+          operation: "create",
+          resource: payload
+        }
+      ]),
+      "createDemandGenMultiAssetAd"
+    );
+    const adGroupAdResult = (mutateResp.mutate_operation_responses || []).map((r) => r.ad_group_ad_result).filter(Boolean)[0];
+    const resourceName = adGroupAdResult?.resource_name;
+    if (resourceName) {
+      await this.autoLabelCreated(customerId, [resourceName], "ad");
+      for (const lbl of input.labels ?? []) {
+        try {
+          const labelRN = await this.ensureLabelExists(customerId, lbl);
+          await this.labelAdGroupAds(customerId, [resourceName], labelRN);
+        } catch (e) {
+          console.error(`[WARN] extra label '${lbl}' failed: ${e.message}`);
+        }
+      }
+    }
+    return {
+      resource_name: resourceName,
+      ad_id: resourceName ? resourceName.split("~").pop() : void 0
+    };
+  }
   // Create keywords (paused by default, auto-labeled for discoverability)
   async createKeywords(customerId, keywords) {
     const customer = this.getCustomer(customerId);
@@ -709,64 +894,167 @@ class GoogleAdsManager {
     const result = await withResilience(() => customer.adGroupCriteria.remove(resourceNames), "removeAdGroupNegativeKeywords");
     return result;
   }
-  // Enable ads (requires approval in MCP)
-  async enableAds(customerId, adIds) {
+  // Enable ads (auto-labels with today's Claude-MM-DD-YY + any custom labels)
+  async enableAds(customerId, adIds, labels) {
     const customer = this.getCustomer(customerId);
-    const operations = adIds.map((adId) => ({
-      resource_name: `customers/${customerId.replace(/-/g, "")}/adGroupAds/${adId}`,
+    const resourceNames = adIds.map(
+      (adId) => `customers/${customerId.replace(/-/g, "")}/adGroupAds/${adId}`
+    );
+    const operations = resourceNames.map((rn) => ({
+      resource_name: rn,
       status: enums.AdGroupAdStatus.ENABLED
     }));
     const result = await withResilience(() => customer.adGroupAds.update(operations), "enableAds");
+    await this.autoLabelCreated(customerId, resourceNames, "ad");
+    await this.applyCustomLabels(customerId, resourceNames, "ad", labels);
     return result;
   }
-  // Enable ad groups
-  async enableAdGroups(customerId, adGroupIds) {
+  // Enable ad groups (auto-labels with today's Claude-MM-DD-YY + any custom labels)
+  async enableAdGroups(customerId, adGroupIds, labels) {
     const customer = this.getCustomer(customerId);
-    const operations = adGroupIds.map((id) => ({
-      resource_name: `customers/${customerId.replace(/-/g, "")}/adGroups/${id}`,
+    const resourceNames = adGroupIds.map(
+      (id) => `customers/${customerId.replace(/-/g, "")}/adGroups/${id}`
+    );
+    const operations = resourceNames.map((rn) => ({
+      resource_name: rn,
       status: enums.AdGroupStatus.ENABLED
     }));
     const result = await withResilience(() => customer.adGroups.update(operations), "enableAdGroups");
+    await this.autoLabelCreated(customerId, resourceNames, "ad_group");
+    await this.applyCustomLabels(customerId, resourceNames, "ad_group", labels);
     return result;
   }
-  // Enable campaigns
-  async enableCampaigns(customerId, campaignIds) {
+  // Enable campaigns (auto-labels with today's Claude-MM-DD-YY + any custom labels)
+  async enableCampaigns(customerId, campaignIds, labels) {
     const customer = this.getCustomer(customerId);
-    const operations = campaignIds.map((id) => ({
-      resource_name: `customers/${customerId.replace(/-/g, "")}/campaigns/${id}`,
+    const resourceNames = campaignIds.map(
+      (id) => `customers/${customerId.replace(/-/g, "")}/campaigns/${id}`
+    );
+    const operations = resourceNames.map((rn) => ({
+      resource_name: rn,
       status: enums.CampaignStatus.ENABLED
     }));
     const result = await withResilience(() => customer.campaigns.update(operations), "enableCampaigns");
+    await this.autoLabelCreated(customerId, resourceNames, "campaign");
+    await this.applyCustomLabels(customerId, resourceNames, "campaign", labels);
     return result;
   }
-  // Pause ads
-  async pauseAds(customerId, adIds) {
+  // Apply one or more custom labels to resources of a given asset type.
+  // Best-effort: logs and swallows errors so the calling mutation isn't rolled
+  // back on a labeling failure. Creates labels that don't yet exist.
+  async applyCustomLabels(customerId, resourceNames, assetType, labelNames) {
+    const clean = (labelNames ?? []).map((l) => l?.trim()).filter((l) => !!l);
+    if (clean.length === 0 || resourceNames.length === 0) return;
+    for (const labelName of clean) {
+      try {
+        const labelRN = await this.ensureLabelExists(customerId, labelName);
+        switch (assetType) {
+          case "campaign":
+            await this.labelCampaigns(customerId, resourceNames, labelRN);
+            break;
+          case "ad_group":
+            await this.labelAdGroups(customerId, resourceNames, labelRN);
+            break;
+          case "ad":
+            await this.labelAdGroupAds(customerId, resourceNames, labelRN);
+            break;
+          case "keyword":
+            await this.labelAdGroupCriteria(customerId, resourceNames, labelRN);
+            break;
+        }
+      } catch (e) {
+        console.error(`[WARN] applyCustomLabels(${assetType}, '${labelName}') failed: ${e.message}`);
+      }
+    }
+  }
+  // Pause ads (auto-labels with today's Claude-MM-DD-YY + any custom labels)
+  async pauseAds(customerId, adIds, labels) {
     const customer = this.getCustomer(customerId);
-    const operations = adIds.map((adId) => ({
-      resource_name: `customers/${customerId.replace(/-/g, "")}/adGroupAds/${adId}`,
+    const resourceNames = adIds.map(
+      (adId) => `customers/${customerId.replace(/-/g, "")}/adGroupAds/${adId}`
+    );
+    const operations = resourceNames.map((rn) => ({
+      resource_name: rn,
       status: enums.AdGroupAdStatus.PAUSED
     }));
     const result = await withResilience(() => customer.adGroupAds.update(operations), "pauseAds");
+    await this.autoLabelCreated(customerId, resourceNames, "ad");
+    await this.applyCustomLabels(customerId, resourceNames, "ad", labels);
     return result;
   }
-  // Pause ad groups
-  async pauseAdGroups(customerId, adGroupIds) {
+  // Pause ad groups (auto-labels with today's Claude-MM-DD-YY + any custom labels)
+  async pauseAdGroups(customerId, adGroupIds, labels) {
     const customer = this.getCustomer(customerId);
-    const operations = adGroupIds.map((id) => ({
-      resource_name: `customers/${customerId.replace(/-/g, "")}/adGroups/${id}`,
+    const resourceNames = adGroupIds.map(
+      (id) => `customers/${customerId.replace(/-/g, "")}/adGroups/${id}`
+    );
+    const operations = resourceNames.map((rn) => ({
+      resource_name: rn,
       status: enums.AdGroupStatus.PAUSED
     }));
     const result = await withResilience(() => customer.adGroups.update(operations), "pauseAdGroups");
+    await this.autoLabelCreated(customerId, resourceNames, "ad_group");
+    await this.applyCustomLabels(customerId, resourceNames, "ad_group", labels);
     return result;
   }
-  // Pause campaigns
-  async pauseCampaigns(customerId, campaignIds) {
+  // Pause campaigns (auto-labels with today's Claude-MM-DD-YY + any custom labels)
+  async pauseCampaigns(customerId, campaignIds, labels) {
     const customer = this.getCustomer(customerId);
-    const operations = campaignIds.map((id) => ({
-      resource_name: `customers/${customerId.replace(/-/g, "")}/campaigns/${id}`,
+    const resourceNames = campaignIds.map(
+      (id) => `customers/${customerId.replace(/-/g, "")}/campaigns/${id}`
+    );
+    const operations = resourceNames.map((rn) => ({
+      resource_name: rn,
       status: enums.CampaignStatus.PAUSED
     }));
     const result = await withResilience(() => customer.campaigns.update(operations), "pauseCampaigns");
+    await this.autoLabelCreated(customerId, resourceNames, "campaign");
+    await this.applyCustomLabels(customerId, resourceNames, "campaign", labels);
+    return result;
+  }
+  // Remove ads permanently. Reports on removed ads still work.
+  async removeAds(customerId, adIds) {
+    const customer = this.getCustomer(customerId);
+    const cleanId = customerId.replace(/-/g, "");
+    const resourceNames = adIds.map((id) => `customers/${cleanId}/adGroupAds/${id}`);
+    return withResilience(() => customer.adGroupAds.remove(resourceNames), "removeAds");
+  }
+  // Remove ad groups permanently. Cascades to child ads.
+  async removeAdGroups(customerId, adGroupIds) {
+    const customer = this.getCustomer(customerId);
+    const cleanId = customerId.replace(/-/g, "");
+    const resourceNames = adGroupIds.map((id) => `customers/${cleanId}/adGroups/${id}`);
+    return withResilience(() => customer.adGroups.remove(resourceNames), "removeAdGroups");
+  }
+  // Remove campaigns permanently. Cascades to child ad groups and ads.
+  async removeCampaigns(customerId, campaignIds) {
+    const customer = this.getCustomer(customerId);
+    const cleanId = customerId.replace(/-/g, "");
+    const resourceNames = campaignIds.map((id) => `customers/${cleanId}/campaigns/${id}`);
+    return withResilience(() => customer.campaigns.remove(resourceNames), "removeCampaigns");
+  }
+  // Attach a label to existing resources without changing status.
+  // Unlike applyCustomLabels (which swallows errors to protect a parent mutation),
+  // this surfaces errors to the caller so label-first-then-remove can abort cleanly.
+  async applyLabel(customerId, label, targets) {
+    const cleanId = customerId.replace(/-/g, "");
+    const labelRN = await this.ensureLabelExists(customerId, label);
+    const result = { label, label_resource_name: labelRN };
+    if (targets.campaignIds?.length) {
+      const rns = targets.campaignIds.map((id) => `customers/${cleanId}/campaigns/${id}`);
+      await this.labelCampaigns(customerId, rns, labelRN);
+      result.campaigns_labeled = rns.length;
+    }
+    if (targets.adGroupIds?.length) {
+      const rns = targets.adGroupIds.map((id) => `customers/${cleanId}/adGroups/${id}`);
+      await this.labelAdGroups(customerId, rns, labelRN);
+      result.ad_groups_labeled = rns.length;
+    }
+    if (targets.adIds?.length) {
+      const rns = targets.adIds.map((id) => `customers/${cleanId}/adGroupAds/${id}`);
+      await this.labelAdGroupAds(customerId, rns, labelRN);
+      result.ads_labeled = rns.length;
+    }
     return result;
   }
   // Update campaign tracking parameters (final_url_suffix, tracking_url_template, custom params)
@@ -788,6 +1076,163 @@ class GoogleAdsManager {
     const result = await withResilience(() => customer.campaigns.update([campaignUpdate]), "updateCampaignTracking");
     return result;
   }
+  // Update campaign bidding strategy (and/or target CPA / target ROAS).
+  // If `strategy` is omitted, the current strategy is preserved and only the target is updated.
+  async updateCampaignBidding(customerId, campaignId, updates) {
+    const customer = this.getCustomer(customerId);
+    const cleanId = customerId.replace(/-/g, "");
+    const [current] = await withResilience(
+      () => customer.query(`
+          SELECT campaign.id, campaign.name, campaign.bidding_strategy_type
+          FROM campaign
+          WHERE campaign.id = ${campaignId}
+        `),
+      "updateCampaignBidding.query"
+    );
+    if (!current?.campaign?.name) {
+      throw new Error(`Campaign ${campaignId} not found`);
+    }
+    const currentTypeEnum = current.campaign.bidding_strategy_type;
+    const typeEnumToName = {
+      2: "MANUAL_CPC",
+      6: "MAXIMIZE_CONVERSIONS",
+      8: "TARGET_CPA",
+      9: "TARGET_ROAS",
+      10: "MAXIMIZE_CONVERSIONS",
+      11: "MAXIMIZE_CONVERSION_VALUE",
+      12: "TARGET_SPEND"
+    };
+    const currentStrategy = typeEnumToName[currentTypeEnum] || "UNKNOWN";
+    const resolvedStrategy = updates.strategy || currentStrategy;
+    const targetCpaMicros = updates.target_cpa_dollars !== void 0 ? Math.round(updates.target_cpa_dollars * 1e6) : void 0;
+    const campaignUpdate = {
+      resource_name: `customers/${cleanId}/campaigns/${campaignId}`
+    };
+    switch (resolvedStrategy) {
+      case "MAXIMIZE_CONVERSIONS":
+        campaignUpdate.maximize_conversions = targetCpaMicros !== void 0 ? { target_cpa_micros: targetCpaMicros } : {};
+        break;
+      case "MAXIMIZE_CONVERSION_VALUE":
+        campaignUpdate.maximize_conversion_value = updates.target_roas !== void 0 ? { target_roas: updates.target_roas } : {};
+        break;
+      case "TARGET_CPA":
+        if (targetCpaMicros === void 0) {
+          throw new Error("TARGET_CPA strategy requires target_cpa_dollars");
+        }
+        campaignUpdate.target_cpa = { target_cpa_micros: targetCpaMicros };
+        break;
+      case "TARGET_ROAS":
+        if (updates.target_roas === void 0) {
+          throw new Error("TARGET_ROAS strategy requires target_roas");
+        }
+        campaignUpdate.target_roas = { target_roas: updates.target_roas };
+        break;
+      case "MANUAL_CPC":
+        campaignUpdate.manual_cpc = {};
+        break;
+      case "MAXIMIZE_CLICKS":
+        campaignUpdate.target_spend = {};
+        break;
+      default:
+        throw new Error(`Unsupported strategy: ${resolvedStrategy}`);
+    }
+    await withResilience(
+      () => customer.campaigns.update([campaignUpdate]),
+      "updateCampaignBidding.update"
+    );
+    return {
+      campaign_id: campaignId,
+      campaign_name: current.campaign.name,
+      previous_strategy: currentStrategy,
+      new_strategy: resolvedStrategy,
+      target_cpa_dollars: updates.target_cpa_dollars,
+      target_roas: updates.target_roas
+    };
+  }
+  async updateAssetUrls(customerId, updates) {
+    const customer = this.getCustomer(customerId);
+    const cleanId = customerId.replace(/-/g, "");
+    const assetIds = updates.map((u) => u.asset_id);
+    const idList = assetIds.join(",");
+    const currentRows = await withResilience(
+      () => customer.query(`
+          SELECT asset.id, asset.name, asset.final_urls, asset.sitelink_asset.link_text
+          FROM asset
+          WHERE asset.id IN (${idList})
+        `),
+      "updateAssetUrls.query"
+    );
+    const byId = /* @__PURE__ */ new Map();
+    for (const row of currentRows) {
+      if (row.asset?.id) byId.set(String(row.asset.id), row.asset);
+    }
+    const missing = assetIds.filter((id) => !byId.has(id));
+    if (missing.length > 0) {
+      throw new Error(`Asset ID(s) not found in customer ${customerId}: ${missing.join(", ")}`);
+    }
+    const operations = updates.map((u) => ({
+      resource_name: `customers/${cleanId}/assets/${u.asset_id}`,
+      final_urls: u.final_urls
+    }));
+    await withResilience(
+      () => customer.assets.update(operations),
+      "updateAssetUrls.update"
+    );
+    return {
+      customer_id: cleanId,
+      updated: updates.map((u) => {
+        const before = byId.get(u.asset_id);
+        return {
+          asset_id: u.asset_id,
+          link_text: before?.sitelink_asset?.link_text ?? null,
+          previous_final_urls: before?.final_urls ?? [],
+          new_final_urls: u.final_urls
+        };
+      })
+    };
+  }
+  async pauseAssetLinks(customerId, resourceNames) {
+    const customer = this.getCustomer(customerId);
+    const cleanId = customerId.replace(/-/g, "");
+    const byLevel = {
+      customer_asset: [],
+      campaign_asset: [],
+      ad_group_asset: []
+    };
+    for (const rn of resourceNames) {
+      if (/\/customerAssets\//.test(rn)) byLevel.customer_asset.push(rn);
+      else if (/\/campaignAssets\//.test(rn)) byLevel.campaign_asset.push(rn);
+      else if (/\/adGroupAssets\//.test(rn)) byLevel.ad_group_asset.push(rn);
+      else throw new Error(`Unrecognized asset-link resource name: ${rn}`);
+    }
+    const PAUSED = 2;
+    const result = { customer_id: cleanId, paused: { customer_asset: 0, campaign_asset: 0, ad_group_asset: 0 } };
+    if (byLevel.customer_asset.length > 0) {
+      const ops = byLevel.customer_asset.map((rn) => ({ resource_name: rn, status: PAUSED }));
+      await withResilience(
+        () => customer.customerAssets.update(ops),
+        "pauseAssetLinks.customerAssets"
+      );
+      result.paused.customer_asset = ops.length;
+    }
+    if (byLevel.campaign_asset.length > 0) {
+      const ops = byLevel.campaign_asset.map((rn) => ({ resource_name: rn, status: PAUSED }));
+      await withResilience(
+        () => customer.campaignAssets.update(ops),
+        "pauseAssetLinks.campaignAssets"
+      );
+      result.paused.campaign_asset = ops.length;
+    }
+    if (byLevel.ad_group_asset.length > 0) {
+      const ops = byLevel.ad_group_asset.map((rn) => ({ resource_name: rn, status: PAUSED }));
+      await withResilience(
+        () => customer.adGroupAssets.update(ops),
+        "pauseAssetLinks.adGroupAssets"
+      );
+      result.paused.ad_group_asset = ops.length;
+    }
+    return result;
+  }
   // ============================================
   // REPORTING METHODS
   // ============================================
@@ -1305,7 +1750,15 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
         }
         const result = await adsManager.createCampaign(customerId, {
           name: sanitizedName,
-          budget_amount_micros: Math.round(daily_budget * 1e6)
+          budget_amount_micros: Math.round(daily_budget * 1e6),
+          channel_type: args?.channel_type,
+          bidding_strategy: args?.bidding_strategy,
+          target_cpa: args?.target_cpa,
+          target_cpc_cap: args?.target_cpc_cap,
+          geo_target_ids: args?.geo_target_ids,
+          language_id: args?.language_id,
+          start_date: args?.start_date,
+          end_date: args?.end_date
         });
         return {
           content: [{
@@ -1323,7 +1776,8 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
         const result = await adsManager.createAdGroup(customerId, {
           name: args?.name,
           campaign_id: args?.campaign_id,
-          cpc_bid_micros: args?.cpc_bid ? Math.round(args.cpc_bid * 1e6) : void 0
+          cpc_bid_micros: args?.cpc_bid ? Math.round(args.cpc_bid * 1e6) : void 0,
+          type: args?.type
         });
         return {
           content: [{
@@ -1414,15 +1868,16 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             }]
           };
         }
+        const labels = args?.labels;
         const results = {};
         if (hasCampaignIds) {
-          results.campaigns = await adsManager.enableCampaigns(customerId, args.campaign_ids);
+          results.campaigns = await adsManager.enableCampaigns(customerId, args.campaign_ids, labels);
         }
         if (hasAdGroupIds) {
-          results.adGroups = await adsManager.enableAdGroups(customerId, args.ad_group_ids);
+          results.adGroups = await adsManager.enableAdGroups(customerId, args.ad_group_ids, labels);
         }
         if (hasAdIds) {
-          results.ads = await adsManager.enableAds(customerId, args.ad_ids);
+          results.ads = await adsManager.enableAds(customerId, args.ad_ids, labels);
         }
         return {
           content: [{
@@ -1448,15 +1903,16 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             }]
           };
         }
+        const labels = args?.labels;
         const results = {};
         if (hasCampaignIds) {
-          results.campaigns = await adsManager.pauseCampaigns(customerId, args.campaign_ids);
+          results.campaigns = await adsManager.pauseCampaigns(customerId, args.campaign_ids, labels);
         }
         if (hasAdGroupIds) {
-          results.adGroups = await adsManager.pauseAdGroups(customerId, args.ad_group_ids);
+          results.adGroups = await adsManager.pauseAdGroups(customerId, args.ad_group_ids, labels);
         }
         if (hasAdIds) {
-          results.ads = await adsManager.pauseAds(customerId, args.ad_ids);
+          results.ads = await adsManager.pauseAds(customerId, args.ad_ids, labels);
         }
         return {
           content: [{
@@ -1469,6 +1925,81 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
           }]
         };
       }
+      case "google_ads_remove_items": {
+        const removeArgs = normalizeRemoveArgs(args);
+        const customerId = removeArgs.customer_id ?? "";
+        const validation = validateRemoveInput(removeArgs);
+        if (!validation.ok) {
+          return { content: [{ type: "text", text: JSON.stringify({ error: validation.error }, null, 2) }] };
+        }
+        if (removeArgs.confirm !== true) {
+          return {
+            content: [{ type: "text", text: JSON.stringify(buildRemovePreview(removeArgs), null, 2) }]
+          };
+        }
+        const autoLabel = adsManager.todayClaudeLabel ? adsManager.todayClaudeLabel() : void 0;
+        const allLabels = [autoLabel, ...removeArgs.labels ?? []].filter(
+          (l) => typeof l === "string" && !!l
+        );
+        const labelResults = [];
+        for (const labelName of allLabels) {
+          try {
+            const r = await adsManager.applyLabel(customerId, labelName, {
+              campaignIds: removeArgs.campaign_ids,
+              adGroupIds: removeArgs.ad_group_ids,
+              adIds: removeArgs.ad_ids
+            });
+            labelResults.push(r);
+          } catch (e) {
+            return {
+              content: [{
+                type: "text",
+                text: JSON.stringify({
+                  error: `Label attach failed before removal: ${e.message}. Nothing removed.`,
+                  partial_labels_applied: labelResults
+                }, null, 2)
+              }]
+            };
+          }
+        }
+        const steps = orderRemovalsChildUp(removeArgs);
+        const removed = {};
+        for (const step of steps) {
+          if (step.type === "ads") {
+            removed.ads = await adsManager.removeAds(customerId, step.ids);
+          } else if (step.type === "ad_groups") {
+            removed.ad_groups = await adsManager.removeAdGroups(customerId, step.ids);
+          } else {
+            removed.campaigns = await adsManager.removeCampaigns(customerId, step.ids);
+          }
+        }
+        return {
+          content: [{
+            type: "text",
+            text: JSON.stringify({
+              success: true,
+              message: "Items removed. Reports on removed resources remain queryable.",
+              labels_applied: allLabels,
+              removed
+            }, null, 2)
+          }]
+        };
+      }
+      case "google_ads_apply_label": {
+        const customerId = args?.customer_id ?? "";
+        const label = args?.label;
+        if (!label) {
+          return { content: [{ type: "text", text: JSON.stringify({ error: "label is required" }, null, 2) }] };
+        }
+        const result = await adsManager.applyLabel(customerId, label, {
+          campaignIds: coerceStringArray(args?.campaign_ids),
+          adGroupIds: coerceStringArray(args?.ad_group_ids),
+          adIds: coerceStringArray(args?.ad_ids)
+        });
+        return {
+          content: [{ type: "text", text: JSON.stringify({ success: true, ...result }, null, 2) }]
+        };
+      }
       case "google_ads_update_campaign_tracking": {
         const customerId = args?.customer_id || "";
         const campaignId = args?.campaign_id;
@@ -1852,6 +2383,72 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
           }]
         };
       }
+      case "google_ads_update_campaign_bidding": {
+        const customerId = args?.customer_id || "";
+        const campaignId = args?.campaign_id;
+        const strategy = args?.strategy;
+        const targetCpaDollars = args?.target_cpa_dollars;
+        const targetRoas = args?.target_roas;
+        if (strategy === void 0 && targetCpaDollars === void 0 && targetRoas === void 0) {
+          return {
+            content: [{
+              type: "text",
+              text: JSON.stringify({ error: "Must provide at least one of: strategy, target_cpa_dollars, target_roas" }, null, 2)
+            }]
+          };
+        }
+        if (targetCpaDollars !== void 0 && targetCpaDollars <= 0) {
+          return {
+            content: [{
+              type: "text",
+              text: JSON.stringify({ error: "target_cpa_dollars must be positive" }, null, 2)
+            }]
+          };
+        }
+        if (targetRoas !== void 0 && targetRoas <= 0) {
+          return {
+            content: [{
+              type: "text",
+              text: JSON.stringify({ error: "target_roas must be positive (decimal, e.g., 3.0 = 300%)" }, null, 2)
+            }]
+          };
+        }
+        const result = await adsManager.updateCampaignBidding(customerId, campaignId, {
+          strategy,
+          target_cpa_dollars: targetCpaDollars,
+          target_roas: targetRoas
+        });
+        return {
+          content: [{
+            type: "text",
+            text: JSON.stringify({ success: true, ...result }, null, 2)
+          }]
+        };
+      }
+      case "google_ads_update_asset_urls": {
+        const normalized = normalizeUpdateAssetUrlsArgs(args);
+        if ("error" in normalized) {
+          return { content: [{ type: "text", text: JSON.stringify({ error: normalized.error }, null, 2) }] };
+        }
+        if (!normalized.confirm) {
+          return { content: [{ type: "text", text: JSON.stringify(buildUpdateUrlsDryRun(normalized), null, 2) }] };
+        }
+        const customerId = normalized.customer_id || "";
+        const result = await adsManager.updateAssetUrls(customerId, normalized.updates);
+        return { content: [{ type: "text", text: JSON.stringify({ success: true, ...result }, null, 2) }] };
+      }
+      case "google_ads_pause_asset_links": {
+        const normalized = normalizePauseAssetLinksArgs(args);
+        if ("error" in normalized) {
+          return { content: [{ type: "text", text: JSON.stringify({ error: normalized.error }, null, 2) }] };
+        }
+        if (!normalized.confirm) {
+          return { content: [{ type: "text", text: JSON.stringify(buildPauseLinksDryRun(normalized), null, 2) }] };
+        }
+        const customerId = normalized.customer_id || "";
+        const result = await adsManager.pauseAssetLinks(customerId, normalized.resource_names);
+        return { content: [{ type: "text", text: JSON.stringify({ success: true, ...result }, null, 2) }] };
+      }
       case "google_ads_gaql_query": {
         const customerId = args?.customer_id || "";
         const query = args?.query;
@@ -1893,6 +2490,65 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
           }]
         };
       }
+      case "google_ads_create_demand_gen_multi_asset_ad": {
+        const customerId = args?.customer_id || "";
+        try {
+          const result = await adsManager.createDemandGenMultiAssetAd(customerId, {
+            ad_group_id: args?.ad_group_id,
+            final_urls: args?.final_urls,
+            business_name: args?.business_name,
+            call_to_action: args?.call_to_action,
+            marketing_image_asset_ids: args?.marketing_image_asset_ids,
+            square_marketing_image_asset_ids: args?.square_marketing_image_asset_ids,
+            portrait_marketing_image_asset_ids: args?.portrait_marketing_image_asset_ids,
+            logo_image_asset_ids: args?.logo_image_asset_ids,
+            headlines: args?.headlines,
+            long_headlines: args?.long_headlines,
+            descriptions: args?.descriptions,
+            labels: args?.labels
+          });
+          return {
+            content: [{
+              type: "text",
+              text: JSON.stringify({
+                success: true,
+                message: "Demand Gen multi-asset ad created (PAUSED). Review in Google Ads before enabling.",
+                ...result
+              }, null, 2)
+            }]
+          };
+        } catch (e) {
+          return {
+            content: [{
+              type: "text",
+              text: JSON.stringify({ success: false, error: e.message }, null, 2)
+            }]
+          };
+        }
+      }
+      case "google_ads_create_image_asset": {
+        const customerId = args?.customer_id || "";
+        try {
+          const result = await adsManager.createImageAsset(customerId, {
+            name: args?.name,
+            file_path: args?.file_path,
+            base64_data: args?.base64_data
+          });
+          return {
+            content: [{
+              type: "text",
+              text: JSON.stringify({ success: true, ...result }, null, 2)
+            }]
+          };
+        } catch (e) {
+          return {
+            content: [{
+              type: "text",
+              text: JSON.stringify({ success: false, error: e.message }, null, 2)
+            }]
+          };
+        }
+      }
       default:
         throw new Error(`Unknown tool: ${name}`);
     }