mcp-google-ads 1.10.0 → 1.11.0

package/dist/backfillDefaults.d.ts

@@ -0,0 +1,19 @@
+/** Extract the selected field paths from a GAQL query's SELECT clause. */
+export declare function extractSelectedFields(query: string): string[];
+/**
+ * Resolve a dotted GAQL field path (e.g. "ad_group.optimized_targeting_enabled")
+ * to its primitive type tag (e.g. "BOOL"). Returns undefined if the path can't
+ * be resolved, or if it resolves to a nested message/enum object rather than a
+ * scalar leaf -- callers only act on an exact string type match.
+ */
+export declare function resolveFieldType(fieldPath: string): string | undefined;
+/**
+ * Google Ads' REST API omits fields at their proto3 default value (e.g.
+ * `false`) entirely from the JSON body -- our tool then serializes the row
+ * with no key at all, indistinguishable from "not returned"/error. This
+ * backfills an explicit `false` for any selected BOOL leaf field missing from
+ * a row whose parent object IS present, so callers can trust that an absent
+ * boolean key never means "unknown" -- only a truly absent parent resource
+ * (e.g. a metrics-only row) is left untouched, never fabricated.
+ */
+export declare function backfillOmittedBooleans<T = any>(query: string, rows: T[]): T[];

package/dist/backfillDefaults.js

@@ -0,0 +1,57 @@
+import { parse as circJsonParse } from "circ-json";
+import fieldsMod from "google-ads-api/build/src/protos/autogen/fields.js";
+let cachedFieldDataTypes = null;
+function getFieldDataTypes() {
+  if (!cachedFieldDataTypes) {
+    cachedFieldDataTypes = circJsonParse(fieldsMod.fieldDataTypes);
+  }
+  return cachedFieldDataTypes;
+}
+function snakeToPascal(snake) {
+  return snake.split("_").map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join("");
+}
+function extractSelectedFields(query) {
+  const match = query.match(/SELECT\s+(.*?)\s+FROM\s/is);
+  if (!match) return [];
+  return match[1].split(",").map((f) => f.trim()).filter(Boolean);
+}
+function resolveFieldType(fieldPath) {
+  const segments = fieldPath.split(".");
+  if (segments.length < 2) return void 0;
+  const types = getFieldDataTypes();
+  let current = types[snakeToPascal(segments[0])];
+  for (let i = 1; i < segments.length && current !== void 0; i++) {
+    if (typeof current !== "object") return void 0;
+    current = current[segments[i]];
+  }
+  return typeof current === "string" ? current : void 0;
+}
+function backfillOmittedBooleans(query, rows) {
+  const boolPaths = extractSelectedFields(query).filter((f) => resolveFieldType(f) === "BOOL");
+  if (boolPaths.length === 0) return rows;
+  for (const row of rows) {
+    for (const path of boolPaths) {
+      const segments = path.split(".");
+      const leaf = segments[segments.length - 1];
+      let parent = row;
+      let reachable = true;
+      for (let i = 0; i < segments.length - 1; i++) {
+        if (parent == null || typeof parent !== "object") {
+          reachable = false;
+          break;
+        }
+        parent = parent[segments[i]];
+      }
+      if (reachable && parent != null && typeof parent === "object" && !(leaf in parent)) {
+        parent[leaf] = false;
+      }
+    }
+  }
+  return rows;
+}
+export {
+  backfillOmittedBooleans,
+  extractSelectedFields,
+  resolveFieldType
+};
+//# sourceMappingURL=backfillDefaults.js.map

package/dist/build-info.json

@@ -1,5 +1,5 @@
 {
-  "sha": "3bef9bb",
-  "builtAt": "2026-09-03T17:18:06.866Z",
+  "sha": "8219937",
+  "builtAt": "2026-09-09T04:33:00.640Z",
   "embeddedSecrets": true
 }

package/dist/index.d.ts

