mcp-google-ads 1.4.2 → 1.5.0

package/dist/index.js

@@ -28,11 +28,22 @@ import {
   normalizeUpdateAssetUrlsArgs,
   normalizePauseAssetLinksArgs,
   buildUpdateUrlsDryRun,
-  buildPauseLinksDryRun
+  buildPauseLinksDryRun,
+  normalizeCreateSitelinkArgs,
+  buildCreateSitelinkDryRun,
+  normalizeReplaceSitelinkArgs,
+  buildReplaceSitelinkDryRun
 } from "./assetHelpers.js";
 import {
   buildCampaignCreatePayload
 } from "./campaignBuilder.js";
+import {
+  buildExperimentPayload,
+  buildControlArmPayload,
+  buildTreatmentArmPayload,
+  experimentIdFromResourceName,
+  campaignIdFromResourceName
+} from "./experimentBuilder.js";
 import {
   buildAdGroupCreatePayload
 } from "./adGroupBuilder.js";
@@ -45,6 +56,7 @@ import {
   isDemandGenAdGroup
 } from "./validateDemandGenAd.js";
 import { GoogleAdsApi, enums } from "google-ads-api";
+import { buildAdGroupAdResourceName } from "./resourceNames.js";
 import { readFileSync, existsSync } from "fs";
 import v8 from "v8";
 const __cliPkg = JSON.parse(readFileSync(join(__moduleDir, "..", "package.json"), "utf-8"));
@@ -434,7 +446,7 @@ class GoogleAdsManager {
     const mm = String(now.getMonth() + 1).padStart(2, "0");
     const dd = String(now.getDate()).padStart(2, "0");
     const yy = String(now.getFullYear()).slice(-2);
-    return `Claude-${mm}-${dd}-${yy}`;
+    return `claude-${mm}-${dd}-${yy}`;
   }
   // Apply today's Claude-MM-DD-YY label to newly created assets.
   // Best-effort: log and swallow errors so creation never fails because of labeling.
@@ -568,13 +580,25 @@ class GoogleAdsManager {
       "createCampaign.budget"
     );
     const budgetResourceName = budgetResult.results[0].resource_name;
-    const campaignResult = await withResilience(
-      () => customer.campaigns.create([{
-        ...plan.campaign,
-        campaign_budget: budgetResourceName
-      }]),
-      "createCampaign"
-    );
+    const campaignPayload = { ...plan.campaign, campaign_budget: budgetResourceName };
+    const isDemandGen = plan.campaign.advertising_channel_type === 14;
+    let campaignResult;
+    if (isDemandGen) {
+      const mutateResp = await withResilience(
+        () => customer.mutateResources([
+          { entity: "campaign", operation: "create", resource: campaignPayload }
+        ]),
+        "createCampaign"
+      );
+      campaignResult = {
+        results: (mutateResp.mutate_operation_responses || []).map((r) => r.campaign_result).filter(Boolean)
+      };
+    } else {
+      campaignResult = await withResilience(
+        () => customer.campaigns.create([campaignPayload]),
+        "createCampaign"
+      );
+    }
     const campaignRNs = (campaignResult.results || []).map((r) => r.resource_name).filter(Boolean);
     if (plan.criteria.length > 0 && campaignRNs.length > 0) {
       const campaignResourceName = campaignRNs[0];
@@ -819,6 +843,18 @@ class GoogleAdsManager {
     const result = await withResilience(() => customer.adGroupCriteria.update(operations), "pauseKeywords");
     return result;
   }
+  // Enable keywords (auto-labels with today's Claude-MM-DD-YY + any custom labels)
+  async enableKeywords(customerId, criterionResourceNames, labels) {
+    const customer = this.getCustomer(customerId);
+    const operations = criterionResourceNames.map((rn) => ({
+      resource_name: rn,
+      status: enums.AdGroupCriterionStatus.ENABLED
+    }));
+    const result = await withResilience(() => customer.adGroupCriteria.update(operations), "enableKeywords");
+    await this.autoLabelCreated(customerId, criterionResourceNames, "keyword");
+    await this.applyCustomLabels(customerId, criterionResourceNames, "keyword", labels);
+    return result;
+  }
   // Create a new shared negative keyword list at account level
   async createSharedSet(customerId, name) {
     const customer = this.getCustomer(customerId);
@@ -888,6 +924,44 @@ class GoogleAdsManager {
     const result = await withResilience(() => customer.campaignCriteria.create(criteria), "addCampaignNegativeKeywords");
     return result;
   }
+  // Add location (geo) targeting criteria at the AD GROUP level.
+  // Required for Demand Gen campaigns — DG sets location at ad group, not campaign.
+  // Uses string type "LOCATION" (integer 77) — not in v23 enum map, same pattern
+  // as DEMAND_GEN_MULTI_ASSET_AD_GROUP and EuPoliticalAdvertising fixes.
+  async setAdGroupLocationTargeting(customerId, adGroupId, geoTargetIds) {
+    const customer = this.getCustomer(customerId);
+    const cleanId = customerId.replace(/-/g, "");
+    const adGroupRN = `customers/${cleanId}/adGroups/${adGroupId}`;
+    const criteria = geoTargetIds.map((id) => ({
+      ad_group: adGroupRN,
+      type: "LOCATION",
+      location: { geo_target_constant: `geoTargetConstants/${id}` }
+    }));
+    const result = await withResilience(
+      () => customer.adGroupCriteria.create(criteria),
+      "setAdGroupLocationTargeting"
+    );
+    return result;
+  }
+  // Add location (geo) targeting criteria to an existing campaign.
+  // Uses mutateResources (not campaignCriteria.create) because the v23 typed
+  // path doesn't recognize the `location` criterion field — same pattern as
+  // DEMAND_GEN campaign/ad-group creation.
+  async setCampaignLocationTargeting(customerId, campaignId, geoTargetIds) {
+    const customer = this.getCustomer(customerId);
+    const cleanId = customerId.replace(/-/g, "");
+    const campaignRN = `customers/${cleanId}/campaigns/${campaignId}`;
+    const criteria = geoTargetIds.map((id) => ({
+      campaign: campaignRN,
+      type: "LOCATION",
+      location: { geo_target_constant: `geoTargetConstants/${id}` }
+    }));
+    const result = await withResilience(
+      () => customer.campaignCriteria.create(criteria),
+      "setCampaignLocationTargeting"
+    );
+    return result;
+  }
   // Remove campaign-level negative keywords by resource name
   async removeCampaignNegativeKeywords(customerId, resourceNames) {
     const customer = this.getCustomer(customerId);
@@ -900,12 +974,43 @@ class GoogleAdsManager {
     const result = await withResilience(() => customer.adGroupCriteria.remove(resourceNames), "removeAdGroupNegativeKeywords");
     return result;
   }
+  // Resolve plain ad IDs to the composite ad_group_ad resource name
+  // (`customers/{cid}/adGroupAds/{adGroupId}~{adId}`) required by every
+  // adGroupAd mutation and label endpoint. Passing just `{adId}` is a
+  // Google Ads API error — this helper fixes that by looking up the
+  // adGroupId for each adId via GAQL in a single query.
+  async resolveAdGroupAdResourceNames(customerId, adIds) {
+    if (!adIds || adIds.length === 0) return [];
+    const cleanId = customerId.replace(/-/g, "");
+    const customer = this.getCustomer(customerId);
+    const sanitized = adIds.map((id) => sanitizeNumericId(String(id)));
+    const query = `SELECT ad_group.id, ad_group_ad.ad.id FROM ad_group_ad WHERE ad_group_ad.ad.id IN (${sanitized.join(",")})`;
+    const rows = await withResilience(
+      () => customer.query(query),
+      "resolveAdGroupAdResourceNames"
+    );
+    const resolved = [];
+    const foundIds = /* @__PURE__ */ new Set();
+    for (const row of rows) {
+      const adGroupId = row?.ad_group?.id;
+      const adId = row?.ad_group_ad?.ad?.id;
+      if (adGroupId != null && adId != null) {
+        resolved.push(buildAdGroupAdResourceName(cleanId, adGroupId, adId));
+        foundIds.add(String(adId));
+      }
+    }
+    const missing = sanitized.filter((id) => !foundIds.has(id));
+    if (missing.length > 0) {
+      throw new Error(
+        `Could not resolve ad_group_id for ${missing.length}/${adIds.length} ad IDs: ${missing.join(", ")}`
+      );
+    }
+    return resolved;
+  }
   // 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 resourceNames = adIds.map(
-      (adId) => `customers/${customerId.replace(/-/g, "")}/adGroupAds/${adId}`
-    );
+    const resourceNames = await this.resolveAdGroupAdResourceNames(customerId, adIds);
     const operations = resourceNames.map((rn) => ({
       resource_name: rn,
       status: enums.AdGroupAdStatus.ENABLED
@@ -976,9 +1081,7 @@ class GoogleAdsManager {
   // 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 resourceNames = adIds.map(
-      (adId) => `customers/${customerId.replace(/-/g, "")}/adGroupAds/${adId}`
-    );
+    const resourceNames = adIds.some((id) => id.startsWith("customers/")) ? adIds : await this.resolveAdGroupAdResourceNames(customerId, adIds);
     const operations = resourceNames.map((rn) => ({
       resource_name: rn,
       status: enums.AdGroupAdStatus.PAUSED
@@ -1021,8 +1124,7 @@ class GoogleAdsManager {
   // 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}`);
+    const resourceNames = await this.resolveAdGroupAdResourceNames(customerId, adIds);
     return withResilience(() => customer.adGroupAds.remove(resourceNames), "removeAds");
   }
   // Remove ad groups permanently. Cascades to child ads.
@@ -1057,7 +1159,7 @@ class GoogleAdsManager {
       result.ad_groups_labeled = rns.length;
     }
     if (targets.adIds?.length) {
-      const rns = targets.adIds.map((id) => `customers/${cleanId}/adGroupAds/${id}`);
+      const rns = await this.resolveAdGroupAdResourceNames(customerId, targets.adIds);
       await this.labelAdGroupAds(customerId, rns, labelRN);
       result.ads_labeled = rns.length;
     }
@@ -1211,7 +1313,7 @@ class GoogleAdsManager {
       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 PAUSED = enums.AssetLinkStatus.PAUSED;
     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 }));
@@ -1240,6 +1342,555 @@ class GoogleAdsManager {
     return result;
   }
   // ============================================
+  // SITELINK CREATE + REPLACE
+  // ============================================
+  async createSitelink(customerId, args) {
+    const customer = this.getCustomer(customerId);
+    const cleanId = customerId.replace(/-/g, "");
+    const sitelink = { link_text: args.link_text };
+    if (args.description1) sitelink.description1 = args.description1;
+    if (args.description2) sitelink.description2 = args.description2;
+    const result = await withResilience(
+      () => customer.assets.create([
+        {
+          type: enums.AssetType.SITELINK,
+          final_urls: args.final_urls,
+          sitelink_asset: sitelink
+        }
+      ]),
+      "createSitelink"
+    );
+    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 {
+      customer_id: cleanId,
+      asset_id: assetId,
+      resource_name: resourceName,
+      link_text: args.link_text,
+      final_urls: args.final_urls,
+      description1: args.description1,
+      description2: args.description2
+    };
+  }
+  async replaceSitelinkUrl(customerId, args) {
+    const customer = this.getCustomer(customerId);
+    const cleanId = customerId.replace(/-/g, "");
+    const oldAssetRows = await withResilience(
+      () => customer.query(`
+          SELECT
+            asset.id,
+            asset.type,
+            asset.final_urls,
+            asset.sitelink_asset.link_text,
+            asset.sitelink_asset.description1,
+            asset.sitelink_asset.description2
+          FROM asset
+          WHERE asset.id = ${args.old_asset_id}
+        `),
+      "replaceSitelinkUrl.queryAsset"
+    );
+    const oldAsset = oldAssetRows[0]?.asset;
+    if (!oldAsset) {
+      throw new Error(`Asset ${args.old_asset_id} not found in customer ${cleanId}`);
+    }
+    if (oldAsset.type !== enums.AssetType.SITELINK && oldAsset.type !== 13) {
+      throw new Error(
+        `Asset ${args.old_asset_id} is type ${oldAsset.type} (not SITELINK). This tool only replaces sitelink assets; use google_ads_update_asset_urls for other asset types.`
+      );
+    }
+    const link_text = args.new_link_text ?? oldAsset.sitelink_asset?.link_text;
+    if (!link_text) {
+      throw new Error(
+        `Old asset has no link_text and none was provided. Pass new_link_text to override.`
+      );
+    }
+    const description1 = args.new_description1 ?? oldAsset.sitelink_asset?.description1 ?? void 0;
+    const description2 = args.new_description2 ?? oldAsset.sitelink_asset?.description2 ?? void 0;
+    const campaignLinksRows = await withResilience(
+      () => customer.query(`
+          SELECT
+            campaign_asset.resource_name,
+            campaign_asset.campaign,
+            campaign_asset.field_type,
+            campaign_asset.status
+          FROM campaign_asset
+          WHERE campaign_asset.asset = 'customers/${cleanId}/assets/${args.old_asset_id}'
+            AND campaign_asset.field_type = 'SITELINK'
+            AND campaign_asset.status = 'ENABLED'
+        `),
+      "replaceSitelinkUrl.queryCampaignAssets"
+    );
+    const adGroupLinksRows = await withResilience(
+      () => customer.query(`
+          SELECT
+            ad_group_asset.resource_name,
+            ad_group_asset.ad_group,
+            ad_group_asset.field_type,
+            ad_group_asset.status
+          FROM ad_group_asset
+          WHERE ad_group_asset.asset = 'customers/${cleanId}/assets/${args.old_asset_id}'
+            AND ad_group_asset.field_type = 'SITELINK'
+            AND ad_group_asset.status = 'ENABLED'
+        `),
+      "replaceSitelinkUrl.queryAdGroupAssets"
+    );
+    const customerLinksRows = await withResilience(
+      () => customer.query(`
+          SELECT
+            customer_asset.resource_name,
+            customer_asset.field_type,
+            customer_asset.status
+          FROM customer_asset
+          WHERE customer_asset.asset = 'customers/${cleanId}/assets/${args.old_asset_id}'
+            AND customer_asset.field_type = 'SITELINK'
+            AND customer_asset.status = 'ENABLED'
+        `),
+      "replaceSitelinkUrl.queryCustomerAssets"
+    );
+    const campaignLinks = campaignLinksRows.map((r) => ({
+      resource_name: r.campaign_asset.resource_name,
+      campaign: r.campaign_asset.campaign
+    }));
+    const adGroupLinks = adGroupLinksRows.map((r) => ({
+      resource_name: r.ad_group_asset.resource_name,
+      ad_group: r.ad_group_asset.ad_group
+    }));
+    const customerLinks = customerLinksRows.map((r) => ({
+      resource_name: r.customer_asset.resource_name
+    }));
+    const newSitelink = { link_text };
+    if (description1) newSitelink.description1 = description1;
+    if (description2) newSitelink.description2 = description2;
+    const createResult = await withResilience(
+      () => customer.assets.create([
+        {
+          type: enums.AssetType.SITELINK,
+          final_urls: args.new_final_urls,
+          sitelink_asset: newSitelink
+        }
+      ]),
+      "replaceSitelinkUrl.createAsset"
+    );
+    const newAssetResource = createResult.results?.[0]?.resource_name;
+    if (!newAssetResource) {
+      throw new Error("Failed to create replacement sitelink asset (no resource_name in response)");
+    }
+    const newAssetId = newAssetResource.split("/").pop() || "";
+    await this.autoLabelCreated(customerId, [newAssetResource], "asset");
+    const SITELINK_FIELD_TYPE = enums.AssetFieldType.SITELINK;
+    if (campaignLinks.length > 0) {
+      await withResilience(
+        () => customer.campaignAssets.create(
+          campaignLinks.map((l) => ({
+            campaign: l.campaign,
+            asset: newAssetResource,
+            field_type: SITELINK_FIELD_TYPE
+          }))
+        ),
+        "replaceSitelinkUrl.createCampaignAssets"
+      );
+    }
+    if (adGroupLinks.length > 0) {
+      await withResilience(
+        () => customer.adGroupAssets.create(
+          adGroupLinks.map((l) => ({
+            ad_group: l.ad_group,
+            asset: newAssetResource,
+            field_type: SITELINK_FIELD_TYPE
+          }))
+        ),
+        "replaceSitelinkUrl.createAdGroupAssets"
+      );
+    }
+    if (customerLinks.length > 0) {
+      await withResilience(
+        () => customer.customerAssets.create(
+          customerLinks.map(() => ({
+            asset: newAssetResource,
+            field_type: SITELINK_FIELD_TYPE
+          }))
+        ),
+        "replaceSitelinkUrl.createCustomerAssets"
+      );
+    }
+    if (campaignLinks.length > 0) {
+      await withResilience(
+        () => customer.campaignAssets.remove(campaignLinks.map((l) => l.resource_name)),
+        "replaceSitelinkUrl.removeCampaignAssets"
+      );
+    }
+    if (adGroupLinks.length > 0) {
+      await withResilience(
+        () => customer.adGroupAssets.remove(adGroupLinks.map((l) => l.resource_name)),
+        "replaceSitelinkUrl.removeAdGroupAssets"
+      );
+    }
+    if (customerLinks.length > 0) {
+      await withResilience(
+        () => customer.customerAssets.remove(customerLinks.map((l) => l.resource_name)),
+        "replaceSitelinkUrl.removeCustomerAssets"
+      );
+    }
+    return {
+      customer_id: cleanId,
+      old_asset_id: args.old_asset_id,
+      new_asset_id: newAssetId,
+      new_asset_resource_name: newAssetResource,
+      link_text,
+      final_urls: args.new_final_urls,
+      description1,
+      description2,
+      relinked: {
+        campaign_assets: campaignLinks.length,
+        ad_group_assets: adGroupLinks.length,
+        customer_assets: customerLinks.length
+      },
+      note: "The old Asset is not deleted; only its ENABLED links were migrated. Paused/removed links on the old asset were left alone."
+    };
+  }
+  // ============================================
+  // AD GROUP RENAME
+  // ============================================
+  async renameAdGroup(customerId, adGroupId, newName) {
+    const customer = this.getCustomer(customerId);
+    const cleanId = customerId.replace(/-/g, "");
+    const resourceName = `customers/${cleanId}/adGroups/${adGroupId}`;
+    await withResilience(
+      () => customer.adGroups.update([{ resource_name: resourceName, name: newName }]),
+      "renameAdGroup"
+    );
+    await this.autoLabelCreated(customerId, [resourceName], "ad_group");
+    return {
+      customer_id: cleanId,
+      ad_group_id: adGroupId,
+      resource_name: resourceName,
+      new_name: newName
+    };
+  }
+  // ============================================
+  // LINK ASSET TO CAMPAIGN
+  // ============================================
+  async linkAssetToCampaign(customerId, args) {
+    const customer = this.getCustomer(customerId);
+    const cleanId = customerId.replace(/-/g, "");
+    const fieldTypeMap = {
+      SITELINK: enums.AssetFieldType.SITELINK,
+      CALLOUT: enums.AssetFieldType.CALLOUT,
+      STRUCTURED_SNIPPET: enums.AssetFieldType.STRUCTURED_SNIPPET
+    };
+    const fieldType = fieldTypeMap[args.field_type.toUpperCase()];
+    if (fieldType === void 0) {
+      throw new Error(
+        `Unknown field_type: "${args.field_type}". Supported values: SITELINK, CALLOUT, STRUCTURED_SNIPPET`
+      );
+    }
+    const assetResource = `customers/${cleanId}/assets/${args.asset_id}`;
+    const operations = args.campaign_ids.map((id) => ({
+      campaign: `customers/${cleanId}/campaigns/${id}`,
+      asset: assetResource,
+      field_type: fieldType
+    }));
+    const result = await withResilience(
+      () => customer.campaignAssets.create(operations),
+      "linkAssetToCampaign"
+    );
+    const results = result.results || [];
+    const resourceNames = results.map((r) => r.resource_name).filter(Boolean);
+    return {
+      customer_id: cleanId,
+      asset_id: args.asset_id,
+      asset_resource_name: assetResource,
+      field_type: args.field_type,
+      campaigns_linked: args.campaign_ids.length,
+      resource_names: resourceNames
+    };
+  }
+  // ============================================
+  // EXPERIMENT METHODS
+  // ============================================
+  async createExperiment(customerId, input) {
+    const customer = this.getCustomer(customerId);
+    const cleanId = customerId.replace(/-/g, "");
+    const trafficSplit = input.traffic_split_percent ?? 50;
+    const experimentPayload = buildExperimentPayload(input);
+    const expResult = await withResilience(
+      () => customer.experiments.create([experimentPayload]),
+      "createExperiment.create"
+    );
+    const expResourceName = expResult.results?.[0]?.resource_name;
+    if (!expResourceName) {
+      throw new Error("Experiment creation returned no resource_name");
+    }
+    const experimentId = experimentIdFromResourceName(expResourceName);
+    const baseCampaignRN = `customers/${cleanId}/campaigns/${input.base_campaign_id}`;
+    const controlArm = buildControlArmPayload(expResourceName, baseCampaignRN, trafficSplit);
+    const treatmentArm = buildTreatmentArmPayload(expResourceName, trafficSplit);
+    const armsResult = await withResilience(
+      () => customer.experimentArms.create([controlArm, treatmentArm]),
+      "createExperiment.arms"
+    );
+    const treatmentArmRN = armsResult.results?.[1]?.resource_name;
+    let treatmentCampaignId = null;
+    if (treatmentArmRN) {
+      const armRows = await withResilience(
+        () => customer.query(`
+          SELECT experiment_arm.resource_name, experiment_arm.in_design_campaigns
+          FROM experiment_arm
+          WHERE experiment_arm.resource_name = '${treatmentArmRN}'
+        `),
+        "createExperiment.queryTreatmentArm"
+      );
+      const inDesign = armRows[0]?.experiment_arm?.in_design_campaigns ?? [];
+      if (inDesign.length > 0) {
+        treatmentCampaignId = campaignIdFromResourceName(inDesign[0]);
+      }
+    }
+    await this.autoLabelCreated(customerId, [expResourceName], "experiment");
+    return {
+      customer_id: cleanId,
+      experiment_id: experimentId,
+      experiment_resource_name: expResourceName,
+      treatment_campaign_id: treatmentCampaignId,
+      name: input.name,
+      traffic_split_percent: trafficSplit,
+      status: "SETUP",
+      note: treatmentCampaignId ? `Treatment campaign ${treatmentCampaignId} created. Use google_ads_update_campaign_ad_urls to change landing pages, then google_ads_schedule_experiment to go live.` : "Treatment campaign not yet available \u2014 query google_ads_get_experiment in a few seconds."
+    };
+  }
+  async listExperiments(customerId, options = {}) {
+    const customer = this.getCustomer(customerId);
+    const statusClause = options.statusFilter && options.statusFilter !== "ALL" ? `AND experiment.status = '${options.statusFilter}'` : `AND experiment.status != 'REMOVED'`;
+    const rows = await withResilience(
+      () => customer.query(`
+        SELECT
+          experiment.resource_name,
+          experiment.experiment_id,
+          experiment.name,
+          experiment.description,
+          experiment.status,
+          experiment.type,
+          experiment.start_date,
+          experiment.end_date,
+          experiment.suffix
+        FROM experiment
+        WHERE experiment.type = 'SEARCH_CUSTOM'
+        ${statusClause}
+        ORDER BY experiment.name
+      `),
+      "listExperiments"
+    );
+    let experiments = rows.map((r) => ({
+      experiment_id: String(r.experiment?.experiment_id ?? ""),
+      resource_name: r.experiment?.resource_name ?? "",
+      name: r.experiment?.name ?? "",
+      description: r.experiment?.description ?? "",
+      status: r.experiment?.status ?? "",
+      start_date: r.experiment?.start_date ?? "",
+      end_date: r.experiment?.end_date ?? "",
+      suffix: r.experiment?.suffix ?? ""
+    }));
+    if (options.campaignId) {
+      const armRows = await withResilience(
+        () => customer.query(`
+          SELECT experiment_arm.experiment, experiment_arm.campaigns, experiment_arm.control
+          FROM experiment_arm
+          WHERE experiment_arm.control = TRUE
+        `),
+        "listExperiments.arms"
+      );
+      const cleanCid = customerId.replace(/-/g, "");
+      const targetRN = `customers/${cleanCid}/campaigns/${options.campaignId}`;
+      const expRNsForCampaign = new Set(
+        armRows.filter((r) => (r.experiment_arm?.campaigns ?? []).includes(targetRN)).map((r) => r.experiment_arm?.experiment)
+      );
+      experiments = experiments.filter((e) => expRNsForCampaign.has(e.resource_name));
+    }
+    return { customer_id: customerId.replace(/-/g, ""), experiments };
+  }
+  async getExperiment(customerId, experimentId) {
+    const customer = this.getCustomer(customerId);
+    const cleanId = customerId.replace(/-/g, "");
+    const expRN = `customers/${cleanId}/experiments/${experimentId}`;
+    const [expRows, armRows] = await Promise.all([
+      withResilience(
+        () => customer.query(`
+          SELECT
+            experiment.resource_name,
+            experiment.experiment_id,
+            experiment.name,
+            experiment.description,
+            experiment.status,
+            experiment.type,
+            experiment.start_date,
+            experiment.end_date,
+            experiment.suffix
+          FROM experiment
+          WHERE experiment.resource_name = '${expRN}'
+        `),
+        "getExperiment.exp"
+      ),
+      withResilience(
+        () => customer.query(`
+          SELECT
+            experiment_arm.resource_name,
+            experiment_arm.name,
+            experiment_arm.control,
+            experiment_arm.traffic_split,
+            experiment_arm.campaigns,
+            experiment_arm.in_design_campaigns
+          FROM experiment_arm
+          WHERE experiment_arm.experiment = '${expRN}'
+        `),
+        "getExperiment.arms"
+      )
+    ]);
+    if (expRows.length === 0) {
+      throw new Error(`Experiment ${experimentId} not found`);
+    }
+    const exp = expRows[0].experiment;
+    const arms = armRows.map((r) => {
+      const arm = r.experiment_arm;
+      const isControl = arm?.control ?? false;
+      const campaigns = arm?.campaigns ?? [];
+      const inDesignCampaigns = arm?.in_design_campaigns ?? [];
+      return {
+        name: arm?.name ?? "",
+        control: isControl,
+        traffic_split: arm?.traffic_split ?? 0,
+        campaign_ids: campaigns.map(campaignIdFromResourceName),
+        treatment_campaign_ids: inDesignCampaigns.map(campaignIdFromResourceName)
+      };
+    });
+    const treatmentArm = arms.find((a) => !a.control);
+    const treatmentCampaignId = treatmentArm?.treatment_campaign_ids?.[0] ?? null;
+    return {
+      experiment_id: String(exp?.experiment_id ?? experimentId),
+      resource_name: exp?.resource_name ?? expRN,
+      name: exp?.name ?? "",
+      description: exp?.description ?? "",
+      status: exp?.status ?? "",
+      start_date: exp?.start_date ?? "",
+      end_date: exp?.end_date ?? "",
+      suffix: exp?.suffix ?? "",
+      arms,
+      treatment_campaign_id: treatmentCampaignId
+    };
+  }
+  async scheduleExperiment(customerId, experimentId) {
+    const customer = this.getCustomer(customerId);
+    const cleanId = customerId.replace(/-/g, "");
+    const expRN = `customers/${cleanId}/experiments/${experimentId}`;
+    await withResilience(
+      () => customer.experiments.scheduleExperiment({ resource_name: expRN }),
+      "scheduleExperiment"
+    );
+    return { customer_id: cleanId, experiment_id: experimentId, status: "SCHEDULED" };
+  }
+  async endExperiment(customerId, experimentId) {
+    const customer = this.getCustomer(customerId);
+    const cleanId = customerId.replace(/-/g, "");
+    const expRN = `customers/${cleanId}/experiments/${experimentId}`;
+    await withResilience(
+      () => customer.experiments.endExperiment({ resource_name: expRN }),
+      "endExperiment"
+    );
+    return { customer_id: cleanId, experiment_id: experimentId, status: "HALTED" };
+  }
+  async promoteExperiment(customerId, experimentId, validateOnly = false) {
+    const customer = this.getCustomer(customerId);
+    const cleanId = customerId.replace(/-/g, "");
+    const expRN = `customers/${cleanId}/experiments/${experimentId}`;
+    await withResilience(
+      () => customer.experiments.promoteExperiment({ resource_name: expRN, validate_only: validateOnly }),
+      "promoteExperiment"
+    );
+    return {
+      customer_id: cleanId,
+      experiment_id: experimentId,
+      status: validateOnly ? "VALIDATED (not promoted)" : "PROMOTED"
+    };
+  }
+  async removeExperiment(customerId, experimentId) {
+    const customer = this.getCustomer(customerId);
+    const cleanId = customerId.replace(/-/g, "");
+    const expRN = `customers/${cleanId}/experiments/${experimentId}`;
+    await withResilience(
+      () => customer.experiments.remove([expRN]),
+      "removeExperiment"
+    );
+    return {
+      customer_id: cleanId,
+      experiment_id: experimentId,
+      status: "REMOVED"
+    };
+  }
+  async updateCampaignAdUrls(customerId, campaignId, newFinalUrl, execute = false) {
+    const customer = this.getCustomer(customerId);
+    const cleanId = customerId.replace(/-/g, "");
+    const rows = await withResilience(
+      () => customer.query(`
+        SELECT
+          ad_group_ad.resource_name,
+          ad_group_ad.ad.id,
+          ad_group_ad.ad.final_urls,
+          ad_group_ad.status,
+          ad_group.name,
+          campaign.name
+        FROM ad_group_ad
+        WHERE campaign.id = ${sanitizeNumericId(campaignId)}
+          AND ad_group_ad.status != 'REMOVED'
+        ORDER BY ad_group.name
+      `),
+      "updateCampaignAdUrls.query"
+    );
+    const ads = rows.map((r) => ({
+      resource_name: r.ad_group_ad?.resource_name,
+      ad_id: String(r.ad_group_ad?.ad?.id ?? ""),
+      current_final_urls: r.ad_group_ad?.ad?.final_urls ?? [],
+      ad_group_name: r.ad_group?.name ?? "",
+      status: r.ad_group_ad?.status ?? ""
+    }));
+    const preview = ads.map((a) => ({
+      ad_id: a.ad_id,
+      ad_group: a.ad_group_name,
+      from: a.current_final_urls,
+      to: [newFinalUrl]
+    }));
+    if (!execute) {
+      return {
+        customer_id: cleanId,
+        campaign_id: campaignId,
+        dry_run: true,
+        ads_to_update: ads.length,
+        preview,
+        note: "Set execute=true to apply these changes."
+      };
+    }
+    const updates = ads.map((a) => ({
+      resource_name: a.resource_name,
+      ad: { final_urls: [newFinalUrl] }
+    }));
+    if (updates.length > 0) {
+      await withResilience(
+        () => customer.adGroupAds.update(updates),
+        "updateCampaignAdUrls.update"
+      );
+    }
+    await this.autoLabelCreated(customerId, ads.map((a) => a.resource_name).filter(Boolean), "ad");
+    return {
+      customer_id: cleanId,
+      campaign_id: campaignId,
+      dry_run: false,
+      ads_updated: updates.length,
+      new_final_url: newFinalUrl,
+      preview
+    };
+  }
+  // ============================================
   // REPORTING METHODS
   // ============================================
   // Get keyword performance report
@@ -2131,6 +2782,42 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
           }]
         };
       }
+      case "google_ads_set_ad_group_location_targeting": {
+        const customerId = args?.customer_id || "";
+        const result = await adsManager.setAdGroupLocationTargeting(
+          customerId,
+          args?.ad_group_id,
+          args?.geo_target_ids
+        );
+        return {
+          content: [{
+            type: "text",
+            text: JSON.stringify({
+              success: true,
+              message: `Location targeting set: ${(args?.geo_target_ids).length} geo targets added to ad group ${args?.ad_group_id}`,
+              results: result
+            }, null, 2)
+          }]
+        };
+      }
+      case "google_ads_set_campaign_location_targeting": {
+        const customerId = args?.customer_id || "";
+        const result = await adsManager.setCampaignLocationTargeting(
+          customerId,
+          args?.campaign_id,
+          args?.geo_target_ids
+        );
+        return {
+          content: [{
+            type: "text",
+            text: JSON.stringify({
+              success: true,
+              message: `Location targeting set: ${(args?.geo_target_ids).length} geo targets added to campaign ${args?.campaign_id}`,
+              results: result
+            }, null, 2)
+          }]
+        };
+      }
       case "google_ads_add_campaign_negatives": {
         const customerId = args?.customer_id || "";
         const result = await adsManager.addCampaignNegativeKeywords(
@@ -2202,6 +2889,24 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
           }]
         };
       }