@@ -24,6 +24,23 @@ interface Config {
         require_approval_for_enable: boolean;
     };
 }
+interface ClientResolution {
+    /** "one": exactly one client matched — use `client`.
+     *  "none": no client matched — `client` is null, `candidates` empty.
+     *  "several": more than one client matched — `client` is null, inspect `candidates`. */
+    match: "one" | "none" | "several";
+    client: ClientConfig | null;
+    candidates: ClientConfig[];
+}
+/**
+ * Resolve every client whose `folder` prefixes `cwd`, or whose config key
+ * appears as a substring of `cwd` (fallback for bare per-account folders
+ * like `clients/imvu` that only a per-key match, not the shared folder
+ * value, can disambiguate). Both paths feed the same de-duplicated
+ * candidate set so a caller can never be handed a single confident answer
+ * when more than one client actually matches.
+ */
+export declare function getClientFromWorkingDir(config: Config, cwd: string): ClientResolution;
 export declare class GoogleAdsManager {
     private api;
     private config;
@@ -285,6 +302,10 @@ export declare class GoogleAdsManager {
         target_cpa_dollars: number | undefined;
         target_roas: number | undefined;
     }>;
+    updateCampaignSelectiveOptimization(customerId: string, campaignId: string, conversionActionIds: string[]): Promise<{
+        campaign_id: string;
+        conversion_action_ids: string[];
+    }>;
     updateCampaignAdRotation(customerId: string, campaignId: string, mode: string): Promise<{
         campaign_id: string;
         campaign_name: string;
@@ -541,6 +562,85 @@ export declare class GoogleAdsManager {
         preview?: undefined;
         note?: undefined;
     }>;
+    /**
+     * Update RSA headline/description text IN PLACE via AdService
+     * (customer.ads.update), same ad ID, no clone/pause. This is deliberately
+     * NOT the clone-and-swap pattern updateAdFinalUrls uses -- that pattern
+     * exists because RSA final_urls really does appear to reject in-place
+     * updates; headlines/descriptions do not have that problem (Google's own
+     * update_responsive_search_ad.py sample updates them the same way this
+     * method does). See the class-level history note above updateAdFinalUrls
+     * for how that distinction was confirmed. Payload shape:
+     * `customer.ads.update([{resource_name: "customers/X/ads/Y", responsive_search_ad: {...}}])`
+     * -- responsive_search_ad is a TOP-LEVEL field on the Ad resource, not
+     * nested under an "ad" sub-field (that nesting is the AdGroupAd shape,
+     * a different resource).
+     *
+     * IMPORTANT: an Ad resource can be linked into more than one ad_group_ad
+     * (confirmed live: some Neon CRM ads are shared between a base campaign
+     * and an experiment-page campaign). AdService.update mutates the shared
+     * Ad resource, so ONE call here changes every ad_group_ad that links it.
+     * Both dry-run and confirm paths surface every affected link so a caller
+     * scoped to reviewing just one of them isn't surprised.
+     */
+    updateResponsiveSearchAdText(customerId: string, adId: string, updates: {
+        headlines?: Array<string | {
+            text: string;
+            pinned_position?: number;
+        }>;
+        descriptions?: Array<string | {
+            text: string;
+            pinned_position?: number;
+        }>;
+    }, confirm?: boolean): Promise<{
+        customer_id: string;
+        ad_id: string;
+        dry_run: boolean;
+        mechanism: string;
+        affected_ad_group_ad_links: {
+            resource_name: any;
+            ad_group_id: string;
+            ad_group_name: any;
+            campaign: any;
+            status: any;
+        }[];
+        shared_across_multiple_ad_groups: boolean;
+        headline_changes: {
+            index: number;
+            from: string;
+            to: string;
+        }[];
+        description_changes: {
+            index: number;
+            from: string;
+            to: string;
+        }[];
+        note: string;
+    } | {
+        customer_id: string;
+        ad_id: string;
+        dry_run: boolean;
+        mechanism: string;
+        affected_ad_group_ad_links: {
+            resource_name: any;
+            ad_group_id: string;
+            ad_group_name: any;
+            campaign: any;
+            status: any;
+        }[];
+        shared_across_multiple_ad_groups: boolean;
+        headline_changes: {
+            index: number;
+            from: string;
+            to: string;
+        }[];
+        description_changes: {
+            index: number;
+            from: string;
+            to: string;
+        }[];
+        note?: undefined;
+    }>;
     getKeywordPerformance(customerId: string, options: {
         startDate: string;
         endDate: string;
@@ -617,7 +717,7 @@ export declare class GoogleAdsManager {
         startDate: string;
         endDate: string;
     }): Promise<import("google-ads-node/build/protos/protos.js").google.ads.googleads.v24.services.IGoogleAdsRow[]>;
-    executeGaql(customerId: string, query: string): Promise<import("google-ads-node/build/protos/protos.js").google.ads.googleads.v24.services.IGoogleAdsRow[]>;
+    executeGaql(customerId: string, query: string): Promise<any[]>;
     keywordVolume(customerId: string, keywords: string[], geoTargetConstants?: string[], language?: string): Promise<any>;
 }
 export {};

package/dist/index.js

@@ -85,7 +85,7 @@ import {
   isDemandGenAdGroup
 } from "./validateDemandGenAd.js";
 import { GoogleAdsApi, enums } from "google-ads-api";
-import { buildAdGroupAdResourceName } from "./resourceNames.js";
+import { buildAdGroupAdResourceName, buildAdResourceName } from "./resourceNames.js";
 import { readFileSync, existsSync, realpathSync } from "fs";
 import v8 from "v8";
 const __cliPkg = JSON.parse(readFileSync(join(__moduleDir, "..", "package.json"), "utf-8"));
@@ -160,12 +160,19 @@ function loadConfig() {
   };
 }
 function getClientFromWorkingDir(config, cwd) {
+  const candidates = [];
   for (const [key, client] of Object.entries(config.clients)) {
     if (cwd.startsWith(client.folder) || cwd.includes(key)) {
-      return client;
+      candidates.push(client);
     }
   }
-  return null;
+  if (candidates.length === 0) {
+    return { match: "none", client: null, candidates: [] };
+  }
+  if (candidates.length === 1) {
+    return { match: "one", client: candidates[0], candidates };
+  }
+  return { match: "several", client: null, candidates };
 }
 function sanitizeNumericId(id) {
   return id.replace(/[^0-9]/g, "");
@@ -180,6 +187,7 @@ import {
   classifyError
 } from "./errors.js";
 import { withResilience, safeResponse, logger } from "./resilience.js";
+import { backfillOmittedBooleans } from "./backfillDefaults.js";
 import {
   resolveCredentials,
   readStoredCredentials,
@@ -1898,6 +1906,29 @@ class GoogleAdsManager {
       target_roas: updates.target_roas
     };
   }
+  // Set a campaign's Selective Optimization conversion actions. Full-array
+  // replace, not additive — the conversion_action_ids list passed in entirely
+  // replaces campaign.selective_optimization.conversion_actions.
+  async updateCampaignSelectiveOptimization(customerId, campaignId, conversionActionIds) {
+    const customer = this.getCustomer(customerId);
+    const cleanId = customerId.replace(/-/g, "");
+    const campaignUpdate = {
+      resource_name: `customers/${cleanId}/campaigns/${campaignId}`,
+      selective_optimization: {
+        conversion_actions: conversionActionIds.map(
+          (id) => `customers/${cleanId}/conversionActions/${id}`
+        )
+      }
+    };
+    await withResilience(
+      () => customer.campaigns.update([campaignUpdate]),
+      "updateCampaignSelectiveOptimization.update"
+    );
+    return {
+      campaign_id: campaignId,
+      conversion_action_ids: conversionActionIds
+    };
+  }
   // Update campaign ad rotation (ad_serving_optimization_status). ROTATE
   // self-reverts to OPTIMIZE after ~90 days (Google-managed); ROTATE_INDEFINITELY
   // does not. Caller must pass an explicit mode — no default, so ROTATE_INDEFINITELY
@@ -2872,6 +2903,160 @@ class GoogleAdsManager {
       swaps
     };
   }
+  /**
+   * Update RSA headline/description text IN PLACE via AdService
+   * (customer.ads.update), same ad ID, no clone/pause. This is deliberately
+   * NOT the clone-and-swap pattern updateAdFinalUrls uses -- that pattern
+   * exists because RSA final_urls really does appear to reject in-place
+   * updates; headlines/descriptions do not have that problem (Google's own
+   * update_responsive_search_ad.py sample updates them the same way this
+   * method does). See the class-level history note above updateAdFinalUrls
+   * for how that distinction was confirmed. Payload shape:
+   * `customer.ads.update([{resource_name: "customers/X/ads/Y", responsive_search_ad: {...}}])`
+   * -- responsive_search_ad is a TOP-LEVEL field on the Ad resource, not
+   * nested under an "ad" sub-field (that nesting is the AdGroupAd shape,
+   * a different resource).
+   *
+   * IMPORTANT: an Ad resource can be linked into more than one ad_group_ad
+   * (confirmed live: some Neon CRM ads are shared between a base campaign
+   * and an experiment-page campaign). AdService.update mutates the shared
+   * Ad resource, so ONE call here changes every ad_group_ad that links it.
+   * Both dry-run and confirm paths surface every affected link so a caller
+   * scoped to reviewing just one of them isn't surprised.
+   */
+  async updateResponsiveSearchAdText(customerId, adId, updates, confirm = false) {
+    const customer = this.getCustomer(customerId);
+    const cleanId = customerId.replace(/-/g, "");
+    const cleanAdId = sanitizeNumericId(adId);
+    if (!updates.headlines && !updates.descriptions) {
+      throw new Error("Must provide headlines and/or descriptions to update.");
+    }
+    const rows = await withResilience(
+      () => customer.query(`
+        SELECT
+          ad_group_ad.resource_name,
+          ad_group_ad.ad.id,
+          ad_group_ad.ad.type,
+          ad_group_ad.ad.responsive_search_ad.headlines,
+          ad_group_ad.ad.responsive_search_ad.descriptions,
+          ad_group_ad.ad.responsive_search_ad.path1,
+          ad_group_ad.ad.responsive_search_ad.path2,
+          ad_group_ad.ad.final_urls,
+          ad_group_ad.status,
+          ad_group.id,
+          ad_group.name,
+          campaign.id,
+          campaign.name
+        FROM ad_group_ad
+        WHERE ad_group_ad.ad.id = ${cleanAdId}
+          AND ad_group_ad.status != 'REMOVED'
+      `),
+      "updateResponsiveSearchAdText.query"
+    );
+    if (!rows || rows.length === 0) {
+      throw new Error(`Ad ${adId} not found (or removed).`);
+    }
+    const first = rows[0];
+    const adType = first.ad_group_ad?.ad?.type;
+    if (adType !== 15 && adType !== "RESPONSIVE_SEARCH_AD") {
+      throw new Error(
+        `Ad ${adId} is type ${adType}, not RESPONSIVE_SEARCH_AD. This tool only edits RSA text.`
+      );
+    }
+    const rsa = first.ad_group_ad?.ad?.responsive_search_ad ?? {};
+    const HEADLINE_PIN_REV = { 2: 1, 3: 2, 4: 3 };
+    const DESCRIPTION_PIN_REV = { 5: 1, 6: 2 };
+    const HEADLINE_PIN_MAP = { 1: 2, 2: 3, 3: 4 };
+    const DESCRIPTION_PIN_MAP = { 1: 5, 2: 6 };
+    const currentHeadlines = (rsa.headlines ?? []).map(
+      (h) => ({
+        text: h.text,
+        ...h.pinned_field && HEADLINE_PIN_REV[h.pinned_field] ? { pinned_position: HEADLINE_PIN_REV[h.pinned_field] } : {}
+      })
+    );
+    const currentDescriptions = (rsa.descriptions ?? []).map(
+      (d) => ({
+        text: d.text,
+        ...d.pinned_field && DESCRIPTION_PIN_REV[d.pinned_field] ? { pinned_position: DESCRIPTION_PIN_REV[d.pinned_field] } : {}
+      })
+    );
+    const newHeadlines = updates.headlines?.map((h) => typeof h === "string" ? { text: h } : h);
+    const newDescriptions = updates.descriptions?.map((d) => typeof d === "string" ? { text: d } : d);
+    const validation = validateRsa({
+      headlines: (newHeadlines ?? currentHeadlines).map((h) => h.text),
+      descriptions: (newDescriptions ?? currentDescriptions).map((d) => d.text),
+      final_urls: first.ad_group_ad?.ad?.final_urls ?? [],
+      path1: rsa.path1 ?? "",
+      path2: rsa.path2 ?? "",
+      labels: ["__auto_claude_label__"],
+      requirePathSegments: false
+    });
+    if (!validation.valid) {
+      throw new Error("RSA validation failed:\n" + validation.errors.join("\n"));
+    }
+    const diff = (before, after) => {
+      if (!after) return [];
+      const changes = [];
+      after.forEach((a, i) => {
+        const b = before[i]?.text;
+        if (b !== a.text) changes.push({ index: i, from: b ?? "(none)", to: a.text });
+      });
+      return changes;
+    };
+    const affectedLinks = rows.map((r) => ({
+      resource_name: r.ad_group_ad?.resource_name,
+      ad_group_id: String(r.ad_group?.id ?? ""),
+      ad_group_name: r.ad_group?.name ?? "",
+      campaign: r.campaign?.name ?? "",
+      status: r.ad_group_ad?.status
+    }));
+    const headlineChanges = diff(currentHeadlines, newHeadlines);
+    const descriptionChanges = diff(currentDescriptions, newDescriptions);
+    if (!confirm) {
+      return {
+        customer_id: cleanId,
+        ad_id: cleanAdId,
+        dry_run: true,
+        mechanism: "in-place update via AdService (customer.ads.update)",
+        affected_ad_group_ad_links: affectedLinks,
+        shared_across_multiple_ad_groups: affectedLinks.length > 1,
+        headline_changes: headlineChanges,
+        description_changes: descriptionChanges,
+        note: "Set confirm=true to apply. Edits the shared Ad resource directly -- if shared_across_multiple_ad_groups is true, EVERY link above gets this change in one mutation, not just the one you queried for."
+      };
+    }
+    const adUpdate = { resource_name: buildAdResourceName(cleanId, cleanAdId) };
+    if (newHeadlines) {
+      adUpdate.responsive_search_ad = {
+        ...adUpdate.responsive_search_ad ?? {},
+        headlines: newHeadlines.map((h) => ({
+          text: h.text,
+          ...h.pinned_position && HEADLINE_PIN_MAP[h.pinned_position] ? { pinned_field: HEADLINE_PIN_MAP[h.pinned_position] } : {}
+        }))
+      };
+    }
+    if (newDescriptions) {
+      adUpdate.responsive_search_ad = {
+        ...adUpdate.responsive_search_ad ?? {},
+        descriptions: newDescriptions.map((d) => ({
+          text: d.text,
+          ...d.pinned_position && DESCRIPTION_PIN_MAP[d.pinned_position] ? { pinned_field: DESCRIPTION_PIN_MAP[d.pinned_position] } : {}
+        }))
+      };
+    }
+    await withResilience(() => customer.ads.update([adUpdate]), "updateResponsiveSearchAdText.mutate");
+    await this.autoLabelCreated(customerId, affectedLinks.map((l) => l.resource_name).filter(Boolean), "ad");
+    return {
+      customer_id: cleanId,
+      ad_id: cleanAdId,
+      dry_run: false,
+      mechanism: "in-place update via AdService (customer.ads.update)",
+      affected_ad_group_ad_links: affectedLinks,
+      shared_across_multiple_ad_groups: affectedLinks.length > 1,
+      headline_changes: headlineChanges,
+      description_changes: descriptionChanges
+    };
+  }
   // ============================================
   // REPORTING METHODS
   // ============================================
@@ -3236,7 +3421,8 @@ class GoogleAdsManager {
   async executeGaql(customerId, query) {
     const customer = this.getCustomer(customerId);
     const result = await withResilience(() => customer.query(query), "executeGaql");
-    return safeResponse(result, "executeGaql");
+    const backfilled = backfillOmittedBooleans(query, result);
+    return safeResponse(backfilled, "executeGaql");
   }
   async keywordVolume(customerId, keywords, geoTargetConstants = ["geoTargetConstants/2840"], language = "languageConstants/1000") {
     const customer = this.getCustomer(customerId);
@@ -3297,8 +3483,8 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
     switch (name) {
       case "google_ads_get_client_context": {
         const cwd = args?.working_directory;
-        const client = getClientFromWorkingDir(getConfig(), cwd);
-        if (!client) {
+        const resolution = getClientFromWorkingDir(getConfig(), cwd);
+        if (resolution.match === "none") {
           return {
             content: [{
               type: "text",
@@ -3314,6 +3500,25 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             }]
           };
         }
+        if (resolution.match === "several") {
+          return {
+            content: [{
+              type: "text",
+              text: JSON.stringify({
+                ambiguous: true,
+                error: "Multiple clients match this working directory \u2014 specify which account explicitly",
+                working_directory: cwd,
+                candidates: resolution.candidates.map((c) => ({
+                  client_name: c.name,
+                  customer_id: c.customer_id,
+                  folder: c.folder,
+                  mcc_id: c.mcc_customer_id || getConfig().google_ads.mcc_customer_id
+                }))
+              }, null, 2)
+            }]
+          };
+        }
+        const client = resolution.client;
         return {
           content: [{
             type: "text",
@@ -4234,6 +4439,22 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
           }]
         };
       }
+      case "google_ads_update_campaign_selective_optimization": {
+        const customerId = args?.customer_id || "";
+        const campaignId = args?.campaign_id;
+        const conversionActionIds = args?.conversion_action_ids || [];
+        const result = await getAdsManager().updateCampaignSelectiveOptimization(
+          customerId,
+          campaignId,
+          conversionActionIds
+        );
+        return {
+          content: [{
+            type: "text",
+            text: JSON.stringify({ success: true, ...result }, null, 2)
+          }]
+        };
+      }
       case "google_ads_detach_portfolio_bid_strategy": {
         const customerId = args?.customer_id || "";
         const campaignId = args?.campaign_id;
@@ -4914,6 +5135,25 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
           return { content: [{ type: "text", text: JSON.stringify({ success: false, error: e.message }, null, 2) }] };
         }
       }
+      case "google_ads_update_responsive_search_ad_text": {
+        const customerId = args?.customer_id || "";
+        const confirm = args?.confirm === true;
+        if (confirm) assertWriteAllowed(name);
+        try {
+          const result = await getAdsManager().updateResponsiveSearchAdText(
+            customerId,
+            args?.ad_id,
+            {
+              headlines: args?.headlines,
+              descriptions: args?.descriptions
+            },
+            confirm
+          );
+          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}`);
     }
@@ -4998,6 +5238,7 @@ if (isMainModule()) {
   main().catch((err) => logger.error({ error: err.message, stack: err.stack }, "Fatal startup error"));
 }
 export {
-  GoogleAdsManager
+  GoogleAdsManager,
+  getClientFromWorkingDir
 };
 //# sourceMappingURL=index.js.map

package/dist/resourceNames.d.ts

@@ -1 +1,2 @@
 export declare function buildAdGroupAdResourceName(cleanCustomerId: string, adGroupId: string | number, adId: string | number): string;
+export declare function buildAdResourceName(cleanCustomerId: string, adId: string | number): string;

package/dist/resourceNames.js

@@ -1,7 +1,11 @@
 function buildAdGroupAdResourceName(cleanCustomerId, adGroupId, adId) {
   return `customers/${cleanCustomerId}/adGroupAds/${adGroupId}~${adId}`;
 }
+function buildAdResourceName(cleanCustomerId, adId) {
+  return `customers/${cleanCustomerId}/ads/${adId}`;
+}
 export {
-  buildAdGroupAdResourceName
+  buildAdGroupAdResourceName,
+  buildAdResourceName
 };
 //# sourceMappingURL=resourceNames.js.map

package/dist/tools.js

@@ -785,6 +785,24 @@ const tools = [
       required: ["campaign_id"]
     }
   },
+  {
+    name: "google_ads_update_campaign_selective_optimization",
+    description: "Set a campaign's Selective Optimization conversion actions \u2014 the subset of conversion actions a Maximize Conversions / Maximize Conversion Value campaign optimizes bidding toward. FULL-ARRAY REPLACE, not additive: the conversion_action_ids list you pass entirely replaces whatever conversion actions are currently set, it does not merge with them. Pass every conversion action ID you want active, not just the ones to add.",
+    inputSchema: {
+      additionalProperties: false,
+      type: "object",
+      properties: {
+        customer_id: { type: "string" },
+        campaign_id: { type: "string", description: "The numeric string campaign ID to update" },
+        conversion_action_ids: {
+          type: "array",
+          items: { type: "string", description: "Numeric string conversion action ID" },
+          description: "Full replacement list of conversion action IDs for selective optimization. This REPLACES the existing set entirely \u2014 it is not additive."
+        }
+      },
+      required: ["campaign_id", "conversion_action_ids"]
+    }
+  },
   {
     name: "google_ads_detach_portfolio_bid_strategy",
     description: "Detach a campaign from its portfolio (cross-campaign) bid strategy, dropping it to campaign-level Maximize Conversions with no target. This is the ONLY sanctioned way to break a portfolio bid-strategy attachment \u2014 google_ads_update_campaign_bidding and google_ads_update_campaign_budget (create_new_budget) both refuse to do this silently and point here instead. IRREVERSIBLE: re-attaching or re-applying tCPA/tROAS targets afterward is a separate manual step. Requires confirm: true.",
@@ -1490,6 +1508,57 @@ const tools = [
       required: ["ad_group_id", "ad_ids", "new_final_url"]
     }
   },
+  {
+    name: "google_ads_update_responsive_search_ad_text",
+    description: "Update an RSA's headline/description text IN PLACE via AdService \u2014 same ad ID, no new ad created, no pause/clone. Use this instead of google_ads_create_responsive_search_ad + google_ads_pause_items for a text-only edit. WARNING: an Ad resource can be linked into more than one ad group (e.g. a base campaign and an experiment-page campaign sharing unedited ads); this tool edits the shared Ad resource, so one call changes EVERY linked ad_group_ad \u2014 check `affected_ad_group_ad_links` / `shared_across_multiple_ad_groups` in the dry-run before confirming. Pass only headlines and/or descriptions you want changed; omitted fields are left untouched. DRY-RUN BY DEFAULT: omit `confirm` or pass `confirm: false` to preview old\u2192new text and the affected links.",
+    inputSchema: {
+      additionalProperties: false,
+      type: "object",
+      properties: {
+        customer_id: { type: "string" },
+        ad_id: { type: "string", description: "Numeric ad ID of the RESPONSIVE_SEARCH_AD to edit." },
+        headlines: {
+          type: "array",
+          description: "Optional: the FULL replacement headline list (3-15 items, \u226430 chars each). Omit to leave headlines untouched.",
+          items: {
+            oneOf: [
+              { type: "string" },
+              {
+                type: "object",
+                properties: {
+                  text: { type: "string" },
+                  pinned_position: { type: "number", description: "Pin to position 1, 2, or 3" }
+                },
+                required: ["text"]
+              }
+            ]
+          }
+        },
+        descriptions: {
+          type: "array",
+          description: "Optional: the FULL replacement description list (2-4 items, \u226490 chars each). Omit to leave descriptions untouched.",
+          items: {
+            oneOf: [
+              { type: "string" },
+              {
+                type: "object",
+                properties: {
+                  text: { type: "string" },
+                  pinned_position: { type: "number", description: "Pin to position 1 or 2" }
+                },
+                required: ["text"]
+              }
+            ]
+          }
+        },
+        confirm: {
+          type: "boolean",
+          description: "Must be true to apply. Omit or false for dry-run preview."
+        }
+      },
+      required: ["ad_id"]
+    }
+  },
   {
     name: "google_ads_rename_ad_group",
     description: "Rename an ad group. DRY-RUN BY DEFAULT: omit `confirm` or pass `confirm: false` to preview the change.",

package/dist/writeGate.js

@@ -8,6 +8,7 @@ const WRITE_TOOLS = /* @__PURE__ */ new Set([
   "google_ads_create_demand_gen_multi_asset_ad",
   "google_ads_update_demand_gen_multi_asset_ad",
   "google_ads_update_video_ad_videos",
+  "google_ads_update_responsive_search_ad_text",
   "google_ads_create_image_asset",
   "google_ads_create_lead_form_asset",
   "google_ads_enable_items",
@@ -51,7 +52,8 @@ const WRITE_TOOLS = /* @__PURE__ */ new Set([
   "google_ads_set_campaign_location_targeting",
   "google_ads_attach_user_list_audience",
   "google_ads_create_and_attach_audience_bundle",
-  "google_ads_update_campaign_ad_rotation"
+  "google_ads_update_campaign_ad_rotation",
+  "google_ads_update_campaign_selective_optimization"
 ]);
 const gate = createWriteGate({
   writeTools: WRITE_TOOLS,

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "mcp-google-ads",
   "mcpName": "io.github.mharnett/google-ads",
-  "version": "1.10.0",
+  "version": "1.11.0",
   "description": "MCP server for Google Ads API with MCC support, 44 tools for campaign management, reporting, and optimization. Read-only by default -- mutating tools require GOOGLE_ADS_MCP_WRITE=true. All creates/updates land PAUSED.",
   "main": "dist/index.js",
   "bin": {
@@ -50,7 +50,8 @@
     "test": "vitest run",
     "test:portability": "vitest run src/portability.test.ts",
     "prepublishOnly": "node scripts/check-embedded.mjs && npm run build && npm test",
-    "smoke": "scripts/healthcheck.sh"
+    "smoke": "scripts/healthcheck.sh",
+    "scan:secrets": "node scripts/scan-history-secrets.mjs --repo ."
   },
   "keywords": [
     "mcp",
@@ -91,7 +92,7 @@
     "zod": "^3.22.4"
   },
   "devDependencies": {
-    "@drak-marketing/mcp-test-harness": "^0.1.2",
+    "@drak-marketing/mcp-test-harness": "^0.2.3",
     "@types/node": "^20.10.0",
     "@types/prompts": "^2.4.9",
     "esbuild": "^0.28.0",