+      case "google_ads_enable_keywords": {
+        const customerId = args?.customer_id || "";
+        const result = await adsManager.enableKeywords(
+          customerId,
+          args?.criterion_resource_names,
+          args?.labels
+        );
+        return {
+          content: [{
+            type: "text",
+            text: JSON.stringify({
+              success: true,
+              message: "Keywords enabled and now LIVE",
+              results: result
+            }, null, 2)
+          }]
+        };
+      }
       // ============================================
       // REPORTING HANDLERS
       // ============================================
@@ -2444,6 +3149,41 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
         const result = await adsManager.updateAssetUrls(customerId, normalized.updates);
         return { content: [{ type: "text", text: JSON.stringify({ success: true, ...result }, null, 2) }] };
       }
+      case "google_ads_create_sitelink": {
+        const normalized = normalizeCreateSitelinkArgs(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(buildCreateSitelinkDryRun(normalized), null, 2) }] };
+        }
+        const customerId = normalized.customer_id || "";
+        const result = await adsManager.createSitelink(customerId, {
+          link_text: normalized.link_text,
+          final_urls: normalized.final_urls,
+          description1: normalized.description1,
+          description2: normalized.description2
+        });
+        return { content: [{ type: "text", text: JSON.stringify({ success: true, ...result }, null, 2) }] };
+      }
+      case "google_ads_replace_sitelink_url": {
+        const normalized = normalizeReplaceSitelinkArgs(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(buildReplaceSitelinkDryRun(normalized), null, 2) }] };
+        }
+        const customerId = normalized.customer_id || "";
+        const result = await adsManager.replaceSitelinkUrl(customerId, {
+          old_asset_id: normalized.old_asset_id,
+          new_final_urls: normalized.new_final_urls,
+          new_link_text: normalized.new_link_text,
+          new_description1: normalized.new_description1,
+          new_description2: normalized.new_description2
+        });
+        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) {
@@ -2456,6 +3196,61 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
         const result = await adsManager.pauseAssetLinks(customerId, normalized.resource_names);
         return { content: [{ type: "text", text: JSON.stringify({ success: true, ...result }, null, 2) }] };
       }
+      case "google_ads_rename_ad_group": {
+        const customerId = args?.customer_id || "";
+        const adGroupId = args?.ad_group_id;
+        const newName = args?.new_name;
+        if (!adGroupId || !newName) {
+          return { content: [{ type: "text", text: JSON.stringify({ error: "ad_group_id and new_name are required." }, null, 2) }] };
+        }
+        if (!args?.confirm) {
+          return {
+            content: [{
+              type: "text",
+              text: JSON.stringify({
+                dry_run: true,
+                action: "rename_ad_group",
+                ad_group_id: adGroupId,
+                new_name: newName,
+                message: "Pass confirm: true to apply the rename."
+              }, null, 2)
+            }]
+          };
+        }
+        const renameResult = await adsManager.renameAdGroup(customerId, adGroupId, newName);
+        return { content: [{ type: "text", text: JSON.stringify({ success: true, ...renameResult }, null, 2) }] };
+      }
+      case "google_ads_link_asset_to_campaign": {
+        const customerId = args?.customer_id || "";
+        const assetId = args?.asset_id;
+        const campaignIds = args?.campaign_ids;
+        const fieldType = args?.field_type;
+        if (!assetId || !campaignIds?.length || !fieldType) {
+          return { content: [{ type: "text", text: JSON.stringify({ error: "asset_id, campaign_ids (non-empty), and field_type are required." }, null, 2) }] };
+        }
+        if (!args?.confirm) {
+          return {
+            content: [{
+              type: "text",
+              text: JSON.stringify({
+                dry_run: true,
+                action: "link_asset_to_campaign",
+                asset_id: assetId,
+                campaign_ids: campaignIds,
+                field_type: fieldType,
+                campaigns_to_link: campaignIds.length,
+                message: "Pass confirm: true to apply the links."
+              }, null, 2)
+            }]
+          };
+        }
+        const linkResult = await adsManager.linkAssetToCampaign(customerId, {
+          asset_id: assetId,
+          campaign_ids: campaignIds,
+          field_type: fieldType
+        });
+        return { content: [{ type: "text", text: JSON.stringify({ success: true, ...linkResult }, null, 2) }] };
+      }
       case "google_ads_gaql_query": {
         const customerId = args?.customer_id || "";
         const query = args?.query;
@@ -2533,6 +3328,70 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
           };
         }
       }
+      case "google_ads_create_page_feed": {
+        const customerId = args?.customer_id || "";
+        const campaignId = args?.campaign_id;
+        const feedName = args?.name;
+        const urls = args?.urls;
+        const label = args?.label ?? "page-feed";
+        try {
+          const customer = adsManager.getCustomer(customerId);
+          const assetCreateResult = await withResilience(
+            () => customer.assets.create(
+              urls.map((url) => ({
+                type: enums.AssetType.PAGE_FEED,
+                page_feed_asset: { page_url: url, labels: [label] }
+              }))
+            ),
+            "createPageFeedAssets"
+          );
+          const assetResources = (assetCreateResult.results || []).map((r) => r.resource_name);
+          const assetSetCreateResult = await withResilience(
+            () => customer.asset_sets.create([{
+              name: feedName,
+              type: enums.AssetSetType.PAGE_FEED
+            }]),
+            "createAssetSet"
+          );
+          const assetSetResource = (assetSetCreateResult.results || [])[0]?.resource_name;
+          await withResilience(
+            () => customer.asset_set_assets.create(
+              assetResources.map((assetResource) => ({
+                asset_set: assetSetResource,
+                asset: assetResource
+              }))
+            ),
+            "linkAssetsToSet"
+          );
+          const casCreateResult = await withResilience(
+            () => customer.campaign_asset_sets.create([{
+              campaign: `customers/${customerId}/campaigns/${campaignId}`,
+              asset_set: assetSetResource
+            }]),
+            "attachAssetSetToCampaign"
+          );
+          const casResource = (casCreateResult.results || [])[0]?.resource_name;
+          return {
+            content: [{
+              type: "text",
+              text: JSON.stringify({
+                success: true,
+                asset_set_resource: assetSetResource,
+                campaign_asset_set_resource: casResource,
+                urls_added: urls.length,
+                label
+              }, 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 {
@@ -2556,6 +3415,101 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
           };
         }
       }
+      // ============================================
+      // EXPERIMENT DISPATCH
+      // ============================================
+      case "google_ads_create_experiment": {
+        assertWriteAllowed(name);
+        const customerId = args?.customer_id || "";
+        try {
+          const result = await adsManager.createExperiment(customerId, {
+            base_campaign_id: args?.base_campaign_id,
+            name: args?.name,
+            description: args?.description,
+            suffix: args?.suffix,
+            traffic_split_percent: args?.traffic_split_percent,
+            start_date: args?.start_date,
+            end_date: args?.end_date
+          });
+          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) }] };
+        }
+      }
+      case "google_ads_list_experiments": {
+        const customerId = args?.customer_id || "";
+        const result = await adsManager.listExperiments(customerId, {
+          campaignId: args?.campaign_id,
+          statusFilter: args?.status_filter
+        });
+        return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+      }
+      case "google_ads_get_experiment": {
+        const customerId = args?.customer_id || "";
+        try {
+          const result = await adsManager.getExperiment(customerId, args?.experiment_id);
+          return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+        } catch (e) {
+          return { content: [{ type: "text", text: JSON.stringify({ success: false, error: e.message }, null, 2) }] };
+        }
+      }
+      case "google_ads_schedule_experiment": {
+        assertWriteAllowed(name);
+        const customerId = args?.customer_id || "";
+        try {
+          const result = await adsManager.scheduleExperiment(customerId, args?.experiment_id);
+          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) }] };
+        }
+      }
+      case "google_ads_end_experiment": {
+        assertWriteAllowed(name);
+        const customerId = args?.customer_id || "";
+        try {
+          const result = await adsManager.endExperiment(customerId, args?.experiment_id);
+          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) }] };
+        }
+      }
+      case "google_ads_promote_experiment": {
+        assertWriteAllowed(name);
+        const customerId = args?.customer_id || "";
+        try {
+          const validateOnly = args?.validate_only === true;
+          const result = await adsManager.promoteExperiment(customerId, args?.experiment_id, validateOnly);
+          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) }] };
+        }
+      }
+      case "google_ads_remove_experiment": {
+        assertWriteAllowed(name);
+        const customerId = args?.customer_id || "";
+        try {
+          const result = await adsManager.removeExperiment(customerId, args?.experiment_id);
+          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) }] };
+        }
+      }
+      case "google_ads_update_campaign_ad_urls": {
+        const customerId = args?.customer_id || "";
+        const execute = args?.execute === true;
+        if (execute) assertWriteAllowed(name);
+        try {
+          const result = await adsManager.updateCampaignAdUrls(
+            customerId,
+            args?.campaign_id,
+            args?.new_final_url,
+            execute
+          );
+          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}`);
     }