@getmcpads/google-ads-mcp-server 1.0.1 → 2.0.0

package/dist/cli.js

@@ -51,24 +51,838 @@ function loadConfig() {
     enableWrites: isTruthy(process.env["GOOGLE_ADS_ENABLE_WRITES"]),
     logLevel: process.env["LOG_LEVEL"] ?? "info"
   };
-  const result = configSchema.safeParse(raw);
-  if (!result.success) {
-    const missing = result.error.issues.map((i) => i.message).join(", ");
+  const result2 = configSchema.safeParse(raw);
+  if (!result2.success) {
+    const missing = result2.error.issues.map((i) => i.message).join(", ");
     logger.error("config", `Missing credentials: ${missing}`);
     throw new Error(`Missing Google Ads credentials: ${missing}`);
   }
-  return result.data;
+  return result2.data;
 }
 function isTruthy(value) {
   if (!value) return false;
   return ["1", "true", "yes", "on"].includes(value.trim().toLowerCase());
 }
 
+// src/parameter-descriptions.ts
+var PARAMETER_DESCRIPTIONS = {
+  "filters": "Filters combined according to this tool's query schema. Use provider field names and the declared operators.",
+  "searchType": "Search surface to report, such as web, image, video, news or Discover. Availability depends on the property.",
+  "searchTypes": "Search surfaces to compare. Each surface is queried separately; do not sum overlapping surfaces.",
+  "datePreset": "Named reporting period. Use the custom date range when you need exact start and end dates.",
+  "dateRange": "Explicit reporting start and end dates in YYYY-MM-DD format.",
+  "timeRange": "Explicit provider reporting period with since and until dates.",
+  "startDate": "First date of the reporting period, in YYYY-MM-DD format.",
+  "endDate": "Last date of the reporting period, in YYYY-MM-DD format, on or after startDate.",
+  "since": "Beginning of the requested reporting period; use the format accepted by the provider.",
+  "until": "End of the requested reporting period; use the format accepted by the provider.",
+  "orderBy": "Field used to order report rows.",
+  "orderField": "Provider field used to order report rows.",
+  "orderDirection": "Sort direction for the selected ordering field.",
+  "orderType": "Sort direction for the selected ordering field.",
+  "sortBy": "Metric or dimension used to rank the returned results.",
+  "sort": "Native provider ordering expressions.",
+  "limit": "Maximum number of returned items or rows. The declared bounds and default apply; use pagination for additional results.",
+  "topN": "Maximum number of highest-ranked results to return.",
+  "pageSize": "Maximum items requested per page. Follow the returned pagination information for remaining results.",
+  "page": "Page number to request, starting at 1.",
+  "offset": "Zero-based number of rows to skip before returning results.",
+  "bookmark": "Opaque Pinterest pagination bookmark returned by the previous response. Omit on the first request.",
+  "after": "Opaque cursor for the next page returned by Meta.",
+  "before": "Opaque cursor for the previous page returned by Meta.",
+  "includeUnchanged": "Include entries with no observed change in the comparison.",
+  "minImpressions": "Minimum reported impressions required for a row to enter the analysis.",
+  "objectives": "Analysis goals that determine the recommended large-site sampling strategy.",
+  "pageLimit": "Maximum number of pages considered for the sampling plan.",
+  "maxInspectionUrls": "Maximum URL Inspection candidates included in the plan; inspection calls consume provider quota.",
+  "minImpressionsForLowCtr": "Minimum impressions before a page is considered for low-CTR analysis.",
+  "staleSitemapDays": "Number of days after which a sitemap's last download is considered stale.",
+  "continueOnError": "Continue with other URLs when one inspection fails, returning individual failures.",
+  "dimension": "Reporting dimension used to group and compare results.",
+  "maxClusters": "Maximum query clusters to return.",
+  "topQueriesPerCluster": "Maximum example queries returned for each cluster.",
+  "minPages": "Minimum distinct pages ranking for a query before it is considered a cannibalization candidate.",
+  "adAccountId": "Owning advertising account ID. Use the exact ID returned by account discovery; do not substitute a campaign or business ID.",
+  "advertiserId": "TikTok advertiser account ID as a string.",
+  "customerId": "Google Ads customer ID, without hyphens.",
+  "propertyId": "Google Analytics property ID; use the property, not the account or measurement ID.",
+  "level": "Entity or aggregation level for the requested report.",
+  "dataLevel": "TikTok reporting aggregation level. Metrics and dimensions must be compatible with this level.",
+  "granularity": "Time bucket used to aggregate reporting rows.",
+  "columns": "Native Pinterest reporting column names. Discover supported columns before selecting metrics.",
+  "executionMode": "Choose the supported synchronous, asynchronous or automatic report execution strategy.",
+  "entityIds": "Exact IDs of the entities to include in the selected reporting level.",
+  "targetingTypes": "Native targeting categories used to break down delivery.",
+  "clickWindowDays": "Click-through attribution window, in days.",
+  "engagementWindowDays": "Engagement-through attribution window, in days.",
+  "viewWindowDays": "View-through attribution window, in days.",
+  "conversionReportTime": "Whether conversions are assigned to the ad action date or the conversion date.",
+  "attributionTypes": "Provider attribution categories included in the report.",
+  "reportingTimezone": "Provider reporting timezone selector. Keep it consistent when comparing periods.",
+  "campaignIds": "Restrict results to these campaign IDs.",
+  "adGroupIds": "Restrict results to these ad group IDs.",
+  "adgroupIds": "Restrict TikTok results to these ad group IDs.",
+  "adIds": "Restrict results to these ad IDs.",
+  "campaignId": "Exact campaign ID in the selected advertising account.",
+  "adGroupId": "Exact ad group ID in the selected advertising account.",
+  "adSetId": "Exact Meta ad set ID in the selected advertising account.",
+  "adId": "Exact ad ID in the selected advertising account.",
+  "entityId": "Exact ID of the entity selected by this operation. It must belong to the selected account.",
+  "onlyWithPeriodDelivery": "Keep only creatives with observed delivery in the requested date range.",
+  "breakdown": "Native reporting breakdown used to group results.",
+  "breakdowns": "Native reporting breakdowns. Check compatibility before combining them.",
+  "productGroupIds": "Restrict reporting to these product group IDs.",
+  "productItemIds": "Restrict reporting to these product item IDs.",
+  "includeProductSamples": "Include a limited sample of product records alongside inventory diagnostics.",
+  "sampleProductGroups": "Maximum product groups to sample for inventory diagnostics.",
+  "reportName": "Provider report name identifying the requested report recipe.",
+  "conversionProductAttributionType": "Pinterest product-conversion attribution category.",
+  "conversionProductBreakdown": "Pinterest product-conversion grouping level.",
+  "productSkuIds": "Restrict product-conversion reporting to these SKU IDs.",
+  "request": "Exact request schema name to inspect before composing a write payload.",
+  "entity": "Entity collection or level to inspect.",
+  "entityType": "Provider entity type to retrieve.",
+  "entityStatuses": "Native status values used to filter the entity collection.",
+  "statusFilter": "Native status values used to filter the returned entities.",
+  "targetingType": "Targeting dictionary to inspect, such as interests, locations or demographics.",
+  "interestId": "Native interest ID for the targeting lookup.",
+  "mode": "Operation or analysis mode. Only the values declared in this schema are supported.",
+  "matchTypes": "Keyword match types included in the lookup.",
+  "countryCode": "Country code used to localize keyword or targeting results.",
+  "keywords": "Keyword phrases to analyze; use the language and market of the intended audience.",
+  "term": "Search term used for the keyword lookup.",
+  "terms": "Search terms used for the keyword lookup.",
+  "audienceId": "Exact ID of the audience to inspect or modify.",
+  "customerListId": "Exact customer-list ID. Reading metadata does not upload customer data.",
+  "businessId": "Exact business account ID used for the lookup.",
+  "accountType": "Provider account category used to filter results.",
+  "ownershipType": "Filter audiences by provider ownership category.",
+  "excludeNca": "Whether to exclude Pinterest new-customer-acquisition audiences from this lookup.",
+  "audienceInsightType": "Pinterest audience-insights category to request.",
+  "surfaces": "Conversion-setup surfaces to inspect, according to the supported values.",
+  "includeDeletedTags": "Include deleted conversion tags in diagnostics.",
+  "lookbackPeriod": "Provider lookback period used for conversion diagnostics.",
+  "sourcePlatform": "Filter conversion data by source platform.",
+  "ingestionSource": "Filter conversion events by ingestion source.",
+  "catalogId": "Exact product catalog ID accessible to the selected account.",
+  "feedId": "Exact catalog feed ID.",
+  "processingResultId": "Exact catalog feed processing result ID to inspect.",
+  "productGroupId": "Exact product group ID.",
+  "productSetId": "Exact Meta product set ID belonging to the selected catalog.",
+  "exportType": "Provider export category to request.",
+  "action": "Supported operation within this tool's scoped provider surface.",
+  "includeDetails": "Include detailed provider records in addition to summary information.",
+  "leadFormId": "Exact lead form ID to inspect.",
+  "subscriptionId": "Exact subscription ID to inspect.",
+  "assetId": "Exact provider asset ID.",
+  "memberId": "Exact business member ID used for the read lookup.",
+  "partnerId": "Exact business partner ID used for the read lookup.",
+  "pinId": "Exact Pinterest pin ID.",
+  "pinIds": "Exact Pinterest pin IDs to include.",
+  "metrics": "Native or documented calculated metric names to request. Check compatibility with the selected dimensions.",
+  "metric": "Metric used for the analysis; use a name from the platform metric catalogue.",
+  "boardId": "Exact Pinterest board ID.",
+  "searchTerm": "Text used to filter or search the selected collection.",
+  "region": "Provider region selector used to localize trends.",
+  "productRegion": "Region used for product trend analysis.",
+  "trendType": "Provider trend category to return.",
+  "interests": "Native interest categories used to filter trends.",
+  "genders": "Native gender categories used to filter aggregate trends.",
+  "ageBuckets": "Native age groups used to filter aggregate trends.",
+  "includeKeywords": "Include related keyword details in the trend response.",
+  "includeDemographics": "Include available aggregate demographic breakdowns.",
+  "productCategories": "Native product category IDs or values used to filter trends.",
+  "verticals": "Native business verticals used to filter trends.",
+  "productLookbackDays": "Product-trend lookback window, in days.",
+  "productEngagementType": "Engagement signal used for product-trend analysis.",
+  "featuredInterest": "Featured interest category for the trends lookup.",
+  "reportType": "Native provider report type; determines supported metrics and dimensions.",
+  "promotionId": "Exact Pinterest product-group promotion ID.",
+  "type": "Provider object or operation type selected from this schema's allowed values.",
+  "productBreakdown": "Native product grouping used to join catalog items with reported insights.",
+  "catalogProductLimit": "Maximum catalog product records read for the join.",
+  "includeAdsets": "Include ad set configuration when checking brand safety.",
+  "includeBlockLists": "Include accessible brand-safety block-list metadata.",
+  "includeRawTargeting": "Include the native targeting specification for diagnostics.",
+  "cellEntityType": "Entity type represented by experiment cells.",
+  "includePagePosts": "Read related Facebook Page posts when the token has permission.",
+  "includeInstagramMedia": "Read related Instagram media when the token has permission.",
+  "includeInsights": "Include available insight metrics; additional provider permissions may be required.",
+  "edge": "Allowlisted Meta Graph edge to read on the selected node.",
+  "fields": "Native provider fields to return. Select only fields supported by the chosen object or report.",
+  "filtering": "Native provider filter expressions; credentials and account overrides are not allowed.",
+  "includeSummary": "Request the provider's available summary or total-count metadata.",
+  "actionBreakdowns": "Meta action-level breakdowns, subject to Insights compatibility rules.",
+  "actionAttributionWindows": "Meta attribution windows used to attribute action metrics.",
+  "timeIncrement": "Provider time-bucket size or supported aggregate value.",
+  "locationTypes": "Location dictionary categories to include in targeting search.",
+  "adFormat": "Native Meta ad preview format; must be compatible with this ad's creative.",
+  "handle": "Asynchronous catalog batch handle returned by the submission to inspect.",
+  "keepEmptyRows": "Keep provider rows whose selected metrics are all zero, where supported.",
+  "sampleLimit": "Maximum records included in the diagnostic sample.",
+  "isOpenFunnel": "Allow users to enter at any funnel step instead of requiring the first step.",
+  "visualizationType": "Supported funnel visualization mode.",
+  "breakdownLimit": "Maximum breakdown values to include in the funnel response.",
+  "nextActionLimit": "Maximum next actions returned for each funnel step.",
+  "fallbackToStepCounts": "If the advanced funnel is unavailable, return independent step counts with the limitation made explicit.",
+  "report": "Native GA4 report request object for this endpoint.",
+  "reports": "Native GA4 report request objects to execute in one batch.",
+  "dimensions": "Native reporting dimensions. Validate compatibility with the selected metrics.",
+  "compatibilityFilter": "Limit compatibility results to the requested GA4 compatibility category.",
+  "collection": "Allowlisted administrative resource collection to read.",
+  "settings": "Property configuration surfaces to inspect.",
+  "includeRecurring": "Include recurring audience-export configurations.",
+  "audienceExportName": "Full GA4 audience-export resource name returned by list_audience_exports.",
+  "queryLifetime": "Request lifetime reporting instead of the explicit reporting period where TikTok supports it.",
+  "declineThresholdPct": "Percentage decline used as a candidate signal for creative fatigue, requiring further evidence.",
+  "includeSavedAudiences": "Include accessible saved-audience metadata in the overlap analysis.",
+  "overlapThreshold": "Overlap threshold used to flag audience pairs, in the units declared by this schema.",
+  "serviceType": "TikTok report service category.",
+  "catalog": "Allowlisted targeting dictionary or catalog to inspect.",
+  "query": "Search text used to find matching entries in the selected catalogue.",
+  "parameters": "Native query parameters for this allowlisted read endpoint. Do not provide credentials or account overrides.",
+  "account_id": "Exact account ID selected for this platform in the GetMCPAds workspace.",
+  "platform": "Platform key identifying the connected advertising or analytics source.",
+  "id": "Exact saved object ID returned by the corresponding create or list tool.",
+  "revision": "Last known object revision, used to reject conflicting updates. Read the object before editing.",
+  "name": "Human-readable name for this object.",
+  "title": "Human-readable title for the resulting object or review.",
+  "clientLabel": "Display label identifying the client in the saved view.",
+  "config": "Complete saved-view configuration, including source, selected account, period and display options.",
+  "subject": "Entity or creative subject whose dated performance will be analyzed.",
+  "compare_previous": "Include the immediately preceding period of equal duration for comparison.",
+  "profile": "Creative brief profile containing the client's business context and analysis preferences.",
+  "primaryMetric": "Metric used to rank or evaluate the review; it must be available for the selected platform.",
+  "direction": "Whether higher or lower values of the primary metric represent improvement.",
+  "creative_ids": "Exact creative IDs to include in this review.",
+  "request_id": "Caller-generated request identifier. Reuse it for a retry of the same operation to avoid duplicate work.",
+  "expiresInDays": "Number of days before the public review sharing link expires.",
+  "client_id": "Exact saved business-client workspace ID.",
+  "review_id": "Exact review ID returned by the review creation or listing tool.",
+  "page_id": "Exact page identifier within the landing-page review.",
+  "entity_id": "Exact entity identifier in the selected review or platform context.",
+  "source_key": "Source identifier returned by the business review; keep the platform/account association intact.",
+  "metric_key": "Exact metric key in the review evidence.",
+  "follow_up_on": "Follow-up date for the decision, using the format declared in this schema.",
+  "hypothesis": "Specific hypothesis to record, supported by the review evidence.",
+  "successCriterion": "Measurable condition used to decide whether the recorded action succeeded.",
+  "outcome": "Observed outcome to record; distinguish evidence from an untested expectation.",
+  "status": "Status selected from the allowed values for this object or operation.",
+  "retry_source": "Source identifier to retry after reviewing its reported error.",
+  "site_origin": "Website origin to analyze, including https:// and hostname, without credentials or a path.",
+  "matchType": "Google Ads keyword match type for the forecast.",
+  "negativeKeywords": "Keyword phrases excluded from the keyword forecast.",
+  "negativeMatchType": "Match type applied to the negative keywords.",
+  "geoTargetIds": "Google Ads geo-target constant IDs for the intended locations.",
+  "languageId": "Google Ads language constant ID for the keyword request.",
+  "languageIds": "Google Ads language constant IDs for the intended audience.",
+  "network": "Google Ads search network selector used for planning.",
+  "biddingStrategy": "Supported bidding strategy for this temporary forecast. The request does not create a live campaign.",
+  "includeAdultKeywords": "Allow adult keyword ideas where supported by the provider and the selected market.",
+  "seedKeywords": "Seed keyword phrases from which Google generates keyword ideas.",
+  "includeAverageCpc": "Request average cost-per-click metrics when available.",
+  "includeDeviceBreakdown": "Include device-specific planning metrics when supported.",
+  "includeKeywordConcepts": "Include Google's keyword concept grouping metadata.",
+  "startYearMonth": "First year and month of the historical metrics period.",
+  "endYearMonth": "Last year and month of the historical metrics period.",
+  "includeDismissed": "Include recommendations already dismissed in the account.",
+  "operation": "Exact allowlisted operation to execute. Arbitrary provider operations are not accepted.",
+  "category": "Category selected from the provider dictionary or field catalogue.",
+  "selectable": "Filter the field catalogue by whether the field can appear in SELECT.",
+  "filterable": "Filter the field catalogue by whether the field can appear in WHERE.",
+  "sortable": "Filter the field catalogue by whether the field can appear in ORDER BY.",
+  "pageToken": "Opaque continuation token returned by the preceding provider response.",
+  "locationNames": "Human-readable location names for Google to resolve into geo-target constants.",
+  "locale": "Locale used for human-readable lookup results.",
+  "resource": "Native Google Ads resource from which the GAQL query selects rows.",
+  "cursor": "Opaque pagination cursor returned by the preceding response; omit for the first page.",
+  "kind": "Entity or request kind whose schema or data is being requested.",
+  "startTime": "Beginning of the reporting period as an ISO 8601 timestamp with an explicit timezone.",
+  "endTime": "End of the reporting period as an ISO 8601 timestamp with an explicit timezone, after startTime.",
+  "reportDimension": "Native dimension used to break down the Snapchat report."
+};
+
+// src/tool-quality.ts
+import { z as z2 } from "zod";
+var RESULT_SCHEMA = {
+  type: "object",
+  properties: {
+    result: {
+      description: "Original tool result: parsed JSON when the text is JSON, otherwise the text or multiple MCP content blocks. Provider fields depend on the selected query.",
+      type: ["object", "array", "string", "number", "boolean", "null"]
+    }
+  },
+  required: ["result"],
+  additionalProperties: true
+};
+function toolAnnotations(write) {
+  return { readOnlyHint: !write, destructiveHint: write, idempotentHint: !write, openWorldHint: true };
+}
+function structuredResult(value) {
+  if (value.isError) return value;
+  let result2 = value.content;
+  const first = value.content[0];
+  if (value.content.length === 1 && first?.type === "text" && typeof first.text === "string") {
+    result2 = first.text;
+    try {
+      result2 = JSON.parse(first.text);
+    } catch {
+    }
+  }
+  return { ...value, structuredContent: { ...value.structuredContent, result: result2 } };
+}
+var resultShape = { result: z2.union([z2.object({}).passthrough(), z2.array(z2.unknown()), z2.string(), z2.number(), z2.boolean(), z2.null()]).describe(RESULT_SCHEMA.properties.result.description) };
+function installToolQuality(server) {
+  server.tool = ((name, description, inputSchema, handler) => {
+    const write = Object.hasOwn(inputSchema, "confirm");
+    inputSchema = Object.fromEntries(Object.entries(inputSchema).map(([key, schema]) => [key, schema.description || PARAMETER_DESCRIPTIONS[key] ? schema.describe(schema.description || PARAMETER_DESCRIPTIONS[key]) : schema]));
+    return server.registerTool(name, {
+      title: name.replace(/_/g, " "),
+      description,
+      inputSchema,
+      outputSchema: resultShape,
+      annotations: toolAnnotations(write)
+    }, async (...args) => structuredResult(await handler(...args)));
+  });
+}
+
 // src/server.ts
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 
+// src/platforms/google-ads/extended-writes.ts
+import { webcrypto } from "crypto";
+import { z as z3 } from "zod";
+var BASE = "https://googleads.googleapis.com/v25";
+var resources = {
+  conversionActionOperation: "conversionActions",
+  campaignBudgetOperation: "campaignBudgets",
+  campaignOperation: "campaigns",
+  adGroupOperation: "adGroups",
+  adGroupAdOperation: "adGroupAds",
+  adOperation: "ads",
+  assetOperation: "assets",
+  assetGroupOperation: "assetGroups",
+  assetGroupAssetOperation: "assetGroupAssets",
+  campaignAssetOperation: "campaignAssets",
+  campaignCriterionOperation: "campaignCriteria",
+  adGroupCriterionOperation: "adGroupCriteria",
+  assetGroupListingGroupFilterOperation: "assetGroupListingGroupFilters"
+};
+var json = z3.record(z3.unknown());
+var operation = z3.object({
+  kind: z3.enum(
+    Object.keys(resources)
+  ),
+  create: json.optional(),
+  update: json.optional(),
+  remove: z3.string().optional(),
+  updateMask: z3.string().min(1).optional()
+}).strict();
+var result = (v) => ({
+  content: [{ type: "text", text: JSON.stringify(v, null, 2) }]
+});
+function canonical(v) {
+  if (Array.isArray(v)) return `[${v.map(canonical).join(",")}]`;
+  if (v && typeof v === "object")
+    return `{${Object.keys(v).sort().map((k) => `${JSON.stringify(k)}:${canonical(v[k])}`).join(",")}}`;
+  return JSON.stringify(v);
+}
+async function digest(v) {
+  return Array.from(
+    new Uint8Array(
+      await webcrypto.subtle.digest(
+        "SHA-256",
+        new TextEncoder().encode(canonical(v))
+      )
+    )
+  ).map((n) => n.toString(16).padStart(2, "0")).join("");
+}
+function previewData(v) {
+  if (Array.isArray(v)) return v.map(previewData);
+  if (v && typeof v === "object")
+    return Object.fromEntries(
+      Object.entries(v).map(([k, x]) => [
+        k,
+        k === "data" && typeof x === "string" ? `[base64 media: ${x.length} characters]` : previewData(x)
+      ])
+    );
+  return v;
+}
+function normalizeGooglePlan(customerId, input) {
+  if (!/^\d{10}$/.test(customerId))
+    throw new Error("Use a ten-digit customer ID.");
+  const prefix = `customers/${customerId}/`;
+  function check(v) {
+    if (typeof v === "string" && v.startsWith("customers/") && !v.startsWith(prefix))
+      throw new Error(
+        "Every customer resource must belong to the selected customerId."
+      );
+    if (Array.isArray(v)) v.forEach(check);
+    else if (v && typeof v === "object")
+      for (const [k, x] of Object.entries(v)) {
+        if (/access.?token|refresh.?token|developer.?token|authorization|client.?secret/i.test(
+          k
+        ))
+          throw new Error("Do not put credentials in a plan.");
+        if (k === "data" && typeof x === "string") {
+          let valid = x.length > 0 && x.length <= 6990508 && /^[A-Za-z0-9+/]*={0,2}$/.test(x);
+          try {
+            valid = valid && atob(x).length <= 5 * 1024 * 1024;
+          } catch {
+            valid = false;
+          }
+          if (!valid) throw new Error("Image data must be base64, at most 5 MiB decoded.");
+        }
+        check(x);
+      }
+  }
+  return input.map((raw) => {
+    const op = operation.parse(raw);
+    if ([op.create, op.update, op.remove].filter((x) => x !== void 0).length !== 1)
+      throw new Error(
+        "Each operation needs exactly one of create, update or remove."
+      );
+    if (op.update && !op.updateMask)
+      throw new Error("Updates require an explicit updateMask.");
+    if (op.kind === "adOperation" && op.update && ("name" in op.update || op.updateMask?.split(",").some((field) => field.trim() === "name")))
+      throw new Error("Google ad.name is immutable. Edit supported creative fields, or explicitly create a new paused ad with the desired name; never silently replace the original.");
+    if (!op.update && op.updateMask)
+      throw new Error("updateMask is only valid on updates.");
+    if (op.updateMask && /(^|,)\s*(\*|resource_name)\s*(,|$)/.test(op.updateMask))
+      throw new Error(
+        "Use a precise updateMask; never wildcard or resource_name."
+      );
+    const body = structuredClone(op.create ?? op.update);
+    const expected = prefix + resources[op.kind] + "/";
+    const resource = op.remove ?? body?.resourceName;
+    if ((op.update || op.remove) && !resource)
+      throw new Error("Update/remove requires a resource name.");
+    if (resource && (!resource.startsWith(expected) || !/^-?\d+(~[A-Za-z0-9_-]+)*$/.test(resource.slice(expected.length))))
+      throw new Error(`Expected resource in ${expected}.`);
+    if (op.create && [
+      "campaignOperation",
+      "adGroupOperation",
+      "adGroupAdOperation",
+      "assetGroupOperation"
+    ].includes(op.kind)) {
+      if (body.status && body.status !== "PAUSED")
+        throw new Error("New campaigns, groups and ads must be PAUSED.");
+      body.status = "PAUSED";
+    }
+    if (op.create && op.kind === "campaignOperation") {
+      if (body.advertisingChannelType === "VIDEO")
+        throw new Error(
+          "Google Ads API cannot create VIDEO campaigns. Use an explicitly requested DEMAND_GEN video campaign instead."
+        );
+      if (![
+        "CONTAINS_EU_POLITICAL_ADVERTISING",
+        "DOES_NOT_CONTAIN_EU_POLITICAL_ADVERTISING"
+      ].includes(body.containsEuPoliticalAdvertising))
+        throw new Error(
+          "Explicit EU political advertising declaration required."
+        );
+    }
+    const value = op.remove ? { remove: op.remove } : op.create ? { create: body } : { update: body, updateMask: op.updateMask };
+    check(value);
+    return { [op.kind]: value };
+  });
+}
+function registerGoogleVideoReads(c, config) {
+  c.tool("google_ads_get_video_upload", "Read the processing state and YouTube video ID of one Google Ads upload in the selected customer. Use only the returned videoId after state=PROCESSED. This is a read; it does not upload again.", {
+    customerId: z3.string().regex(/^[\d-]+$/),
+    currency: z3.string().regex(/^[A-Z]{3}$/).describe("Actual customer currency, verified before reading the upload."),
+    uploadId: z3.string().regex(/^\d+$/).describe("Numeric upload ID returned by google_ads_upload_video."),
+    loginCustomerId: z3.string().regex(/^[\d-]+$/).optional().describe("Optional MCC manager ID; defaults to the configured manager."),
+    testAccountOnly: z3.boolean().optional().describe("Require customer.test_account=true; enable for sandbox checks.")
+  }, async (raw) => {
+    const a = z3.object({ customerId: z3.string().regex(/^[\d-]+$/), currency: z3.string().regex(/^[A-Z]{3}$/), uploadId: z3.string().regex(/^\d+$/), loginCustomerId: z3.string().regex(/^[\d-]+$/).optional(), testAccountOnly: z3.boolean().optional() }).strict().parse(raw);
+    const cid = a.customerId.replace(/-/g, "");
+    const { api } = await googleSession(config, cid, a.currency, a.testAccountOnly === true, (a.loginCustomerId ?? config.loginCustomerId)?.replace(/-/g, ""));
+    const resourceName = `customers/${cid}/youTubeVideoUploads/${a.uploadId}`;
+    const response = await api("googleAds:search", { query: `SELECT you_tube_video_upload.resource_name, you_tube_video_upload.state, you_tube_video_upload.video_id FROM you_tube_video_upload WHERE you_tube_video_upload.resource_name = '${resourceName}' LIMIT 1` });
+    const video = response.results?.[0]?.youTubeVideoUpload;
+    return result({ uploadId: a.uploadId, state: video?.state ?? "NOT_FOUND", ...video?.state === "PROCESSED" && video.videoId ? { videoId: video.videoId } : {} });
+  });
+}
+function registerGoogleExtendedWrites(c, config) {
+  const original = c;
+  const descriptions = {
+    customerId: "Selected Google Ads customer ID, not the manager account.",
+    currency: "Actual account currency as a three-letter ISO code; verified natively before writes.",
+    loginCustomerId: "Optional MCC ID; defaults to the selected account's inferred manager.",
+    testAccountOnly: "Require customer.test_account=true before writing. Always use true for sandbox acceptance.",
+    confirm: "Apply only when true and expectedPlanHash matches the exact preview.",
+    validateOnly: "Ask Google to validate without applying. Takes priority over confirm.",
+    expectedPlanHash: "SHA-256 planHash from the preview of this exact payload, required for application.",
+    uploadId: "Numeric ID of a video uploaded through Google Ads in this customer.",
+    title: "Nonempty title for this new video upload.",
+    mimeType: "Actual MIME type of the supplied video bytes."
+  };
+  c = {
+    tool: (n, d, shape, h) => original.tool(
+      n,
+      d,
+      Object.fromEntries(
+        Object.entries(shape).map(([k, v]) => [
+          k,
+          v.description ? v : v.describe(descriptions[k] ?? k)
+        ])
+      ),
+      h
+    )
+  };
+  registerGoogleVideoWrites(c, config);
+  c.tool(
+    "google_ads_apply_plan",
+    "Preview, validate and atomically apply a Google Ads v25 build/change plan: campaigns, budgets, ad groups, RSA/Display/Demand Gen ads, image/text/YouTube assets, PMax asset groups and links, keywords, geographic/language targeting listing groups and conversion action configuration (no conversion event uploads). Native REST camelCase fields; amounts are integer micros of the explicitly stated currency. Supports temporary negative resource IDs for ordered creation in one transaction. No VIDEO campaign creation (Google API restriction), billing, account access changes, customer lists or conversion uploads. New campaigns/groups/ads are always PAUSED. Call first without confirm to inspect the plan and get planHash; validateOnly asks Google without applying; execution requires confirm and the matching expectedPlanHash. Read back results with google_ads_run_gaql. Never retry a creation after an uncertain network result before checking its name/IDs.",
+    {
+      customerId: z3.string().regex(/^[\d-]+$/),
+      currency: z3.string().regex(/^[A-Z]{3}$/).describe(
+        "Actual account currency, mandatory even when only linking assets."
+      ),
+      operations: z3.array(operation).min(1).max(100).describe(
+        "Ordered operations. kind is a native MutateOperation field; create/update contains native REST fields; remove is the full owned resource name. Images use imageAsset.data base64 bytes; videos use youtubeVideoAsset.youtubeVideoId (already uploaded on YouTube)."
+      ),
+      loginCustomerId: z3.string().regex(/^[\d-]+$/).optional(),
+      testAccountOnly: z3.boolean().optional().describe(
+        "Require Google's customer.test_account=true before any mutation. Use true for acceptance tests."
+      ),
+      validateOnly: z3.boolean().optional(),
+      confirm: z3.boolean().optional(),
+      expectedPlanHash: z3.string().regex(/^[a-f0-9]{64}$/).optional()
+    },
+    async (a) => {
+      const cid = a.customerId.replace(/-/g, "");
+      const operations = normalizeGooglePlan(cid, a.operations);
+      if (JSON.stringify(operations).length > 12e6)
+        throw new Error(
+          "Plan too large; upload assets in separate confirmed plans and reference their resource names."
+        );
+      const manager = (a.loginCustomerId ?? config.loginCustomerId)?.replace(
+        /-/g,
+        ""
+      );
+      const planHash = await digest({
+        customerId: cid,
+        currency: a.currency,
+        manager: manager ?? null,
+        testAccountOnly: a.testAccountOnly === true,
+        operations
+      });
+      if (!a.confirm && !a.validateOnly)
+        return result({
+          applied: false,
+          planHash,
+          customerId: cid,
+          currency: a.currency,
+          operationCount: operations.length,
+          operations: previewData(operations)
+        });
+      if (a.confirm && !a.validateOnly && a.expectedPlanHash !== planHash)
+        throw new Error(
+          "Preview this exact plan first and provide its matching expectedPlanHash."
+        );
+      const { api, customer } = await googleSession(
+        config,
+        cid,
+        a.currency,
+        a.testAccountOnly,
+        manager
+      );
+      const response = await api("googleAds:mutate", {
+        mutateOperations: operations,
+        partialFailure: false,
+        validateOnly: a.validateOnly === true
+      });
+      return result({
+        applied: a.validateOnly !== true,
+        validatedByGoogle: true,
+        planHash,
+        operationCount: operations.length,
+        customerId: cid,
+        currency: a.currency,
+        testAccount: customer.testAccount === true,
+        result: response
+      });
+    }
+  );
+}
+async function googleSession(config, cid, currency, testAccountOnly, manager) {
+  const auth = await fetch("https://oauth2.googleapis.com/token", {
+    method: "POST",
+    headers: { "content-type": "application/x-www-form-urlencoded" },
+    body: new URLSearchParams({
+      grant_type: "refresh_token",
+      client_id: config.clientId,
+      client_secret: config.clientSecret,
+      refresh_token: config.refreshToken
+    }),
+    redirect: "error"
+  });
+  const token = await auth.json();
+  if (!auth.ok || !token.access_token)
+    throw new Error(
+      "Google authorization could not be refreshed. Reconnect the Google Ads source."
+    );
+  const headers = {
+    authorization: `Bearer ${token.access_token}`,
+    "developer-token": config.developerToken,
+    "content-type": "application/json"
+  };
+  if (manager) headers["login-customer-id"] = manager;
+  async function api(path, body) {
+    const r = await fetch(`${BASE}/customers/${cid}/${path}`, {
+      method: "POST",
+      headers,
+      body: JSON.stringify(body),
+      redirect: "error"
+    });
+    const x = await r.json();
+    if (!r.ok) {
+      const errors = x.error?.details?.flatMap((d) => d.errors ?? []).map((e) => ({
+        code: e.errorCode,
+        message: e.message,
+        location: e.location
+      }));
+      throw new Error(
+        `Google Ads: ${JSON.stringify(errors?.length ? errors : x.error?.message ?? r.status).slice(0, 4e3)}`
+      );
+    }
+    return x;
+  }
+  const read = await api("googleAds:search", {
+    query: "SELECT customer.id, customer.currency_code, customer.test_account FROM customer"
+  });
+  const customer = read.results?.[0]?.customer;
+  if (customer?.id !== cid || customer?.currencyCode !== currency)
+    throw new Error("Customer identity or currency does not match the plan.");
+  if (testAccountOnly && customer.testAccount !== true)
+    throw new Error("This plan requires a Google test account.");
+  return { headers, api, customer };
+}
+function registerGoogleVideoWrites(c, config) {
+  const common = {
+    customerId: z3.string().regex(/^[\d-]+$/),
+    currency: z3.string().regex(/^[A-Z]{3}$/),
+    loginCustomerId: z3.string().regex(/^[\d-]+$/).optional(),
+    testAccountOnly: z3.boolean().optional(),
+    confirm: z3.boolean().optional(),
+    expectedPlanHash: z3.string().regex(/^[a-f0-9]{64}$/).optional()
+  };
+  c.tool(
+    "google_ads_upload_video",
+    "Upload MP4/WebM/QuickTime bytes (max 16 MiB) to the Google-managed YouTube channel for the selected ad account. Visibility is UNLISTED: viewable by anyone with the link, not private. Default preview omits bytes and returns planHash; confirm requires expectedPlanHash. This API has no validateOnly. After upload, query you_tube_video_upload.state and video_id with google_ads_run_gaql; only use the video ID after PROCESSED, via google_ads_apply_plan assetOperation.youtubeVideoAsset. No automatic retry after an uncertain upload.",
+    {
+      ...common,
+      bytesBase64: z3.string().min(4).max(22369624).describe(
+        "Raw base64 video bytes, no data URL. Prefer an existing YouTube asset for large videos."
+      ),
+      mimeType: z3.enum(["video/mp4", "video/webm", "video/quicktime"]),
+      title: z3.string().trim().min(1).max(100),
+      description: z3.string().trim().min(1).max(5e3).describe(
+        "Nonempty video description; Google rejects an empty value during upload."
+      ),
+      visibility: z3.literal("UNLISTED").describe(
+        "Explicit acknowledgment of the visibility of this YouTube upload."
+      )
+    },
+    async (a) => {
+      const cid = a.customerId.replace(/-/g, "");
+      if (!/^\d{10}$/.test(cid))
+        throw new Error("Use a ten-digit customer ID.");
+      if (!/^[A-Za-z0-9+/]*={0,2}$/.test(a.bytesBase64))
+        throw new Error("Invalid base64 video.");
+      let binary;
+      try {
+        binary = atob(a.bytesBase64);
+      } catch {
+        throw new Error("Invalid base64 video.");
+      }
+      if (binary.length > 16 * 1024 * 1024)
+        throw new Error("Video exceeds 16 MiB.");
+      const manager = (a.loginCustomerId ?? config.loginCustomerId)?.replace(
+        /-/g,
+        ""
+      );
+      const planHash = await digest({
+        customerId: cid,
+        currency: a.currency,
+        manager: manager ?? null,
+        testAccountOnly: a.testAccountOnly === true,
+        title: a.title,
+        description: a.description ?? "",
+        mimeType: a.mimeType,
+        visibility: a.visibility,
+        bytes: a.bytesBase64
+      });
+      if (!a.confirm)
+        return result({
+          applied: false,
+          planHash,
+          customerId: cid,
+          title: a.title,
+          description: a.description,
+          mimeType: a.mimeType,
+          visibility: a.visibility,
+          byteLength: binary.length
+        });
+      if (a.expectedPlanHash !== planHash)
+        throw new Error(
+          "Preview this exact upload first and supply expectedPlanHash."
+        );
+      const { headers } = await googleSession(
+        config,
+        cid,
+        a.currency,
+        a.testAccountOnly,
+        manager
+      );
+      const start = await fetch(
+        `https://googleads.googleapis.com/resumable/upload/v25/customers/${cid}/youTubeVideoUploads:create`,
+        {
+          method: "POST",
+          headers: {
+            ...headers,
+            "X-Goog-Upload-Protocol": "resumable",
+            "X-Goog-Upload-Command": "start",
+            "X-Goog-Upload-Header-Content-Length": String(binary.length)
+          },
+          body: JSON.stringify({
+            customer_id: cid,
+            you_tube_video_upload: {
+              video_title: a.title,
+              video_description: a.description ?? "",
+              video_privacy: "UNLISTED"
+            }
+          }),
+          redirect: "error"
+        }
+      );
+      if (!start.ok)
+        throw new Error(
+          `Google video upload initiation failed (${start.status}). No automatic retry.`
+        );
+      const target = start.headers.get("x-goog-upload-url");
+      if (!target || new URL(target).origin !== "https://googleads.googleapis.com")
+        throw new Error(
+          "Unexpected Google upload URL; no bytes or credentials sent."
+        );
+      const uploaded = await fetch(target, {
+        method: "PUT",
+        headers: {
+          ...headers,
+          "content-type": a.mimeType,
+          "X-Goog-Upload-Offset": "0",
+          "X-Goog-Upload-Command": "upload, finalize"
+        },
+        body: Uint8Array.from(binary, (c2) => c2.charCodeAt(0)),
+        redirect: "error"
+      });
+      if (!uploaded.ok) {
+        const error = await uploaded.json().catch(() => ({}));
+        throw new Error(
+          `Google video upload failed (${uploaded.status}): ${String(error.error?.message ?? "unknown error").slice(0, 700)}. Inspect you_tube_video_upload before retrying.`
+        );
+      }
+      const response = await uploaded.json();
+      if (!String(response.resourceName).startsWith(
+        `customers/${cid}/youTubeVideoUploads/`
+      ))
+        throw new Error(
+          "Google did not return an owned video upload resource. Inspect uploads before retrying."
+        );
+      return result({
+        applied: true,
+        planHash,
+        resourceName: response.resourceName,
+        uploadId: String(response.resourceName).split("/").pop(),
+        visibility: "UNLISTED",
+        nextAction: "Query you_tube_video_upload.state and video_id; wait for PROCESSED before creating the video asset."
+      });
+    }
+  );
+  c.tool(
+    "google_ads_remove_video_upload",
+    "Remove a video upload owned by the selected ad account. Deletes the uploaded YouTube video and can break ads referencing it. Preview and matching expectedPlanHash required. Google v25 marks title/description immutable; this tool does not pretend to edit them.",
+    { ...common, uploadId: z3.string().regex(/^\d+$/) },
+    async (a) => {
+      const cid = a.customerId.replace(/-/g, "");
+      if (!/^\d{10}$/.test(cid))
+        throw new Error("Use a ten-digit customer ID.");
+      const manager = (a.loginCustomerId ?? config.loginCustomerId)?.replace(
+        /-/g,
+        ""
+      );
+      const resourceName = `customers/${cid}/youTubeVideoUploads/${a.uploadId}`;
+      const planHash = await digest({
+        customerId: cid,
+        currency: a.currency,
+        manager: manager ?? null,
+        testAccountOnly: a.testAccountOnly === true,
+        remove: resourceName
+      });
+      if (!a.confirm)
+        return result({ applied: false, planHash, remove: resourceName });
+      if (a.expectedPlanHash !== planHash)
+        throw new Error(
+          "Preview this exact removal first and supply expectedPlanHash."
+        );
+      const { api } = await googleSession(
+        config,
+        cid,
+        a.currency,
+        a.testAccountOnly,
+        manager
+      );
+      return result({
+        applied: true,
+        planHash,
+        result: await api("youTubeVideoUploads:remove", {
+          resourceNames: [resourceName]
+        })
+      });
+    }
+  );
+}
+
+// src/platforms/google-ads/pmax-metrics.ts
+var PMAX_METRIC_FIELDS = [
+  "metrics.impressions",
+  "metrics.clicks",
+  "metrics.cost_micros",
+  "metrics.conversions",
+  "metrics.conversions_value",
+  "metrics.all_conversions",
+  "metrics.all_conversions_from_interactions_rate",
+  "metrics.all_conversions_from_interactions_value_per_interaction",
+  "metrics.all_conversions_value",
+  "metrics.all_conversions_value_per_cost",
+  "metrics.average_cost",
+  "metrics.average_cpc",
+  "metrics.average_cpe",
+  "metrics.average_cpm",
+  "metrics.conversions_from_interactions_rate",
+  "metrics.conversions_from_interactions_value_per_interaction",
+  "metrics.conversions_value_per_cost",
+  "metrics.cost_per_all_conversions",
+  "metrics.cost_per_conversion",
+  "metrics.cross_device_conversions",
+  "metrics.cross_device_conversions_value",
+  "metrics.ctr",
+  "metrics.engagement_rate",
+  "metrics.engagements",
+  "metrics.interaction_rate",
+  "metrics.interactions",
+  "metrics.trueview_average_cpv",
+  "metrics.value_per_all_conversions",
+  "metrics.value_per_conversion",
+  "metrics.video_trueview_view_rate",
+  "metrics.video_trueview_views",
+  "metrics.view_through_conversions"
+];
+
 // src/platforms/google-ads/tools.ts
-import { z as z5 } from "zod";
+import { z as z7 } from "zod";
 
 // src/platforms/google-ads/types.ts
 var GoogleAdsApiException = class extends Error {
@@ -3706,9 +4520,9 @@ var BIDDING_TARGET_DIMENSIONS = [
   {
     key: "campaignStartDate",
     name: "Campaign Start Date",
-    description: "The start date of the campaign in YYYY-MM-DD format.",
+    description: "The start date and time of the campaign in the account time zone (YYYY-MM-DD HH:mm:ss).",
     category: "entity",
-    apiField: "campaign.start_date",
+    apiField: "campaign.start_date_time",
     isSegment: false,
     isResourceAttribute: true,
     compatibleResources: ["campaign"]
@@ -3716,9 +4530,9 @@ var BIDDING_TARGET_DIMENSIONS = [
   {
     key: "campaignEndDate",
     name: "Campaign End Date",
-    description: "The end date of the campaign in YYYY-MM-DD format (if set).",
+    description: "The end date and time of the campaign in the account time zone (YYYY-MM-DD HH:mm:ss), if set.",
     category: "entity",
-    apiField: "campaign.end_date",
+    apiField: "campaign.end_date_time",
     isSegment: false,
     isResourceAttribute: true,
     compatibleResources: ["campaign"]
@@ -4151,7 +4965,7 @@ function buildDateWhereClause(startDate, endDate, datePreset) {
   }
   return { clause: null, warnings: [] };
 }
-function planQuery(request) {
+function planQuery(request2) {
   const {
     resource,
     metrics,
@@ -4163,7 +4977,7 @@ function planQuery(request) {
     orderBy,
     orderDirection,
     limit
-  } = request;
+  } = request2;
   const errors = [];
   const warnings = [];
   const calculatedMetricKeys = metrics.filter((k) => isCalculatedMetric(k));
@@ -4516,13 +5330,6 @@ var PlatformApiError = class extends Error {
     this.retryAfter = retryAfter;
     this.name = "PlatformApiError";
   }
-  platform;
-  code;
-  isRateLimit;
-  isAuth;
-  isPermission;
-  suggestion;
-  retryAfter;
   toMcpError() {
     return {
       error: this.message,
@@ -4657,7 +5464,7 @@ var KeywordPlannerRateLimiter = class {
 };
 
 // src/platforms/google-ads/read-rpc.ts
-import { z as z2 } from "zod";
+import { z as z4 } from "zod";
 var READ_ONLY_OPERATION_NAMES = [
   "generateAudienceCompositionInsights",
   "generateAudienceDefinition",
@@ -4773,13 +5580,13 @@ function validateGoogleAdsReadOnlyRequest(value, path = "request", depth = 0, st
   }
   throw new Error(`${path} must contain JSON-compatible values.`);
 }
-function buildGoogleAdsReadOnlyPath(operation, customerId) {
-  const config = GOOGLE_ADS_READ_ONLY_OPERATIONS[operation];
-  if (!config) throw new Error(`Unsupported read-only operation: ${operation}.`);
+function buildGoogleAdsReadOnlyPath(operation2, customerId) {
+  const config = GOOGLE_ADS_READ_ONLY_OPERATIONS[operation2];
+  if (!config) throw new Error(`Unsupported read-only operation: ${operation2}.`);
   if (config.scope === "customer") {
     const cleanCustomerId = customerId?.replace(/-/g, "");
     if (!cleanCustomerId || !/^\d+$/.test(cleanCustomerId)) {
-      throw new Error(`${operation} requires a numeric customerId.`);
+      throw new Error(`${operation2} requires a numeric customerId.`);
     }
     return { path: `customers/${cleanCustomerId}${config.path}`, config };
   }
@@ -4790,20 +5597,20 @@ function registerGoogleAdsReadOnlyRpcTool(server, client, ok3) {
     "google_ads_run_readonly_rpc",
     "Advanced read-only escape hatch for allowlisted Google Ads services outside GAQL: Audience Insights, Reach Planner, benchmarks, creator/trending insights, targeting suggestions, Smart Campaign suggestions, identity verification, invoices, and payments accounts. The operation is an enum; arbitrary paths and all mutations/uploads are impossible.",
     {
-      operation: z2.enum(READ_ONLY_OPERATION_NAMES),
-      customerId: z2.string().regex(/^\d[\d-]*\d$|^\d$/).optional().describe("Required for customer-scoped operations; omit for global planning catalogs"),
-      request: z2.record(z2.unknown()).optional().default({}).describe("Official REST JSON request body for POST operations, or query parameters for GET operations")
+      operation: z4.enum(READ_ONLY_OPERATION_NAMES),
+      customerId: z4.string().regex(/^\d[\d-]*\d$|^\d$/).optional().describe("Required for customer-scoped operations; omit for global planning catalogs"),
+      request: z4.record(z4.unknown()).optional().default({}).describe("Official REST JSON request body for POST operations, or query parameters for GET operations")
     },
-    async ({ operation, customerId, request }) => {
+    async ({ operation: operation2, customerId, request: request2 }) => {
       try {
-        validateGoogleAdsReadOnlyRequest(request);
-        const encodedLength = JSON.stringify(request).length;
+        validateGoogleAdsReadOnlyRequest(request2);
+        const encodedLength = JSON.stringify(request2).length;
         if (encodedLength > 1e5) throw new Error("Encoded request exceeds 100,000 characters.");
-        const { path, config } = buildGoogleAdsReadOnlyPath(operation, customerId);
+        const { path, config } = buildGoogleAdsReadOnlyPath(operation2, customerId);
         let response;
         if (config.method === "GET") {
           const query = {};
-          for (const [key, value] of Object.entries(request)) {
+          for (const [key, value] of Object.entries(request2)) {
             if (!["string", "number", "boolean"].includes(typeof value)) {
               throw new Error(`GET query parameter ${key} must be a string, number, or boolean.`);
             }
@@ -4811,17 +5618,17 @@ function registerGoogleAdsReadOnlyRpcTool(server, client, ok3) {
           }
           response = await client.runReadOnlyService(path, "GET", void 0, query);
         } else {
-          response = await client.runReadOnlyService(path, "POST", request);
+          response = await client.runReadOnlyService(path, "POST", request2);
         }
         return ok3({
           dataKind: "google_ads_readonly_rpc",
-          operation,
+          operation: operation2,
           purpose: config.purpose,
           scope: config.scope,
           method: config.method,
           response,
           readOnly: true,
-          warnings: operation === "generateShareablePreviews" ? ["The returned preview URL is shareable and can expose ad creative until it expires; disclose it only to intended recipients."] : [],
+          warnings: operation2 === "generateShareablePreviews" ? ["The returned preview URL is shareable and can expose ad creative until it expires; disclose it only to intended recipients."] : [],
           limitations: [
             "The request body follows Google's native REST schema and is intentionally not translated into this server's metric aliases.",
             "Availability depends on developer-token access level, account eligibility, OAuth permissions, and operation-specific quotas."
@@ -4836,8 +5643,20 @@ function registerGoogleAdsReadOnlyRpcTool(server, client, ok3) {
   );
 }
 
+// src/core/redirects.ts
+function refuseRedirect(response, api) {
+  if (response.status < 300 || response.status >= 400) return;
+  throw new Error(`${api} returned an unexpected HTTP ${response.status} redirect. Redirects are never followed. Check the configured endpoint and authorization.`);
+}
+
 // src/platforms/google-ads/client.ts
 var DEFAULT_GOOGLE_ADS_REQUEST_TIMEOUT_MS = 3e4;
+function withManagerHint(message, url, announcedManager) {
+  if (announcedManager) return message;
+  if (!/permission|PERMISSION_DENIED/i.test(message)) return message;
+  const customer = url.match(/customers\/(\d+)/)?.[1];
+  return `${message} This account may sit under a manager (MCC). Google refuses such requests unless the call names the manager in login-customer-id. Set GOOGLE_ADS_LOGIN_CUSTOMER_ID to the manager's ID` + (customer ? `, or check with google_ads_get_account_hierarchy which manager holds ${customer}` : "") + `.`;
+}
 function googleAdsRequestTimeoutMs() {
   const parsed = Number(process.env["GOOGLE_ADS_REQUEST_TIMEOUT_MS"]);
   return Number.isFinite(parsed) && parsed > 0 ? parsed : DEFAULT_GOOGLE_ADS_REQUEST_TIMEOUT_MS;
@@ -4850,6 +5669,14 @@ var GoogleAdsClient = class {
   loginCustomerId;
   accessToken = "";
   tokenExpiresAt = 0;
+  /**
+   * Le gestionnaire résolu pour un compte, ou `undefined` s'il n'en a pas.
+   *
+   * La distinction compte : `undefined` mémorisé veut dire « on a cherché et il
+   * n'y en a pas », ce qui évite de refaire la découverte à chaque appel sur un
+   * compte accessible en direct.
+   */
+  managerCache = /* @__PURE__ */ new Map();
   rateLimiter = new RateLimiter();
   keywordPlannerRateLimiter = new KeywordPlannerRateLimiter();
   constructor(config) {
@@ -4906,18 +5733,66 @@ var GoogleAdsClient = class {
   // ============================================
   // PRIVATE METHODS
   // ============================================
-  getHeaders() {
+  getHeaders(loginCustomerId) {
     const headers = {
       Authorization: `Bearer ${this.accessToken}`,
       "developer-token": this.developerToken,
       "Content-Type": "application/json"
     };
-    if (this.loginCustomerId) {
-      headers["login-customer-id"] = this.loginCustomerId;
+    const manager = loginCustomerId ?? this.loginCustomerId;
+    if (manager) {
+      headers["login-customer-id"] = stripCustomerId(manager);
     }
     return headers;
   }
-  async request(url, options = {}, beforeAttempt, deadlineAtMs) {
+  /**
+   * The manager account to announce when querying a given customer.
+   *
+   * Google rejects any request against an account managed by an MCC unless the
+   * call names that MCC in `login-customer-id`. The rejection is a bare
+   * `USER_PERMISSION_DENIED` that names neither the account nor the manager, so
+   * it reads as missing access rather than as a missing header, and that is
+   * where people lose an afternoon.
+   *
+   * `GOOGLE_ADS_LOGIN_CUSTOMER_ID` solves it when you know the answer in
+   * advance. This resolves it when you do not: if the customer is not directly
+   * accessible, the accessible managers are asked which accounts they hold, and
+   * the one holding this customer is used.
+   *
+   * Resolved once and cached for the life of the client. The hierarchy of an
+   * advertising account does not change between two tool calls, and paying two
+   * extra requests on every query to discover that it has not would be worse
+   * than the problem.
+   */
+  async resolveLoginCustomerId(customerId) {
+    if (this.loginCustomerId) return this.loginCustomerId;
+    const wanted = stripCustomerId(customerId);
+    if (this.managerCache.has(wanted)) return this.managerCache.get(wanted);
+    try {
+      const accessible = (await this.listAccessibleCustomers()).map((name) => stripCustomerId(name.replace(/^customers\//, "")));
+      if (accessible.includes(wanted)) {
+        this.managerCache.set(wanted, void 0);
+        return void 0;
+      }
+      for (const candidate of accessible) {
+        const children = await this.getClientAccounts(candidate);
+        for (const child of children) {
+          if (stripCustomerId(child.id) === wanted) {
+            this.managerCache.set(wanted, candidate);
+            return candidate;
+          }
+        }
+      }
+    } catch (error) {
+      logger.debug(
+        "google-ads",
+        `Could not resolve a manager for ${wanted}: ${error instanceof Error ? error.message : error}`
+      );
+    }
+    this.managerCache.set(wanted, void 0);
+    return void 0;
+  }
+  async request(url, options = {}, beforeAttempt, deadlineAtMs, loginCustomerId) {
     await this.ensureValidToken();
     return this.rateLimiter.execute(async () => {
       await beforeAttempt?.();
@@ -4942,10 +5817,11 @@ var GoogleAdsClient = class {
           // whatever host the redirect names.
           redirect: "error",
           headers: {
-            ...this.getHeaders(),
+            ...this.getHeaders(loginCustomerId),
             ...options.headers
           }
         });
+        refuseRedirect(response, "Google Ads API");
         if (!response.ok) {
           const errorBody = await response.json().catch(() => ({}));
           const errorDetails = errorBody?.error;
@@ -4954,7 +5830,7 @@ var GoogleAdsClient = class {
           const requestId = errorDetails?.details?.[0]?.requestId ?? errorBody?.[0]?.error?.details?.[0]?.requestId;
           const detailedMessage = gaErrors?.[0]?.message || errorDetails?.message || `Request failed: ${response.statusText}`;
           throw new GoogleAdsApiException(
-            detailedMessage,
+            withManagerHint(detailedMessage, url, loginCustomerId),
             response.status,
             errorDetails?.status,
             requestId,
@@ -5015,12 +5891,16 @@ var GoogleAdsClient = class {
   async searchStream(customerId, gaqlQuery) {
     const cleanCustomerId = stripCustomerId(customerId);
     const url = `${GOOGLE_ADS_API_BASE_URL}/customers/${cleanCustomerId}/googleAds:searchStream`;
+    const manager = await this.resolveLoginCustomerId(cleanCustomerId);
     const response = await this.request(
       url,
       {
         method: "POST",
         body: JSON.stringify({ query: gaqlQuery })
-      }
+      },
+      void 0,
+      void 0,
+      manager
     );
     const allRows = [];
     for (const batch of response) {
@@ -5037,12 +5917,19 @@ var GoogleAdsClient = class {
   async search(customerId, gaqlQuery, pageToken) {
     const cleanCustomerId = stripCustomerId(customerId);
     const url = `${GOOGLE_ADS_API_BASE_URL}/customers/${cleanCustomerId}/googleAds:search`;
+    const manager = await this.resolveLoginCustomerId(cleanCustomerId);
     const body = { query: gaqlQuery };
     if (pageToken) body.pageToken = pageToken;
-    return this.request(url, {
-      method: "POST",
-      body: JSON.stringify(body)
-    });
+    return this.request(
+      url,
+      {
+        method: "POST",
+        body: JSON.stringify(body)
+      },
+      void 0,
+      void 0,
+      manager
+    );
   }
   // ============================================
   // KEYWORD PLANNER (PLANLESS, READ-ONLY RPCS)
@@ -5195,8 +6082,8 @@ var GoogleAdsClient = class {
     return {
       id: String(row.customer?.id || cleanCustomerId),
       descriptiveName: row.customer?.descriptiveName || "Unknown Account",
-      currencyCode: row.customer?.currencyCode || "USD",
-      timeZone: row.customer?.timeZone || "America/New_York",
+      currencyCode: row.customer?.currencyCode || "",
+      timeZone: row.customer?.timeZone || "",
       manager: row.customer?.manager || false,
       testAccount: row.customer?.testAccount || false,
       resourceName: row.customer?.resourceName || `customers/${cleanCustomerId}`
@@ -5264,9 +6151,9 @@ var GoogleAdsClient = class {
   /**
    * Execute a query request with automatic query planning
    */
-  async executeQuery(request) {
+  async executeQuery(request2) {
     const startTime = Date.now();
-    const plan = planQuery(request);
+    const plan = planQuery(request2);
     const errors = [...plan.errors];
     const warnings = [...plan.warnings];
     const gaqlQueries = [];
@@ -5294,7 +6181,7 @@ var GoogleAdsClient = class {
       gaqlQueries.push(query.gaql);
       rawRequests.push({ gaql: query.gaql, resource: query.resource });
       try {
-        const apiRows = (await this.search(request.customerId, query.gaql)).results ?? [];
+        const apiRows = (await this.search(request2.customerId, query.gaql)).results ?? [];
         rawResponses.push(apiRows.slice(0, 5));
         const flatRows = apiRows.map((row) => flattenGoogleAdsRow(row));
         queryResults.push(flatRows);
@@ -5505,7 +6392,7 @@ function camelToSnakeResource(key) {
 }
 
 // src/platforms/google-ads/keyword-planner.ts
-import { z as z3 } from "zod";
+import { z as z5 } from "zod";
 var FORECAST_WITH_BREAKDOWN_TIME_BUDGET_MS = 45e3;
 var MONTHS = [
   "JANUARY",
@@ -5524,17 +6411,17 @@ var MONTHS = [
 var MONTH_NUMBER = new Map(
   MONTHS.map((month, index) => [month, index + 1])
 );
-var customerIdSchema = z3.string().regex(/^\d[\d-]*\d$|^\d$/, "Expected a numeric Google Ads customer ID, with or without dashes");
-var numericIdSchema = z3.string().regex(/^\d+$/, "Expected a numeric Google Ads criterion ID");
-var keywordTextSchema = z3.string().trim().min(1).max(80).refine(
+var customerIdSchema = z5.string().regex(/^\d[\d-]*\d$|^\d$/, "Expected a numeric Google Ads customer ID, with or without dashes");
+var numericIdSchema = z5.string().regex(/^\d+$/, "Expected a numeric Google Ads criterion ID");
+var keywordTextSchema = z5.string().trim().min(1).max(80).refine(
   (value) => value.split(/\s+/).length <= 10,
   "Google Ads keywords can contain at most 10 words"
 );
-var yearMonthSchema = z3.string().regex(/^\d{4}-(0[1-9]|1[0-2])$/, "Expected YYYY-MM");
-var isoDateSchema = z3.string().regex(/^\d{4}-\d{2}-\d{2}$/, "Expected YYYY-MM-DD");
-var networkSchema = z3.enum(["GOOGLE_SEARCH", "GOOGLE_SEARCH_AND_PARTNERS"]);
-var matchTypeSchema = z3.enum(["EXACT", "PHRASE", "BROAD"]);
-var currencyAmountSchema = z3.number().finite().min(1e-6).max(1e9);
+var yearMonthSchema = z5.string().regex(/^\d{4}-(0[1-9]|1[0-2])$/, "Expected YYYY-MM");
+var isoDateSchema = z5.string().regex(/^\d{4}-\d{2}-\d{2}$/, "Expected YYYY-MM-DD");
+var networkSchema = z5.enum(["GOOGLE_SEARCH", "GOOGLE_SEARCH_AND_PARTNERS"]);
+var matchTypeSchema = z5.enum(["EXACT", "PHRASE", "BROAD"]);
+var currencyAmountSchema = z5.number().finite().min(1e-6).max(1e9);
 function compactObject(value) {
   return Object.fromEntries(
     Object.entries(value).filter(([, fieldValue]) => fieldValue !== void 0)
@@ -5806,22 +6693,22 @@ function normalizeKeywordHistoricalMetrics(metrics, includeMonthlySearchVolumes
     trends: computeKeywordPlannerTrends(metrics?.monthlySearchVolumes)
   };
 }
-function normalizeHistoricalResult(result, includeMonthlySearchVolumes) {
+function normalizeHistoricalResult(result2, includeMonthlySearchVolumes) {
   return {
-    keyword: result.text ?? null,
-    closeVariants: result.closeVariants ?? [],
+    keyword: result2.text ?? null,
+    closeVariants: result2.closeVariants ?? [],
     metrics: normalizeKeywordHistoricalMetrics(
-      result.keywordMetrics,
+      result2.keywordMetrics,
       includeMonthlySearchVolumes
     )
   };
 }
-function normalizeIdeaResult(result) {
+function normalizeIdeaResult(result2) {
   return {
-    keyword: result.text ?? null,
-    closeVariants: result.closeVariants ?? [],
-    metrics: normalizeKeywordHistoricalMetrics(result.keywordIdeaMetrics),
-    concepts: result.keywordAnnotations?.concepts ?? []
+    keyword: result2.text ?? null,
+    closeVariants: result2.closeVariants ?? [],
+    metrics: normalizeKeywordHistoricalMetrics(result2.keywordIdeaMetrics),
+    concepts: result2.keywordAnnotations?.concepts ?? []
   };
 }
 function normalizeAggregateMetrics(results) {
@@ -5998,15 +6885,15 @@ function registerGoogleAdsKeywordPlannerTools(server, client, ok3) {
     "Get Keyword Planner search-volume history for supplied keywords. Returns average monthly searches, monthly volumes (up to 48 months), latest volume, computed 3-month and YoY changes, competition, CPC/bid ranges, close variants, and optional device totals. This is a read-only planless RPC.",
     {
       customerId: customerIdSchema.describe("Google Ads serving customer ID; use the client account, not its MCC manager"),
-      keywords: z3.array(keywordTextSchema).min(1).max(1e4).describe("Keywords to analyze; Google may combine near-exact close variants"),
-      geoTargetIds: z3.array(numericIdSchema).max(10).optional().default([]).describe("Geo target criterion IDs, e.g. 2250 for France; empty means all geographies"),
+      keywords: z5.array(keywordTextSchema).min(1).max(1e4).describe("Keywords to analyze; Google may combine near-exact close variants"),
+      geoTargetIds: z5.array(numericIdSchema).max(10).optional().default([]).describe("Geo target criterion IDs, e.g. 2250 for France; empty means all geographies"),
       languageId: numericIdSchema.optional().describe("Optional language criterion ID, e.g. 1002 for French; omit for all languages"),
       network: networkSchema.optional().default("GOOGLE_SEARCH"),
-      includeAdultKeywords: z3.boolean().optional().default(false),
-      includeAverageCpc: z3.boolean().optional().default(true).describe("Request legacy average CPC in addition to top-of-page bid ranges"),
-      includeDeviceBreakdown: z3.boolean().optional().default(false).describe("Return aggregate searches by device across all requested keywords"),
-      includeMonthlySearchVolumes: z3.boolean().optional().default(true).describe("Include every monthly point in the MCP output. Set false to trim an allowed response; Google's upstream series and the 50,000-point guard are unchanged"),
-      historyMonths: z3.number().int().min(3).max(48).optional().default(24).describe("History length when no explicit YYYY-MM range is supplied; 24 enables YoY calculation"),
+      includeAdultKeywords: z5.boolean().optional().default(false),
+      includeAverageCpc: z5.boolean().optional().default(true).describe("Request legacy average CPC in addition to top-of-page bid ranges"),
+      includeDeviceBreakdown: z5.boolean().optional().default(false).describe("Return aggregate searches by device across all requested keywords"),
+      includeMonthlySearchVolumes: z5.boolean().optional().default(true).describe("Include every monthly point in the MCP output. Set false to trim an allowed response; Google's upstream series and the 50,000-point guard are unchanged"),
+      historyMonths: z5.number().int().min(3).max(48).optional().default(24).describe("History length when no explicit YYYY-MM range is supplied; 24 enables YoY calculation"),
       startYearMonth: yearMonthSchema.optional().describe("Optional inclusive historical range start YYYY-MM"),
       endYearMonth: yearMonthSchema.optional().describe("Optional inclusive historical range end YYYY-MM")
     },
@@ -6026,7 +6913,7 @@ function registerGoogleAdsKeywordPlannerTools(server, client, ok3) {
     }) => {
       try {
         const startedAt = Date.now();
-        const { request, historyRange } = buildKeywordHistoricalMetricsRequest({
+        const { request: request2, historyRange } = buildKeywordHistoricalMetricsRequest({
           keywords,
           geoTargetIds,
           languageId,
@@ -6042,9 +6929,9 @@ function registerGoogleAdsKeywordPlannerTools(server, client, ok3) {
           keywords.length,
           historyRange.monthCount
         );
-        const response = await client.generateKeywordHistoricalMetrics(customerId, request);
-        const results = (response.results ?? []).map((result) => normalizeHistoricalResult(
-          result,
+        const response = await client.generateKeywordHistoricalMetrics(customerId, request2);
+        const results = (response.results ?? []).map((result2) => normalizeHistoricalResult(
+          result2,
           includeMonthlySearchVolumes
         ));
         const warnings = [];
@@ -6098,21 +6985,21 @@ function registerGoogleAdsKeywordPlannerTools(server, client, ok3) {
     "Discover Keyword Planner ideas from up to 20 seed keywords, a URL, keywords plus URL, or a whole site. Returns historical volume, monthly trends, computed 3-month/YoY changes, competition, bids, close variants, optional concepts, and pagination. Read-only; no plan is saved.",
     {
       customerId: customerIdSchema.describe("Google Ads serving customer ID; use the client account, not its MCC manager"),
-      seedKeywords: z3.array(keywordTextSchema).min(1).max(20).optional(),
-      url: z3.string().trim().min(1).optional().describe("Specific page URL to crawl; combine with seedKeywords if desired"),
-      site: z3.string().trim().min(1).optional().describe("Whole-domain seed; exclusive with seedKeywords/url"),
-      geoTargetIds: z3.array(numericIdSchema).max(10).optional().default([]),
+      seedKeywords: z5.array(keywordTextSchema).min(1).max(20).optional(),
+      url: z5.string().trim().min(1).optional().describe("Specific page URL to crawl; combine with seedKeywords if desired"),
+      site: z5.string().trim().min(1).optional().describe("Whole-domain seed; exclusive with seedKeywords/url"),
+      geoTargetIds: z5.array(numericIdSchema).max(10).optional().default([]),
       languageId: numericIdSchema.optional(),
       network: networkSchema.optional().default("GOOGLE_SEARCH"),
-      includeAdultKeywords: z3.boolean().optional().default(false),
-      includeAverageCpc: z3.boolean().optional().default(true),
-      includeDeviceBreakdown: z3.boolean().optional().default(false),
-      includeKeywordConcepts: z3.boolean().optional().default(true),
-      historyMonths: z3.number().int().min(3).max(48).optional().default(13).describe("13 months is enough to compute latest-month YoY while limiting response size"),
+      includeAdultKeywords: z5.boolean().optional().default(false),
+      includeAverageCpc: z5.boolean().optional().default(true),
+      includeDeviceBreakdown: z5.boolean().optional().default(false),
+      includeKeywordConcepts: z5.boolean().optional().default(true),
+      historyMonths: z5.number().int().min(3).max(48).optional().default(13).describe("13 months is enough to compute latest-month YoY while limiting response size"),
       startYearMonth: yearMonthSchema.optional(),
       endYearMonth: yearMonthSchema.optional(),
-      pageSize: z3.number().int().min(1).max(1e4).optional().default(100).describe("Google supports up to 10,000; keep pages small for interactive MCP use and use larger pages only for controlled exports"),
-      pageToken: z3.string().optional().describe("nextPageToken from a prior identical request")
+      pageSize: z5.number().int().min(1).max(1e4).optional().default(100).describe("Google supports up to 10,000; keep pages small for interactive MCP use and use larger pages only for controlled exports"),
+      pageToken: z5.string().optional().describe("nextPageToken from a prior identical request")
     },
     async ({
       customerId,
@@ -6134,7 +7021,7 @@ function registerGoogleAdsKeywordPlannerTools(server, client, ok3) {
     }) => {
       try {
         const startedAt = Date.now();
-        const { request, historyRange, seedType } = buildKeywordIdeasRequest({
+        const { request: request2, historyRange, seedType } = buildKeywordIdeasRequest({
           seedKeywords,
           url,
           site,
@@ -6155,7 +7042,7 @@ function registerGoogleAdsKeywordPlannerTools(server, client, ok3) {
           pageSize,
           historyRange.monthCount
         );
-        const response = await client.generateKeywordIdeas(customerId, request);
+        const response = await client.generateKeywordIdeas(customerId, request2);
         const ideas = (response.results ?? []).map(normalizeIdeaResult);
         const nextPageToken = response.nextPageToken ?? null;
         return ok3({
@@ -6204,23 +7091,23 @@ function registerGoogleAdsKeywordPlannerTools(server, client, ok3) {
     "Forecast impressions, clicks, CTR, CPC, cost, conversions, and CPA for a temporary keyword campaign. Supports targeting, negatives, match type, three bidding strategies, explicit future dates, and an optional independent per-keyword breakdown. This read-only planless RPC does not create a campaign or saved plan.",
     {
       customerId: customerIdSchema.describe("Google Ads serving customer ID; use a relevant client account for better estimates"),
-      keywords: z3.array(keywordTextSchema).min(1).max(1e3),
+      keywords: z5.array(keywordTextSchema).min(1).max(1e3),
       matchType: matchTypeSchema.optional().default("BROAD"),
-      negativeKeywords: z3.array(keywordTextSchema).max(1e3).optional().default([]),
+      negativeKeywords: z5.array(keywordTextSchema).max(1e3).optional().default([]),
       negativeMatchType: matchTypeSchema.optional().default("BROAD"),
-      geoTargetIds: z3.array(numericIdSchema).max(20).optional().default([]),
-      languageIds: z3.array(numericIdSchema).max(10).optional().default([]),
+      geoTargetIds: z5.array(numericIdSchema).max(20).optional().default([]),
+      languageIds: z5.array(numericIdSchema).max(10).optional().default([]),
       network: networkSchema.optional().default("GOOGLE_SEARCH"),
-      biddingStrategy: z3.enum(["MANUAL_CPC", "MAXIMIZE_CLICKS", "MAXIMIZE_CONVERSIONS"]).optional().default("MANUAL_CPC"),
+      biddingStrategy: z5.enum(["MANUAL_CPC", "MAXIMIZE_CLICKS", "MAXIMIZE_CONVERSIONS"]).optional().default("MANUAL_CPC"),
       maxCpcBid: currencyAmountSchema.optional().describe("Bid in standard account-currency units; required for MANUAL_CPC"),
       dailyBudget: currencyAmountSchema.optional().describe("Daily amount in standard currency units; required for maximize strategies and optional for MANUAL_CPC"),
       maxCpcBidCeiling: currencyAmountSchema.optional().describe("Optional standard-currency CPC ceiling for MAXIMIZE_CLICKS"),
-      conversionRate: z3.number().finite().min(0).max(1).optional().describe("Expected conversion rate as a decimal, e.g. 0.02 for 2%"),
-      currencyCode: z3.string().regex(/^[A-Z]{3}$/).optional().describe("Optional ISO 4217 conversion currency; account currency is used by default"),
+      conversionRate: z5.number().finite().min(0).max(1).optional().describe("Expected conversion rate as a decimal, e.g. 0.02 for 2%"),
+      currencyCode: z5.string().regex(/^[A-Z]{3}$/).optional().describe("Optional ISO 4217 conversion currency; account currency is used by default"),
       startDate: isoDateSchema.optional().describe("Optional inclusive future forecast start YYYY-MM-DD; supply with endDate"),
       endDate: isoDateSchema.optional().describe("Optional inclusive forecast end YYYY-MM-DD, no more than one year ahead; supply with startDate"),
-      includeKeywordBreakdown: z3.boolean().optional().default(false).describe("Make independent one-keyword forecast calls in addition to the combined campaign forecast"),
-      keywordBreakdownLimit: z3.number().int().min(1).max(20).optional().default(10).describe("Safety cap for additional rate-limited Keyword Planner requests")
+      includeKeywordBreakdown: z5.boolean().optional().default(false).describe("Make independent one-keyword forecast calls in addition to the combined campaign forecast"),
+      keywordBreakdownLimit: z5.number().int().min(1).max(20).optional().default(10).describe("Safety cap for additional rate-limited Keyword Planner requests")
     },
     async ({
       customerId,
@@ -6261,11 +7148,11 @@ function registerGoogleAdsKeywordPlannerTools(server, client, ok3) {
           startDate,
           endDate
         };
-        const { request, periodDays } = buildKeywordForecastRequest(baseInput);
+        const { request: request2, periodDays } = buildKeywordForecastRequest(baseInput);
         const deadlineAtMs = includeKeywordBreakdown ? startedAt + FORECAST_WITH_BREAKDOWN_TIME_BUDGET_MS : void 0;
         const response = await client.generateKeywordForecastMetrics(
           customerId,
-          request,
+          request2,
           deadlineAtMs
         );
         const campaignForecast = normalizeKeywordForecastMetrics(
@@ -6355,7 +7242,7 @@ function registerGoogleAdsKeywordPlannerTools(server, client, ok3) {
 }
 
 // src/platforms/google-ads/discovery-tools.ts
-import { z as z4 } from "zod";
+import { z as z6 } from "zod";
 var FIELD_COLUMNS = [
   "name",
   "category",
@@ -6371,12 +7258,12 @@ var FIELD_COLUMNS = [
   "metrics",
   "segments"
 ].join(", ");
-var customerIdSchema2 = z4.string().regex(
+var customerIdSchema2 = z6.string().regex(
   /^\d[\d-]*\d$|^\d$/,
   "Expected a numeric Google Ads customer ID, with or without dashes"
 );
-var numericIdSchema2 = z4.string().regex(/^\d+$/, "Expected a numeric Google Ads ID");
-var fieldCategorySchema = z4.enum([
+var numericIdSchema2 = z6.string().regex(/^\d+$/, "Expected a numeric Google Ads ID");
+var fieldCategorySchema = z6.enum([
   "RESOURCE",
   "ATTRIBUTE",
   "SEGMENT",
@@ -6431,14 +7318,14 @@ function registerGoogleAdsDiscoveryTools(server, client, ok3) {
     "google_ads_search_fields",
     "Search Google's live GoogleAdsField catalog. Discovers every queryable GAQL resource, attribute, segment, metric, enum value, and selectable-with compatibility relationship. Read-only and useful before a raw GAQL query.",
     {
-      query: z4.string().trim().min(6).max(5e4).optional().describe("Optional raw GoogleAdsField SELECT query. When provided it replaces the structured filters."),
-      nameContains: z4.string().trim().min(1).max(250).optional().describe("Case-sensitive field-name substring, e.g. conversion or asset_group"),
+      query: z6.string().trim().min(6).max(5e4).optional().describe("Optional raw GoogleAdsField SELECT query. When provided it replaces the structured filters."),
+      nameContains: z6.string().trim().min(1).max(250).optional().describe("Case-sensitive field-name substring, e.g. conversion or asset_group"),
       category: fieldCategorySchema.optional(),
-      selectable: z4.boolean().optional(),
-      filterable: z4.boolean().optional(),
-      sortable: z4.boolean().optional(),
-      pageSize: z4.number().int().min(1).max(1e4).optional().default(500),
-      pageToken: z4.string().trim().min(1).max(1e4).optional()
+      selectable: z6.boolean().optional(),
+      filterable: z6.boolean().optional(),
+      sortable: z6.boolean().optional(),
+      pageSize: z6.number().int().min(1).max(1e4).optional().default(500),
+      pageToken: z6.string().trim().min(1).max(1e4).optional()
     },
     async ({ query, nameContains, category, selectable, filterable, sortable, pageSize, pageToken }) => {
       try {
@@ -6481,22 +7368,22 @@ function registerGoogleAdsDiscoveryTools(server, client, ok3) {
     "google_ads_suggest_geo_targets",
     "Resolve up to 25 location names or geo target IDs to Google Ads geoTargetConstants. Returns criterion IDs, canonical names, target types, status, parents, locale, and approximate reach. Read-only.",
     {
-      locationNames: z4.array(z4.string().trim().min(1).max(250)).min(1).max(25).optional(),
-      geoTargetIds: z4.array(numericIdSchema2).min(1).max(25).optional(),
-      locale: z4.string().trim().regex(/^[A-Za-z]{2,3}(?:[-_][A-Za-z]{2,4})?$/, "Expected a locale such as en, fr, or pt-BR").optional().default("en"),
-      countryCode: z4.string().trim().regex(/^[A-Za-z]{2}$/, "Expected an ISO-3166 alpha-2 country code").optional().transform((value) => value?.toUpperCase())
+      locationNames: z6.array(z6.string().trim().min(1).max(250)).min(1).max(25).optional(),
+      geoTargetIds: z6.array(numericIdSchema2).min(1).max(25).optional(),
+      locale: z6.string().trim().regex(/^[A-Za-z]{2,3}(?:[-_][A-Za-z]{2,4})?$/, "Expected a locale such as en, fr, or pt-BR").optional().default("en"),
+      countryCode: z6.string().trim().regex(/^[A-Za-z]{2}$/, "Expected an ISO-3166 alpha-2 country code").optional().transform((value) => value?.toUpperCase())
     },
     async ({ locationNames, geoTargetIds, locale, countryCode }) => {
       try {
         if (Boolean(locationNames?.length) === Boolean(geoTargetIds?.length)) {
           throw new Error("Provide exactly one of locationNames or geoTargetIds.");
         }
-        const request = {
+        const request2 = {
           locale,
           ...countryCode ? { countryCode } : {},
           ...locationNames ? { locationNames: { names: [...new Set(locationNames)] } } : { geoTargets: { geoTargetConstants: [...new Set(geoTargetIds)].map((id) => `geoTargetConstants/${id}`) } }
         };
-        const response = await client.suggestGeoTargetConstants(request);
+        const response = await client.suggestGeoTargetConstants(request2);
         const suggestions = (response.geoTargetConstantSuggestions ?? []).map((suggestion) => ({
           searchTerm: suggestion.searchTerm ?? null,
           locale: suggestion.locale ?? locale,
@@ -6510,7 +7397,7 @@ function registerGoogleAdsDiscoveryTools(server, client, ok3) {
           dataKind: "geo_target_suggestions",
           suggestions,
           count: suggestions.length,
-          request,
+          request: request2,
           readOnly: true,
           warnings: [],
           limitations: ["Reach is approximate and rounded by Google."],
@@ -6526,19 +7413,19 @@ function registerGoogleAdsDiscoveryTools(server, client, ok3) {
     "Organize supplied keywords into existing Google Ads ad groups. Returns suggested ad group/campaign pairings, normalized keyword text, and suggested match type without creating or editing keywords. Read-only Keyword Planner RPC.",
     {
       customerId: customerIdSchema2.describe("Serving customer ID containing the existing ad groups"),
-      keywords: z4.array(z4.string().trim().min(1).max(80)).min(1).max(1e3),
-      adGroupIds: z4.array(numericIdSchema2).min(1).max(200).describe("Existing ad group IDs in the same customer account")
+      keywords: z6.array(z6.string().trim().min(1).max(80)).min(1).max(1e3),
+      adGroupIds: z6.array(numericIdSchema2).min(1).max(200).describe("Existing ad group IDs in the same customer account")
     },
     async ({ customerId, keywords, adGroupIds }) => {
       try {
         const cleanCustomerId = customerId.replace(/-/g, "");
-        const request = {
+        const request2 = {
           keywords: [...new Set(keywords)],
           adGroups: [...new Set(adGroupIds)].map(
             (id) => `customers/${cleanCustomerId}/adGroups/${id}`
           )
         };
-        const response = await client.generateAdGroupThemes(cleanCustomerId, request);
+        const response = await client.generateAdGroupThemes(cleanCustomerId, request2);
         const suggestions = response.adGroupKeywordSuggestions ?? [];
         const unusableAdGroups = response.unusableAdGroups ?? [];
         return ok3({
@@ -6547,8 +7434,8 @@ function registerGoogleAdsDiscoveryTools(server, client, ok3) {
           suggestionCount: suggestions.length,
           unusableAdGroups,
           unusableAdGroupCount: unusableAdGroups.length,
-          requestedKeywordCount: request.keywords.length,
-          requestedAdGroupCount: request.adGroups.length,
+          requestedKeywordCount: request2.keywords.length,
+          requestedAdGroupCount: request2.adGroups.length,
           readOnly: true,
           warnings: unusableAdGroups.length ? ["Google could not use one or more supplied ad groups; inspect unusableAdGroups for their campaign context."] : [],
           limitations: ["This RPC suggests organization into existing ad groups; it does not create themes, ad groups, or keywords."],
@@ -6562,11 +7449,11 @@ function registerGoogleAdsDiscoveryTools(server, client, ok3) {
 }
 
 // src/platforms/google-ads/tools.ts
-var customerIdSchema3 = z5.string().describe("Google Ads customer ID (without dashes, e.g., 1234567890)");
-var loginCustomerIdSchema = z5.string().optional().describe("MCC Manager account ID (required for sub-accounts managed by an MCC)");
-var isoDateSchema2 = z5.string().regex(/^\d{4}-\d{2}-\d{2}$/, "Expected date format YYYY-MM-DD");
-var numericIdSchema3 = z5.string().regex(/^\d+$/, "Expected a numeric Google Ads ID");
-var gaqlEnumSchema = z5.string().regex(/^[A-Z0-9_]+$/, "Expected an uppercase Google Ads enum value");
+var customerIdSchema3 = z7.string().describe("Google Ads customer ID (without dashes, e.g., 1234567890)");
+var loginCustomerIdSchema = z7.string().optional().describe("MCC Manager account ID (required for sub-accounts managed by an MCC)");
+var isoDateSchema2 = z7.string().regex(/^\d{4}-\d{2}-\d{2}$/, "Expected date format YYYY-MM-DD");
+var numericIdSchema3 = z7.string().regex(/^\d+$/, "Expected a numeric Google Ads ID");
+var gaqlEnumSchema = z7.string().regex(/^[A-Z0-9_]+$/, "Expected an uppercase Google Ads enum value");
 var ZERO_METRIC_LIMIT_WARNING = "All returned rows have zero metric values and rowCount equals the requested limit. The response may be truncated before active entities; retry with a higher limit or pass orderBy on a non-zero metric.";
 function isAgentResponseRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -6729,6 +7616,35 @@ function normalizeChangeEventRange(startDate, endDate) {
     warnings
   };
 }
+function recordOf(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+}
+function assetIdFromResourceName(value) {
+  if (typeof value !== "string") return void 0;
+  return value.match(/\/assets\/(\d+)$/)?.[1];
+}
+function youtubeDerivedUrls(videoId) {
+  if (typeof videoId !== "string" || !/^[A-Za-z0-9_-]{5,20}$/.test(videoId)) return void 0;
+  return {
+    watch_url: `https://www.youtube.com/watch?v=${videoId}`,
+    embed_url: `https://www.youtube.com/embed/${videoId}`,
+    thumbnail_url: `https://i.ytimg.com/vi/${videoId}/maxresdefault.jpg`,
+    thumbnail_fallback_url: `https://i.ytimg.com/vi/${videoId}/hqdefault.jpg`
+  };
+}
+function collectAssetIds(value, into) {
+  const id = assetIdFromResourceName(value);
+  if (id) {
+    into.add(id);
+    return;
+  }
+  if (Array.isArray(value)) {
+    for (const item of value) collectAssetIds(item, into);
+    return;
+  }
+  const record = recordOf(value);
+  if (record) for (const item of Object.values(record)) collectAssetIds(item, into);
+}
 async function runGaqlWithFallback(client, customerId, attempts) {
   const warnings = [];
   let lastError;
@@ -6816,7 +7732,7 @@ function registerGoogleAdsTools(server, config) {
 Example: SELECT campaign.name, metrics.impressions FROM campaign WHERE campaign.status = 'ENABLED' AND segments.date DURING LAST_30_DAYS ORDER BY metrics.impressions DESC LIMIT 100`,
     {
       customerId: customerIdSchema3,
-      query: z5.string().min(10).describe("GAQL query string (SELECT ... FROM ... WHERE ...)")
+      query: z7.string().min(10).describe("GAQL query string (SELECT ... FROM ... WHERE ...)")
     },
     async ({ customerId, query }) => {
       try {
@@ -6833,12 +7749,12 @@ Example: SELECT campaign.name, metrics.impressions FROM campaign WHERE campaign.
 Use google-ads://metrics for available metrics, google-ads://dimensions for dimensions.`,
     {
       customerId: customerIdSchema3,
-      resource: z5.string().optional().default("campaign").describe("GAQL FROM clause resource type (campaign, ad_group, ad_group_ad, keyword_view, shopping_performance_view, asset_group, geographic_view, video, search_term_view, landing_page_view, etc.)"),
-      metrics: z5.array(z5.string()).min(1).describe("Metric keys (e.g., impressions, clicks, cost_micros, conversions)"),
-      dimensions: z5.array(z5.string()).optional().describe("Dimension keys (e.g., date, campaignName, device)"),
-      startDate: z5.string().optional().describe("Start date YYYY-MM-DD"),
-      endDate: z5.string().optional().describe("End date YYYY-MM-DD"),
-      datePreset: z5.enum([
+      resource: z7.string().optional().default("campaign").describe("GAQL FROM clause resource type (campaign, ad_group, ad_group_ad, keyword_view, shopping_performance_view, asset_group, geographic_view, video, search_term_view, landing_page_view, etc.)"),
+      metrics: z7.array(z7.string()).min(1).describe("Metric keys (e.g., impressions, clicks, cost_micros, conversions)"),
+      dimensions: z7.array(z7.string()).optional().describe("Dimension keys (e.g., date, campaignName, device)"),
+      startDate: z7.string().optional().describe("Start date YYYY-MM-DD"),
+      endDate: z7.string().optional().describe("End date YYYY-MM-DD"),
+      datePreset: z7.enum([
         "TODAY",
         "YESTERDAY",
         "LAST_7_DAYS",
@@ -6850,9 +7766,9 @@ Use google-ads://metrics for available metrics, google-ads://dimensions for dime
         "THIS_QUARTER",
         "LAST_QUARTER"
       ]).optional().describe("Predefined date range"),
-      orderBy: z5.string().optional().describe("Optional GAQL field to order by, e.g. metrics.impressions or campaign.name"),
-      orderDirection: z5.enum(["ASC", "DESC"]).optional().default("DESC"),
-      limit: z5.number().int().min(1).max(1e4).optional().default(500)
+      orderBy: z7.string().optional().describe("Optional GAQL field to order by, e.g. metrics.impressions or campaign.name"),
+      orderDirection: z7.enum(["ASC", "DESC"]).optional().default("DESC"),
+      limit: z7.number().int().min(1).max(1e4).optional().default(500)
     },
     async ({ customerId, resource, metrics, dimensions, startDate, endDate, datePreset, orderBy, orderDirection, limit }) => {
       try {
@@ -6879,7 +7795,7 @@ Use google-ads://metrics for available metrics, google-ads://dimensions for dime
             gaqlPreview: generateQueryPreview(plan)
           });
         }
-        const result = await client.executeQuery({
+        const result2 = await client.executeQuery({
           customerId,
           resource,
           metrics,
@@ -6892,18 +7808,18 @@ Use google-ads://metrics for available metrics, google-ads://dimensions for dime
           orderDirection,
           limit
         });
-        const debugWarnings = Array.isArray(result.debug.warnings) ? result.debug.warnings : [];
-        const debugErrors = Array.isArray(result.debug.errors) ? result.debug.errors : [];
-        const zeroMetricLimitWarnings = result.data.length === limit && allReturnedMetricValuesAreZero(result.data, metrics) ? [ZERO_METRIC_LIMIT_WARNING] : [];
+        const debugWarnings = Array.isArray(result2.debug.warnings) ? result2.debug.warnings : [];
+        const debugErrors = Array.isArray(result2.debug.errors) ? result2.debug.errors : [];
+        const zeroMetricLimitWarnings = result2.data.length === limit && allReturnedMetricValuesAreZero(result2.data, metrics) ? [ZERO_METRIC_LIMIT_WARNING] : [];
         const warnings = [...dateInput.warnings, ...debugWarnings, ...zeroMetricLimitWarnings];
         return ok({
           status: debugErrors.length > 0 ? "error" : "ok",
-          data: result.data,
-          rowCount: result.data.length,
+          data: result2.data,
+          rowCount: result2.data.length,
           errors: debugErrors,
           warnings,
           debug: {
-            ...result.debug,
+            ...result2.debug,
             warnings,
             executionTimeMs: Date.now() - startTime,
             gaqlPreview: generateQueryPreview(plan)
@@ -6919,8 +7835,8 @@ Use google-ads://metrics for available metrics, google-ads://dimensions for dime
     "List campaigns for a Google Ads account with status, budget, channel type, and bidding strategy.",
     {
       customerId: customerIdSchema3,
-      statusFilter: z5.enum(["ENABLED", "PAUSED", "REMOVED"]).optional(),
-      limit: z5.number().int().min(1).max(1e3).optional().default(100)
+      statusFilter: z7.enum(["ENABLED", "PAUSED", "REMOVED"]).optional(),
+      limit: z7.number().int().min(1).max(1e3).optional().default(100)
     },
     async ({ customerId, statusFilter, limit }) => {
       try {
@@ -6939,9 +7855,9 @@ Use google-ads://metrics for available metrics, google-ads://dimensions for dime
     "List ad groups for a Google Ads account, optionally filtered by campaign.",
     {
       customerId: customerIdSchema3,
-      campaignId: z5.string().optional().describe("Filter by campaign ID"),
-      statusFilter: z5.enum(["ENABLED", "PAUSED", "REMOVED"]).optional(),
-      limit: z5.number().int().min(1).max(1e3).optional().default(100)
+      campaignId: z7.string().optional().describe("Filter by campaign ID"),
+      statusFilter: z7.enum(["ENABLED", "PAUSED", "REMOVED"]).optional(),
+      limit: z7.number().int().min(1).max(1e3).optional().default(100)
     },
     async ({ customerId, campaignId, statusFilter, limit }) => {
       try {
@@ -6963,9 +7879,9 @@ Use google-ads://metrics for available metrics, google-ads://dimensions for dime
     "Get keyword-level performance data from keyword_view resource. Shows quality score, impressions, clicks, cost.",
     {
       customerId: customerIdSchema3,
-      startDate: z5.string().describe("Start date YYYY-MM-DD"),
-      endDate: z5.string().describe("End date YYYY-MM-DD"),
-      limit: z5.number().int().min(1).max(1e3).optional().default(100)
+      startDate: z7.string().describe("Start date YYYY-MM-DD"),
+      endDate: z7.string().describe("End date YYYY-MM-DD"),
+      limit: z7.number().int().min(1).max(1e3).optional().default(100)
     },
     async ({ customerId, startDate, endDate, limit }) => {
       try {
@@ -6981,14 +7897,14 @@ Use google-ads://metrics for available metrics, google-ads://dimensions for dime
     "google_ads_validate_query",
     "Validate metric/dimension/resource compatibility BEFORE executing a query. Checks segment restrictions and resource availability.",
     {
-      metrics: z5.array(z5.string()).min(1).describe("Metric keys to validate"),
-      dimensions: z5.array(z5.string()).optional().describe("Dimension keys to validate"),
-      resource: z5.string().optional().default("campaign")
+      metrics: z7.array(z7.string()).min(1).describe("Metric keys to validate"),
+      dimensions: z7.array(z7.string()).optional().describe("Dimension keys to validate"),
+      resource: z7.string().optional().default("campaign")
     },
     async ({ metrics, dimensions, resource }) => {
       try {
-        const result = validateQuerySelection(metrics, dimensions ?? [], resource, dimensions ?? []);
-        return ok(result);
+        const result2 = validateQuerySelection(metrics, dimensions ?? [], resource, dimensions ?? []);
+        return ok(result2);
       } catch (e) {
         return formatMcpToolError(e);
       }
@@ -7018,7 +7934,9 @@ Use google-ads://metrics for available metrics, google-ads://dimensions for dime
           warnings.push("GOOGLE_ADS_LOGIN_CUSTOMER_ID is configured but was not returned by listAccessibleCustomers; verify MCC access if child account queries fail.");
         }
         if (!loginCustomerId && accessibleCustomers.some((customer) => customer.manager)) {
-          warnings.push("Manager accounts are accessible but GOOGLE_ADS_LOGIN_CUSTOMER_ID is not set. Set it to the MCC ID when querying managed child accounts.");
+          warnings.push(
+            "Manager accounts are accessible and GOOGLE_ADS_LOGIN_CUSTOMER_ID is not set. The server resolves the manager of each account it queries, so this is not a fault on its own. Setting the variable skips that discovery and is worth it when every account sits under the same MCC."
+          );
         }
         return ok({
           status: "ok",
@@ -7049,7 +7967,7 @@ Use google-ads://metrics for available metrics, google-ads://dimensions for dime
     "List accessible customers and, where possible, manager/client relationships from GAQL customer_client. Falls back to accessible customers if hierarchy queries are unavailable.",
     {
       managerCustomerId: loginCustomerIdSchema,
-      includeInactive: z5.boolean().optional().default(false).describe("Include non-ENABLED customer_client links")
+      includeInactive: z7.boolean().optional().default(false).describe("Include non-ENABLED customer_client links")
     },
     async ({ managerCustomerId, includeInactive }) => {
       try {
@@ -7124,8 +8042,8 @@ Use google-ads://metrics for available metrics, google-ads://dimensions for dime
     "List conversion actions with status, type, category, primary/include-in-conversions flags, owner customer, and last activity dates when supported.",
     {
       customerId: customerIdSchema3,
-      statusFilter: z5.enum(["ENABLED", "HIDDEN", "REMOVED"]).optional(),
-      limit: z5.number().int().min(1).max(1e3).optional().default(1e3)
+      statusFilter: z7.enum(["ENABLED", "HIDDEN", "REMOVED"]).optional(),
+      limit: z7.number().int().min(1).max(1e3).optional().default(1e3)
     },
     async ({ customerId, statusFilter, limit }) => {
       try {
@@ -7164,11 +8082,11 @@ Use google-ads://metrics for available metrics, google-ads://dimensions for dime
           ORDER BY conversion_action.name ASC
           LIMIT ${limit}
         `);
-        const result = await runGaqlWithFallback(client, customerId, [
+        const result2 = await runGaqlWithFallback(client, customerId, [
           { label: "conversion_action_with_last_activity", gaql: richGaql, failureWarning: "Conversion action query with last activity metrics failed" },
           { label: "conversion_action_minimal", gaql: fallbackGaql }
         ]);
-        return ok({ conversionActions: result.rows, count: result.rows.length, gaql: result.gaql, warnings: result.warnings });
+        return ok({ conversionActions: result2.rows, count: result2.rows.length, gaql: result2.gaql, warnings: result2.warnings });
       } catch (e) {
         return formatMcpToolError(e);
       }
@@ -7183,10 +8101,10 @@ Use google-ads://metrics for available metrics, google-ads://dimensions for dime
       endDate: isoDateSchema2.optional().describe("End date YYYY-MM-DD. Defaults to today."),
       resourceType: gaqlEnumSchema.optional().describe("Optional ChangeEventResourceType filter, e.g. CAMPAIGN or AD_GROUP_AD"),
       operation: gaqlEnumSchema.optional().describe("Optional ResourceChangeOperation filter, e.g. CREATE, UPDATE, REMOVE"),
-      userEmail: z5.string().email().optional().describe("Optional user email filter"),
-      limit: z5.number().int().min(1).max(1e4).optional().default(1e3)
+      userEmail: z7.string().email().optional().describe("Optional user email filter"),
+      limit: z7.number().int().min(1).max(1e4).optional().default(1e3)
     },
-    async ({ customerId, startDate, endDate, resourceType, operation, userEmail, limit }) => {
+    async ({ customerId, startDate, endDate, resourceType, operation: operation2, userEmail, limit }) => {
       try {
         const range = normalizeChangeEventRange(startDate, endDate);
         const where = [
@@ -7194,7 +8112,7 @@ Use google-ads://metrics for available metrics, google-ads://dimensions for dime
           `change_event.change_date_time < '${range.endExclusiveDate}'`
         ];
         if (resourceType) where.push(`change_event.change_resource_type = '${resourceType}'`);
-        if (operation) where.push(`change_event.resource_change_operation = '${operation}'`);
+        if (operation2) where.push(`change_event.resource_change_operation = '${operation2}'`);
         if (userEmail) where.push(`change_event.user_email = '${quoteGaqlString(userEmail)}'`);
         const gaql = oneLineGaql(`
           SELECT
@@ -7232,8 +8150,8 @@ Use google-ads://metrics for available metrics, google-ads://dimensions for dime
     {
       customerId: customerIdSchema3,
       typeFilter: gaqlEnumSchema.optional().describe("Optional RecommendationType enum filter"),
-      includeDismissed: z5.boolean().optional().default(false),
-      limit: z5.number().int().min(1).max(1e3).optional().default(1e3)
+      includeDismissed: z7.boolean().optional().default(false),
+      limit: z7.number().int().min(1).max(1e3).optional().default(1e3)
     },
     async ({ customerId, typeFilter, includeDismissed, limit }) => {
       try {
@@ -7273,11 +8191,11 @@ Use google-ads://metrics for available metrics, google-ads://dimensions for dime
           ORDER BY recommendation.type ASC
           LIMIT ${limit}
         `);
-        const result = await runGaqlWithFallback(client, customerId, [
+        const result2 = await runGaqlWithFallback(client, customerId, [
           { label: "recommendations_with_impact", gaql: richGaql, failureWarning: "Recommendation query with attributed resources/impact failed" },
           { label: "recommendations_minimal", gaql: fallbackGaql }
         ]);
-        return ok({ recommendations: result.rows, count: result.rows.length, gaql: result.gaql, warnings: result.warnings });
+        return ok({ recommendations: result2.rows, count: result2.rows.length, gaql: result2.gaql, warnings: result2.warnings });
       } catch (e) {
         return formatMcpToolError(e);
       }
@@ -7288,8 +8206,8 @@ Use google-ads://metrics for available metrics, google-ads://dimensions for dime
     "List campaign budgets with amount, status, delivery method, and recommended budget fields when supported.",
     {
       customerId: customerIdSchema3,
-      statusFilter: z5.enum(["ENABLED", "REMOVED", "UNKNOWN", "UNSPECIFIED"]).optional(),
-      limit: z5.number().int().min(1).max(1e3).optional().default(1e3)
+      statusFilter: z7.enum(["ENABLED", "REMOVED", "UNKNOWN", "UNSPECIFIED"]).optional(),
+      limit: z7.number().int().min(1).max(1e3).optional().default(1e3)
     },
     async ({ customerId, statusFilter, limit }) => {
       try {
@@ -7333,11 +8251,11 @@ Use google-ads://metrics for available metrics, google-ads://dimensions for dime
           ORDER BY campaign_budget.name ASC
           LIMIT ${limit}
         `);
-        const result = await runGaqlWithFallback(client, customerId, [
+        const result2 = await runGaqlWithFallback(client, customerId, [
           { label: "campaign_budget_with_recommendations", gaql: richGaql, failureWarning: "Campaign budget query with recommended budget fields failed" },
           { label: "campaign_budget_minimal", gaql: fallbackGaql }
         ]);
-        return ok({ budgets: result.rows, count: result.rows.length, gaql: result.gaql, warnings: result.warnings });
+        return ok({ budgets: result2.rows, count: result2.rows.length, gaql: result2.gaql, warnings: result2.warnings });
       } catch (e) {
         return formatMcpToolError(e);
       }
@@ -7351,7 +8269,7 @@ Use google-ads://metrics for available metrics, google-ads://dimensions for dime
       startDate: isoDateSchema2.optional().describe("Optional start date YYYY-MM-DD for metrics"),
       endDate: isoDateSchema2.optional().describe("Optional end date YYYY-MM-DD for metrics"),
       typeFilter: gaqlEnumSchema.optional().describe("Optional BiddingStrategyType enum filter"),
-      limit: z5.number().int().min(1).max(1e3).optional().default(1e3)
+      limit: z7.number().int().min(1).max(1e3).optional().default(1e3)
     },
     async ({ customerId, startDate, endDate, typeFilter, limit }) => {
       try {
@@ -7398,11 +8316,11 @@ Use google-ads://metrics for available metrics, google-ads://dimensions for dime
           ORDER BY bidding_strategy.name ASC
           LIMIT ${limit}
         `);
-        const result = await runGaqlWithFallback(client, customerId, [
+        const result2 = await runGaqlWithFallback(client, customerId, [
           { label: "bidding_strategy_requested", gaql, failureWarning: "Bidding strategy query with requested fields failed" },
           { label: "bidding_strategy_structure", gaql: fallbackGaql }
         ]);
-        return ok({ biddingStrategies: result.rows, count: result.rows.length, gaql: result.gaql, warnings: [...warnings, ...result.warnings] });
+        return ok({ biddingStrategies: result2.rows, count: result2.rows.length, gaql: result2.gaql, warnings: [...warnings, ...result2.warnings] });
       } catch (e) {
         return formatMcpToolError(e);
       }
@@ -7413,13 +8331,13 @@ Use google-ads://metrics for available metrics, google-ads://dimensions for dime
     "Fetch search term performance from search_term_view or campaign_search_term_insight depending on reportType.",
     {
       customerId: customerIdSchema3,
-      reportType: z5.enum(["search_term_view", "campaign_search_term_insight"]).optional().default("search_term_view"),
+      reportType: z7.enum(["search_term_view", "campaign_search_term_insight"]).optional().default("search_term_view"),
       startDate: isoDateSchema2.describe("Start date YYYY-MM-DD"),
       endDate: isoDateSchema2.describe("End date YYYY-MM-DD"),
       campaignId: numericIdSchema3.optional().describe("Optional campaign ID filter"),
       adGroupId: numericIdSchema3.optional().describe("Optional ad group ID filter. Applies directly to search_term_view and via segments.ad_group for insight reports."),
-      searchTermContains: z5.string().min(1).optional().describe("Optional substring filter for search_term_view"),
-      limit: z5.number().int().min(1).max(1e4).optional().default(1e3)
+      searchTermContains: z7.string().min(1).optional().describe("Optional substring filter for search_term_view"),
+      limit: z7.number().int().min(1).max(1e4).optional().default(1e3)
     },
     async ({ customerId, reportType, startDate, endDate, campaignId, adGroupId, searchTermContains, limit }) => {
       try {
@@ -7492,7 +8410,7 @@ Use google-ads://metrics for available metrics, google-ads://dimensions for dime
       startDate: isoDateSchema2.describe("Start date YYYY-MM-DD"),
       endDate: isoDateSchema2.describe("End date YYYY-MM-DD"),
       campaignId: numericIdSchema3.optional().describe("Optional campaign ID filter"),
-      limit: z5.number().int().min(1).max(1e4).optional().default(1e3)
+      limit: z7.number().int().min(1).max(1e4).optional().default(1e3)
     },
     async ({ customerId, startDate, endDate, campaignId, limit }) => {
       try {
@@ -7536,11 +8454,11 @@ Use google-ads://metrics for available metrics, google-ads://dimensions for dime
           ORDER BY metrics.clicks DESC
           LIMIT ${limit}
         `);
-        const result = await runGaqlWithFallback(client, customerId, [
+        const result2 = await runGaqlWithFallback(client, customerId, [
           { label: "landing_page_with_quality_metrics", gaql: richGaql, failureWarning: "Landing page query with quality metrics failed" },
           { label: "landing_page_minimal", gaql: fallbackGaql }
         ]);
-        return ok({ landingPages: result.rows, count: result.rows.length, gaql: result.gaql, warnings: result.warnings });
+        return ok({ landingPages: result2.rows, count: result2.rows.length, gaql: result2.gaql, warnings: result2.warnings });
       } catch (e) {
         return formatMcpToolError(e);
       }
@@ -7553,27 +8471,30 @@ Use google-ads://metrics for available metrics, google-ads://dimensions for dime
       customerId: customerIdSchema3,
       startDate: isoDateSchema2.optional().describe("Optional start date YYYY-MM-DD for performance metrics"),
       endDate: isoDateSchema2.optional().describe("Optional end date YYYY-MM-DD for performance metrics"),
+      metrics: z7.array(z7.enum(PMAX_METRIC_FIELDS)).min(1).max(32).optional().describe("Additional asset-compatible GAQL metric fields. Used with a date range; delivery metrics are always included. Omit for the default delivery/conversion fields."),
       campaignId: numericIdSchema3.optional().describe("Optional Performance Max campaign ID filter"),
       assetGroupId: numericIdSchema3.optional().describe("Optional asset group ID filter"),
+      assetGroupIds: z7.array(numericIdSchema3).min(1).max(10).optional().describe("Restrict reporting to these asset groups."),
+      assetId: numericIdSchema3.optional().describe("Restrict reporting to one asset."),
+      daily: z7.boolean().optional().default(false).describe("Segment dated performance by segments.date."),
       fieldType: gaqlEnumSchema.optional().describe("Optional AssetFieldType enum filter, e.g. HEADLINE, LONG_HEADLINE, MARKETING_IMAGE"),
-      statusFilter: z5.enum(["ENABLED", "PAUSED", "REMOVED"]).optional(),
-      limit: z5.number().int().min(1).max(1e4).optional().default(1e3)
+      statusFilter: z7.enum(["ENABLED", "PAUSED", "REMOVED"]).optional(),
+      limit: z7.number().int().min(1).max(1e4).optional().default(1e3)
     },
-    async ({ customerId, startDate, endDate, campaignId, assetGroupId, fieldType, statusFilter, limit }) => {
+    async ({ customerId, startDate, endDate, metrics, campaignId, assetGroupId, assetGroupIds, assetId, daily, fieldType, statusFilter, limit }) => {
       try {
         const warnings = [];
         const where = ["campaign.advertising_channel_type = 'PERFORMANCE_MAX'", ...optionalDateRange(startDate, endDate)];
         if (campaignId) where.push(`campaign.id = ${campaignId}`);
         if (assetGroupId) where.push(`asset_group.id = ${assetGroupId}`);
+        if (assetGroupIds) where.push(`asset_group.id IN (${assetGroupIds.join(",")})`);
+        if (assetId) where.push(`asset.id = ${assetId}`);
+        if (daily && (!startDate || !endDate)) throw new Error("Daily reporting requires both startDate and endDate.");
         if (fieldType) where.push(`asset_group_asset.field_type = '${fieldType}'`);
         if (statusFilter) where.push(`asset_group_asset.status = '${statusFilter}'`);
         if (!startDate && !endDate) warnings.push("No date range provided; performance metrics were omitted and only asset structure was returned.");
-        const metricsFields = startDate || endDate ? `,
-            metrics.impressions,
-            metrics.clicks,
-            metrics.cost_micros,
-            metrics.conversions,
-            metrics.conversions_value` : "";
+        const selectedMetrics = [.../* @__PURE__ */ new Set(["metrics.impressions", "metrics.cost_micros", ...metrics ?? PMAX_METRIC_FIELDS.slice(0, 5)])];
+        const metricsFields = startDate || endDate ? `, ${selectedMetrics.join(", ")}${daily ? ", segments.date" : ""}` : "";
         const richGaql = oneLineGaql(`
           SELECT
             campaign.id,
@@ -7620,11 +8541,11 @@ Use google-ads://metrics for available metrics, google-ads://dimensions for dime
           ORDER BY campaign.name ASC, asset_group.name ASC
           LIMIT ${limit}
         `);
-        const result = await runGaqlWithFallback(client, customerId, [
+        const result2 = await runGaqlWithFallback(client, customerId, [
           { label: "pmax_assets_with_asset_details", gaql: richGaql, failureWarning: "PMax asset query with asset details failed" },
           { label: "pmax_assets_minimal", gaql: fallbackGaql }
         ]);
-        return ok({ pmaxAssets: result.rows, count: result.rows.length, gaql: result.gaql, warnings: [...warnings, ...result.warnings] });
+        return ok({ pmaxAssets: result2.rows, count: result2.rows.length, gaql: result2.gaql, warnings: [...warnings, ...result2.warnings] });
       } catch (e) {
         return formatMcpToolError(e);
       }
@@ -7635,7 +8556,7 @@ Use google-ads://metrics for available metrics, google-ads://dimensions for dime
     "Read-only planning/forecast query for campaign, ad group, or portfolio bidding simulations. Returns simulation metadata and projected point lists when available, with a metadata fallback.",
     {
       customerId: customerIdSchema3,
-      level: z5.enum(["campaign", "ad_group", "bidding_strategy"]).optional().default("campaign").describe("Simulation resource level to query"),
+      level: z7.enum(["campaign", "ad_group", "bidding_strategy"]).optional().default("campaign").describe("Simulation resource level to query"),
       campaignId: numericIdSchema3.optional().describe("Optional campaign ID filter. Applies directly to campaign simulations and as campaign context for ad group simulations."),
       adGroupId: numericIdSchema3.optional().describe("Optional ad group ID filter for ad_group simulations"),
       biddingStrategyId: numericIdSchema3.optional().describe("Optional portfolio bidding strategy ID filter for bidding_strategy simulations"),
@@ -7643,7 +8564,7 @@ Use google-ads://metrics for available metrics, google-ads://dimensions for dime
       simulationEndDate: isoDateSchema2.optional().describe("Optional maximum simulation end date YYYY-MM-DD"),
       typeFilter: gaqlEnumSchema.optional().describe("Optional SimulationType enum, e.g. BUDGET, TARGET_CPA, TARGET_ROAS, CPC_BID"),
       modificationMethod: gaqlEnumSchema.optional().describe("Optional SimulationModificationMethod enum, e.g. UNIFORM, SCALING, DEFAULT"),
-      limit: z5.number().int().min(1).max(1e3).optional().default(1e3)
+      limit: z7.number().int().min(1).max(1e3).optional().default(1e3)
     },
     async ({ customerId, level, campaignId, adGroupId, biddingStrategyId, simulationStartDate, simulationEndDate, typeFilter, modificationMethod, limit }) => {
       try {
@@ -7772,11 +8693,11 @@ Use google-ads://metrics for available metrics, google-ads://dimensions for dime
           ORDER BY ${resource}.start_date DESC
           LIMIT ${limit}
         `);
-        const result = await runGaqlWithFallback(client, customerId, [
+        const result2 = await runGaqlWithFallback(client, customerId, [
           { label: `${resource}_with_points`, gaql: richGaql, failureWarning: "Simulation query with projected point lists failed" },
           { label: `${resource}_metadata`, gaql: fallbackGaql }
         ]);
-        return ok({ simulations: result.rows, level, count: result.rows.length, gaql: result.gaql, warnings: [...warnings, ...result.warnings] });
+        return ok({ simulations: result2.rows, level, count: result2.rows.length, gaql: result2.gaql, warnings: [...warnings, ...result2.warnings] });
       } catch (e) {
         return formatMcpToolError(e);
       }
@@ -7791,9 +8712,9 @@ Use google-ads://metrics for available metrics, google-ads://dimensions for dime
       endDate: isoDateSchema2.describe("End date YYYY-MM-DD"),
       campaignId: numericIdSchema3.optional().describe("Optional campaign ID filter"),
       adGroupId: numericIdSchema3.optional().describe("Optional ad group ID filter"),
-      searchTermContains: z5.string().min(1).optional().describe("Optional search term substring filter"),
-      serpType: z5.enum(["ADS_AND_ORGANIC", "ADS_ONLY", "ORGANIC_ONLY", "UNKNOWN", "UNSPECIFIED"]).optional().describe("Optional search engine results page type segment filter"),
-      limit: z5.number().int().min(1).max(1e4).optional().default(1e3)
+      searchTermContains: z7.string().min(1).optional().describe("Optional search term substring filter"),
+      serpType: z7.enum(["ADS_AND_ORGANIC", "ADS_ONLY", "ORGANIC_ONLY", "UNKNOWN", "UNSPECIFIED"]).optional().describe("Optional search engine results page type segment filter"),
+      limit: z7.number().int().min(1).max(1e4).optional().default(1e3)
     },
     async ({ customerId, startDate, endDate, campaignId, adGroupId, searchTermContains, serpType, limit }) => {
       try {
@@ -7853,11 +8774,11 @@ Use google-ads://metrics for available metrics, google-ads://dimensions for dime
           ORDER BY metrics.clicks DESC
           LIMIT ${limit}
         `);
-        const result = await runGaqlWithFallback(client, customerId, [
+        const result2 = await runGaqlWithFallback(client, customerId, [
           { label: "paid_organic_search_term_view", gaql: richGaql, failureWarning: "Paid/organic search term query failed; organic reporting may require eligible linked organic search data or compatible fields" },
           { label: "search_term_view_paid_only", gaql: fallbackGaql }
         ]);
-        return ok({ searchTerms: result.rows, source: result.queryLabel, count: result.rows.length, gaql: result.gaql, warnings: result.warnings });
+        return ok({ searchTerms: result2.rows, source: result2.queryLabel, count: result2.rows.length, gaql: result2.gaql, warnings: result2.warnings });
       } catch (e) {
         return formatMcpToolError(e);
       }
@@ -7868,17 +8789,17 @@ Use google-ads://metrics for available metrics, google-ads://dimensions for dime
     "Read-only Merchant Center product catalog/eligibility report via shopping_product. Supports account, campaign, and ad group scopes with performance metrics when the account has Shopping/PMax e-commerce data.",
     {
       customerId: customerIdSchema3,
-      scope: z5.enum(["account", "campaign", "ad_group"]).optional().default("account").describe("shopping_product scope. ad_group scope requires campaignId and adGroupId."),
+      scope: z7.enum(["account", "campaign", "ad_group"]).optional().default("account").describe("shopping_product scope. ad_group scope requires campaignId and adGroupId."),
       startDate: isoDateSchema2.optional().describe("Optional start date YYYY-MM-DD. Used only as a WHERE filter; shopping_product cannot segment by date."),
       endDate: isoDateSchema2.optional().describe("Optional end date YYYY-MM-DD. Used only as a WHERE filter; shopping_product cannot segment by date."),
       campaignId: numericIdSchema3.optional().describe("Campaign ID for campaign or ad_group scope"),
       adGroupId: numericIdSchema3.optional().describe("Ad group ID for ad_group scope"),
       merchantCenterId: numericIdSchema3.optional().describe("Optional Merchant Center ID filter"),
-      itemId: z5.string().min(1).optional().describe("Optional Merchant Center item ID filter"),
-      titleContains: z5.string().min(1).optional().describe("Optional product title substring filter"),
-      feedLabel: z5.string().min(1).optional().describe("Optional feed label filter"),
-      statusFilter: z5.enum(["ELIGIBLE", "ELIGIBLE_LIMITED", "NOT_ELIGIBLE", "UNKNOWN", "UNSPECIFIED"]).optional(),
-      limit: z5.number().int().min(1).max(1e4).optional().default(1e3)
+      itemId: z7.string().min(1).optional().describe("Optional Merchant Center item ID filter"),
+      titleContains: z7.string().min(1).optional().describe("Optional product title substring filter"),
+      feedLabel: z7.string().min(1).optional().describe("Optional feed label filter"),
+      statusFilter: z7.enum(["ELIGIBLE", "ELIGIBLE_LIMITED", "NOT_ELIGIBLE", "UNKNOWN", "UNSPECIFIED"]).optional(),
+      limit: z7.number().int().min(1).max(1e4).optional().default(1e3)
     },
     async ({ customerId, scope, startDate, endDate, campaignId, adGroupId, merchantCenterId, itemId, titleContains, feedLabel, statusFilter, limit }) => {
       try {
@@ -7965,11 +8886,11 @@ Use google-ads://metrics for available metrics, google-ads://dimensions for dime
           ORDER BY shopping_product.title ASC
           LIMIT ${limit}
         `);
-        const result = await runGaqlWithFallback(client, customerId, [
+        const result2 = await runGaqlWithFallback(client, customerId, [
           { label: "shopping_product_with_metrics_and_issues", gaql: richGaql, failureWarning: "Shopping product query with performance/cart/issue fields failed" },
           { label: "shopping_product_catalog", gaql: fallbackGaql }
         ]);
-        return ok({ shoppingProducts: result.rows, scope, count: result.rows.length, gaql: result.gaql, warnings: [...warnings, ...result.warnings] });
+        return ok({ shoppingProducts: result2.rows, scope, count: result2.rows.length, gaql: result2.gaql, warnings: [...warnings, ...result2.warnings] });
       } catch (e) {
         return formatMcpToolError(e);
       }
@@ -7985,11 +8906,11 @@ Use google-ads://metrics for available metrics, google-ads://dimensions for dime
       campaignId: numericIdSchema3.optional().describe("Optional campaign ID filter"),
       adGroupId: numericIdSchema3.optional().describe("Optional ad group ID filter"),
       merchantCenterId: numericIdSchema3.optional().describe("Optional Merchant Center ID filter"),
-      itemId: z5.string().min(1).optional().describe("Optional Merchant Center item ID filter"),
-      titleContains: z5.string().min(1).optional().describe("Optional product title substring filter"),
-      brand: z5.string().min(1).optional().describe("Optional product brand filter"),
-      feedLabel: z5.string().min(1).optional().describe("Optional product feed label filter"),
-      limit: z5.number().int().min(1).max(1e4).optional().default(1e3)
+      itemId: z7.string().min(1).optional().describe("Optional Merchant Center item ID filter"),
+      titleContains: z7.string().min(1).optional().describe("Optional product title substring filter"),
+      brand: z7.string().min(1).optional().describe("Optional product brand filter"),
+      feedLabel: z7.string().min(1).optional().describe("Optional product feed label filter"),
+      limit: z7.number().int().min(1).max(1e4).optional().default(1e3)
     },
     async ({ customerId, startDate, endDate, campaignId, adGroupId, merchantCenterId, itemId, titleContains, brand, feedLabel, limit }) => {
       try {
@@ -8049,11 +8970,11 @@ Use google-ads://metrics for available metrics, google-ads://dimensions for dime
           ORDER BY metrics.cost_micros DESC
           LIMIT ${limit}
         `);
-        const result = await runGaqlWithFallback(client, customerId, [
+        const result2 = await runGaqlWithFallback(client, customerId, [
           { label: "shopping_performance_with_cart_metrics", gaql: richGaql, failureWarning: "Shopping performance query with cart/profit metrics failed" },
           { label: "shopping_performance_core", gaql: fallbackGaql }
         ]);
-        return ok({ shoppingPerformance: result.rows, count: result.rows.length, gaql: result.gaql, warnings: result.warnings });
+        return ok({ shoppingPerformance: result2.rows, count: result2.rows.length, gaql: result2.gaql, warnings: result2.warnings });
       } catch (e) {
         return formatMcpToolError(e);
       }
@@ -8067,9 +8988,9 @@ Use google-ads://metrics for available metrics, google-ads://dimensions for dime
       startDate: isoDateSchema2.describe("Start date YYYY-MM-DD"),
       endDate: isoDateSchema2.describe("End date YYYY-MM-DD"),
       campaignId: numericIdSchema3.optional().describe("Optional Performance Max campaign ID filter"),
-      placementType: z5.enum(["WEBSITE", "MOBILE_APPLICATION", "YOUTUBE_VIDEO", "YOUTUBE_CHANNEL", "GOOGLE_PRODUCTS", "UNKNOWN", "UNSPECIFIED"]).optional().describe("Optional PlacementType enum filter"),
-      placementContains: z5.string().min(1).optional().describe("Optional substring filter for the placement string"),
-      limit: z5.number().int().min(1).max(1e4).optional().default(1e3)
+      placementType: z7.enum(["WEBSITE", "MOBILE_APPLICATION", "YOUTUBE_VIDEO", "YOUTUBE_CHANNEL", "GOOGLE_PRODUCTS", "UNKNOWN", "UNSPECIFIED"]).optional().describe("Optional PlacementType enum filter"),
+      placementContains: z7.string().min(1).optional().describe("Optional substring filter for the placement string"),
+      limit: z7.number().int().min(1).max(1e4).optional().default(1e3)
     },
     async ({ customerId, startDate, endDate, campaignId, placementType, placementContains, limit }) => {
       try {
@@ -8105,16 +9026,16 @@ Use google-ads://metrics for available metrics, google-ads://dimensions for dime
           ORDER BY metrics.impressions DESC
           LIMIT ${limit}
         `);
-        const result = await runGaqlWithFallback(client, customerId, [
+        const result2 = await runGaqlWithFallback(client, customerId, [
           { label: "pmax_placements_with_target_url_and_campaign", gaql: richGaql, failureWarning: "PMax placement query with target URL/campaign context failed" },
           { label: "pmax_placements_core", gaql: fallbackGaql }
         ]);
         return ok({
-          placements: result.rows,
-          pmaxPlacements: result.rows,
-          count: result.rows.length,
-          gaql: result.gaql,
-          warnings: [...warnings, ...result.warnings]
+          placements: result2.rows,
+          pmaxPlacements: result2.rows,
+          count: result2.rows.length,
+          gaql: result2.gaql,
+          warnings: [...warnings, ...result2.warnings]
         });
       } catch (e) {
         return formatMcpToolError(e);
@@ -8130,9 +9051,9 @@ Use google-ads://metrics for available metrics, google-ads://dimensions for dime
       endDate: isoDateSchema2.optional().describe("Optional end date YYYY-MM-DD for asset group metrics/top combinations"),
       campaignId: numericIdSchema3.optional().describe("Optional Performance Max campaign ID filter"),
       assetGroupId: numericIdSchema3.optional().describe("Optional asset group ID filter"),
-      statusFilter: z5.enum(["ENABLED", "PAUSED", "REMOVED"]).optional(),
-      includeTopCombinations: z5.boolean().optional().default(true).describe("Also query asset_group_top_combination_view when available"),
-      limit: z5.number().int().min(1).max(1e3).optional().default(1e3)
+      statusFilter: z7.enum(["ENABLED", "PAUSED", "REMOVED"]).optional(),
+      includeTopCombinations: z7.boolean().optional().default(true).describe("Also query asset_group_top_combination_view when available"),
+      limit: z7.number().int().min(1).max(1e3).optional().default(1e3)
     },
     async ({ customerId, startDate, endDate, campaignId, assetGroupId, statusFilter, includeTopCombinations, limit }) => {
       try {
@@ -8232,6 +9153,207 @@ Use google-ads://metrics for available metrics, google-ads://dimensions for dime
       }
     }
   );
+  server.tool(
+    "google_ads_list_image_assets",
+    "List the account's image asset library (FROM asset) with stable, publicly served full-size URLs on tpc.googlesyndication.com, dimensions, file size, and mime type. This is the whole stock and carries no notion of delivery: an asset uploaded in 2022 and never served appears exactly like one running today. Newest first, so a limit returns recent assets rather than an arbitrary slice, and the count in the response is the account total. For a visual-only gallery of assets with delivery over dates, use the hosted GetMCPAds service (Performance Max coverage). The local server returns media URLs and native report data. Shopping product imagery lives in Merchant Center, not in this library.",
+    {
+      customerId: customerIdSchema3,
+      beforeAssetId: numericIdSchema3.optional().describe("Continue the descending library before this last-seen asset ID. Use the same filters."),
+      assetIds: z7.array(numericIdSchema3).min(1).max(8).optional().describe("Resolve these exact native asset IDs, without scanning the library."),
+      nameFilter: z7.string().optional().describe("Only assets whose file name contains this text"),
+      minWidth: z7.number().int().min(1).optional().describe("Only images at least this wide, in pixels"),
+      minHeight: z7.number().int().min(1).optional().describe("Only images at least this tall, in pixels"),
+      limit: z7.number().int().min(1).max(1e4).optional().default(500)
+    },
+    async ({ customerId, beforeAssetId, assetIds, nameFilter, minWidth, minHeight, limit }) => {
+      try {
+        const where = ["asset.type = 'IMAGE'"];
+        if (beforeAssetId) where.push(`asset.id < ${beforeAssetId}`);
+        if (assetIds?.length) where.push(`asset.id IN (${assetIds.join(",")})`);
+        if (nameFilter) where.push(`asset.name LIKE '%${quoteGaqlString(nameFilter)}%'`);
+        if (minWidth) where.push(`asset.image_asset.full_size.width_pixels >= ${minWidth}`);
+        if (minHeight) where.push(`asset.image_asset.full_size.height_pixels >= ${minHeight}`);
+        const { rows, gaql, warnings } = await runGaqlWithFallback(client, customerId, [{
+          label: "image asset library",
+          gaql: oneLineGaql(`
+            SELECT
+              asset.id, asset.name, asset.type, asset.source,
+              asset.image_asset.full_size.url,
+              asset.image_asset.full_size.width_pixels,
+              asset.image_asset.full_size.height_pixels,
+              asset.image_asset.file_size,
+              asset.image_asset.mime_type
+            FROM asset${buildWhere(where)} ORDER BY asset.id DESC LIMIT ${limit}`)
+        }]);
+        return ok({
+          imageAssets: rows,
+          count: rows.length,
+          gaql,
+          warnings,
+          limitations: [
+            "This is the account library, not a delivery report: it says nothing about what ran or spent in any period. Rows come newest first, so a limit returns the most recent assets. Use dated delivery reports to identify assets that actually served; the hosted GetMCPAds service provides interactive galleries.",
+            "full_size.url points at tpc.googlesyndication.com/simgad and is publicly served without authentication or visible expiry: safe to display, hotlink, or download while the asset exists.",
+            "Shopping/PLA product visuals come from Merchant Center feeds and never appear in this asset library."
+          ],
+          nextActions: rows.length >= limit ? ["The LIMIT was reached; narrow with nameFilter or dimensions, or raise limit."] : []
+        });
+      } catch (e) {
+        return formatMcpToolError(e);
+      }
+    }
+  );
+  server.tool(
+    "google_ads_list_video_assets",
+    "List the account's YouTube video assets (FROM asset) with derived watch, embed, and public thumbnail URLs. This is the whole stock and carries no notion of delivery: an asset uploaded years ago and never served appears exactly like one running today. Newest first, so a limit returns recent assets rather than an arbitrary slice, and the count in the response is the account total. For a visual-only gallery of assets with delivery over dates, use the hosted GetMCPAds service (Performance Max coverage). The local server returns media URLs and native report data. Google Ads exposes no downloadable video file: PMax and Demand Gen videos are hosted on YouTube, so display them via embed or thumbnails.",
+    {
+      customerId: customerIdSchema3,
+      beforeAssetId: numericIdSchema3.optional().describe("Continue the descending library before this last-seen asset ID. Use the same filters."),
+      assetIds: z7.array(numericIdSchema3).min(1).max(8).optional().describe("Resolve these exact native asset IDs, without scanning the library."),
+      nameFilter: z7.string().optional().describe("Only assets whose name contains this text"),
+      limit: z7.number().int().min(1).max(1e4).optional().default(500)
+    },
+    async ({ customerId, beforeAssetId, assetIds, nameFilter, limit }) => {
+      try {
+        const where = ["asset.type = 'YOUTUBE_VIDEO'"];
+        if (beforeAssetId) where.push(`asset.id < ${beforeAssetId}`);
+        if (assetIds?.length) where.push(`asset.id IN (${assetIds.join(",")})`);
+        if (nameFilter) where.push(`asset.name LIKE '%${quoteGaqlString(nameFilter)}%'`);
+        const { rows, gaql, warnings } = await runGaqlWithFallback(client, customerId, [{
+          label: "video asset library",
+          gaql: oneLineGaql(`
+            SELECT
+              asset.id, asset.name, asset.type, asset.source,
+              asset.youtube_video_asset.youtube_video_id,
+              asset.youtube_video_asset.youtube_video_title
+            FROM asset${buildWhere(where)} ORDER BY asset.id DESC LIMIT ${limit}`)
+        }]);
+        const videoAssets = rows.map((row) => {
+          const asset = recordOf(recordOf(row)?.asset);
+          const youtube = recordOf(asset?.youtubeVideoAsset);
+          return { ...row, derivedUrls: youtubeDerivedUrls(youtube?.youtubeVideoId) };
+        });
+        return ok({
+          videoAssets,
+          count: videoAssets.length,
+          gaql,
+          warnings,
+          limitations: [
+            "This is the account library, not a delivery report: it says nothing about what ran or spent in any period. Rows come newest first, so a limit returns the most recent assets. Use dated delivery reports to identify assets that actually served; the hosted GetMCPAds service provides interactive galleries.",
+            "No raw video file is available through the Google Ads API and YouTube's terms forbid downloading: use derivedUrls.embed_url (iframe) or watch_url, and the publicly served, stable i.ytimg.com thumbnails (maxresdefault with hqdefault as the always-present fallback)."
+          ],
+          nextActions: videoAssets.length >= limit ? ["The LIMIT was reached; narrow with nameFilter or raise limit."] : []
+        });
+      } catch (e) {
+        return formatMcpToolError(e);
+      }
+    }
+  );
+  server.tool(
+    "google_ads_get_demand_gen_assets",
+    "List Demand Gen ads (video responsive, multi-asset, carousel) with their referenced creatives resolved: stable image URLs and YouTube video IDs with embed and thumbnail URLs. Complements google_ads_get_pmax_assets, which covers Performance Max.",
+    {
+      customerId: customerIdSchema3,
+      campaignId: numericIdSchema3.optional().describe("Optional Demand Gen campaign ID filter"),
+      limit: z7.number().int().min(1).max(1e4).optional().default(500)
+    },
+    async ({ customerId, campaignId, limit }) => {
+      try {
+        const where = ["campaign.advertising_channel_type = 'DEMAND_GEN'"];
+        if (campaignId) where.push(`campaign.id = ${campaignId}`);
+        const demandGenFields = `
+          ad_group_ad.ad.demand_gen_video_responsive_ad.videos,
+          ad_group_ad.ad.demand_gen_video_responsive_ad.logo_images,
+          ad_group_ad.ad.demand_gen_multi_asset_ad.marketing_images,
+          ad_group_ad.ad.demand_gen_multi_asset_ad.square_marketing_images,
+          ad_group_ad.ad.demand_gen_multi_asset_ad.portrait_marketing_images,
+          ad_group_ad.ad.demand_gen_multi_asset_ad.logo_images,
+          ad_group_ad.ad.demand_gen_carousel_ad.carousel_cards`;
+        const baseFields = `
+          campaign.id, campaign.name, ad_group.id, ad_group.name,
+          ad_group_ad.status, ad_group_ad.ad.id, ad_group_ad.ad.name, ad_group_ad.ad.type`;
+        const ads = await runGaqlWithFallback(client, customerId, [
+          {
+            label: "demand gen ads with creative references",
+            gaql: oneLineGaql(`SELECT ${baseFields}, ${demandGenFields} FROM ad_group_ad${buildWhere(where)} LIMIT ${limit}`),
+            failureWarning: "Full Demand Gen creative field selection failed; falling back to ad identifiers only"
+          },
+          {
+            label: "demand gen ads without creative fields",
+            gaql: oneLineGaql(`SELECT ${baseFields} FROM ad_group_ad${buildWhere(where)} LIMIT ${limit}`)
+          }
+        ]);
+        const referencedIds = /* @__PURE__ */ new Set();
+        for (const row of ads.rows) {
+          const ad = recordOf(recordOf(recordOf(row)?.adGroupAd)?.ad);
+          if (!ad) continue;
+          collectAssetIds(ad.demandGenVideoResponsiveAd, referencedIds);
+          collectAssetIds(ad.demandGenMultiAssetAd, referencedIds);
+          collectAssetIds(ad.demandGenCarouselAd, referencedIds);
+        }
+        const warnings = [...ads.warnings];
+        const assetsById = /* @__PURE__ */ new Map();
+        const idList = [...referencedIds];
+        const chunkSize = 500;
+        for (let index = 0; index < idList.length; index += chunkSize) {
+          const chunk = idList.slice(index, index + chunkSize);
+          try {
+            const resolved = await client.searchStream(customerId, oneLineGaql(`
+              SELECT
+                asset.id, asset.name, asset.type,
+                asset.image_asset.full_size.url,
+                asset.image_asset.full_size.width_pixels,
+                asset.image_asset.full_size.height_pixels,
+                asset.youtube_video_asset.youtube_video_id,
+                asset.youtube_video_asset.youtube_video_title
+              FROM asset WHERE asset.id IN (${chunk.join(", ")})`));
+            for (const row of resolved) {
+              const asset = recordOf(recordOf(row)?.asset);
+              const rawId = asset?.id;
+              const id = typeof rawId === "string" || typeof rawId === "number" ? String(rawId) : void 0;
+              if (!asset || !id) continue;
+              const youtube = recordOf(asset.youtubeVideoAsset);
+              assetsById.set(id, {
+                ...asset,
+                derivedUrls: youtubeDerivedUrls(youtube?.youtubeVideoId)
+              });
+            }
+          } catch (error) {
+            warnings.push(`Asset resolution failed for ${chunk.length} referenced assets: ${getErrorMessage(error)}`);
+          }
+        }
+        const resolvedAds = ads.rows.map((row) => {
+          const record = recordOf(row) ?? {};
+          const ad = recordOf(recordOf(record.adGroupAd)?.ad);
+          const ids = /* @__PURE__ */ new Set();
+          if (ad) {
+            collectAssetIds(ad.demandGenVideoResponsiveAd, ids);
+            collectAssetIds(ad.demandGenMultiAssetAd, ids);
+            collectAssetIds(ad.demandGenCarouselAd, ids);
+          }
+          return {
+            ...record,
+            resolvedAssets: [...ids].map((id) => assetsById.get(id) ?? { id, unresolved: true })
+          };
+        });
+        return ok({
+          ads: resolvedAds,
+          count: resolvedAds.length,
+          referencedAssetCount: referencedIds.size,
+          resolvedAssetCount: assetsById.size,
+          gaql: ads.gaql,
+          warnings,
+          limitations: [
+            "Demand Gen videos are YouTube assets: no raw file is available (YouTube terms), display them via resolvedAssets.derivedUrls.embed_url or the stable public i.ytimg.com thumbnails.",
+            "Image full_size.url values on tpc.googlesyndication.com are publicly served with no visible expiry.",
+            "Catalog-driven visuals come from Merchant Center feeds and are not part of ad creative references."
+          ],
+          nextActions: resolvedAds.length >= limit ? ["The LIMIT was reached; filter by campaignId or raise limit."] : []
+        });
+      } catch (e) {
+        return formatMcpToolError(e);
+      }
+    }
+  );
   registerGoogleAdsKeywordPlannerTools(server, client, ok);
   registerGoogleAdsDiscoveryTools(server, client, ok);
   registerGoogleAdsReadOnlyRpcTool(server, client, ok);
@@ -8277,7 +9399,11 @@ var GOOGLE_ADS_TOOL_MANIFEST = {
     { name: "google_ads_run_readonly_rpc", purpose: "Call an allowlisted non-GAQL read service for Audience Insights, Reach Planner, benchmarks, suggestions, identity, invoices, or payments metadata." },
     { name: "google_ads_get_insights", purpose: "Generate validated performance GAQL using the metric and dimension catalogs." },
     { name: "google_ads_validate_query", purpose: "Validate metric/dimension/resource compatibility before querying." },
-    { name: "google_ads_run_gaql", purpose: "Run raw read-only GAQL SELECT queries for advanced reporting." }
+    { name: "google_ads_run_gaql", purpose: "Run raw read-only GAQL SELECT queries for advanced reporting." },
+    { name: "google_ads_list_image_assets", purpose: "List the account's image asset library with stable public full-size URLs, dimensions, and file metadata." },
+    { name: "google_ads_list_video_assets", purpose: "List YouTube video assets with derived watch, embed, and public thumbnail URLs." },
+    { name: "google_ads_get_demand_gen_assets", purpose: "List Demand Gen ads with their referenced image and YouTube creatives resolved." },
+    { "name": "google_ads_get_video_upload", "purpose": "Read the processing state and YouTube video ID of one Google Ads upload in the selected customer" }
   ],
   resources: [
     "google-ads://manifest",
@@ -8433,7 +9559,7 @@ function registerGoogleAdsResources(server) {
       mimeType: "application/json",
       text: JSON.stringify({
         description: "Google Ads uses GAQL (SQL-like). The FROM clause determines the resource type. Some metrics are restricted to specific resources, and some segments are incompatible with certain metrics (especially impression_share).",
-        resourceTypes: ["campaign", "ad_group", "ad_group_ad", "keyword_view", "search_term_view", "paid_organic_search_term_view", "shopping_performance_view", "shopping_product", "asset_group", "asset_group_asset", "asset_group_top_combination_view", "performance_max_placement_view", "campaign_simulation", "ad_group_simulation", "bidding_strategy_simulation"],
+        resourceTypes: ["campaign", "ad_group", "ad_group_ad", "keyword_view", "search_term_view", "paid_organic_search_term_view", "shopping_performance_view", "shopping_product", "asset", "asset_group", "asset_group_asset", "asset_group_top_combination_view", "performance_max_placement_view", "campaign_simulation", "ad_group_simulation", "bidding_strategy_simulation"],
         queryFormat: "SELECT ... FROM resource WHERE ... ORDER BY ... LIMIT N"
       }, null, 2)
     }]
@@ -8441,7 +9567,25 @@ function registerGoogleAdsResources(server) {
 }
 
 // src/platforms/google-ads/writes.ts
-import { z as z6 } from "zod";
+import { randomUUID } from "crypto";
+import { z as z8 } from "zod";
+
+// src/core/money.ts
+function guard(amount, currency) {
+  if (!Number.isFinite(amount)) throw new Error(`Amount must be a finite number, received ${amount}.`);
+  if (amount <= 0) throw new Error(`Amount must be greater than zero, received ${amount}.`);
+  if (amount > 1e6) {
+    throw new Error(
+      `Amount ${amount} ${currency} is above the safety ceiling of 1,000,000. If this is intentional, make the change in the platform's own interface.`
+    );
+  }
+  return amount;
+}
+function toMicros(amount) {
+  return Math.round(guard(amount, "units") * 1e6);
+}
+
+// src/platforms/google-ads/writes.ts
 function ok2(data) {
   return { content: [{ type: "text", text: JSON.stringify(data, null, 2) }] };
 }
@@ -8456,246 +9600,326 @@ function preview(action, details) {
     message: "Preview only, nothing was changed. Repeat the same call with confirm: true to apply this change to the live account."
   });
 }
-var confirmSchema = z6.boolean().optional().describe("Set to true to actually apply the change. Without it, the tool only previews.");
-var loginCustomerIdSchema2 = z6.string().optional().describe("Manager account ID, when the customer sits under an MCC. Omit otherwise.");
-function toMicros(amount) {
-  if (!Number.isFinite(amount) || amount <= 0) {
-    throw new Error(`Expected a positive amount, received "${amount}".`);
-  }
-  return Math.round(amount * 1e6);
-}
-var stripDashes = (id) => String(id).replace(/-/g, "");
-function registerGoogleAdsWrites(server, config) {
-  const client = new GoogleAdsClient(config);
-  const resourceName = (cid, collection, id) => `customers/${cid}/${collection}/${id}`;
-  const statusTool = (name, label, param, collection) => server.tool(
-    name,
-    `Pause, re-enable or remove a Google Ads ${label}. Previews by default: without confirm: true, the tool describes the change without applying it.`,
-    {
-      customerId: z6.string().describe("Google Ads customer ID, with or without dashes."),
-      [param]: z6.string().describe(`${label} ID.`),
-      status: z6.enum(["PAUSED", "ENABLED", "REMOVED"]).describe("New status."),
-      loginCustomerId: loginCustomerIdSchema2,
-      confirm: confirmSchema
-    },
-    async (a) => {
-      const cid = stripDashes(a.customerId);
-      const id = String(a[param]);
-      if (!a.confirm) {
-        return preview(name, { customer: cid, target: id, newStatus: a.status });
-      }
-      const result = await client.mutate(cid, collection, [
-        { update: { resourceName: resourceName(cid, collection, id), status: a.status }, updateMask: "status" }
-      ], a.loginCustomerId);
-      return ok2({ applied: true, action: name, result });
+var confirmSchema = z8.boolean().optional().describe("Set to true to actually apply the change. Without it, the tool only previews.");
+async function request(url, init, contexte) {
+  const response = await fetch(url, { ...init, redirect: "error" });
+  const body = await response.text();
+  let parsed;
+  try {
+    parsed = JSON.parse(body);
+  } catch {
+    parsed = body;
+  }
+  if (!response.ok) {
+    if (url.startsWith(ADS_BASE + "/")) {
+      const error = parsed?.error;
+      const details = error?.details?.flatMap((d) => d.errors ?? []).map((e) => ({ code: e.errorCode, message: e.message, location: e.location }));
+      throw new Error(`${contexte}: ${JSON.stringify(details?.length ? details : error?.message ?? parsed).slice(0, 3e3)}`);
     }
-  );
-  statusTool("google_ads_update_campaign_status", "campaign", "campaignId", "campaigns");
-  statusTool("google_ads_update_adgroup_status", "ad group", "adGroupId", "adGroups");
-  server.tool(
-    "google_ads_rename_campaign",
-    "Rename a Google Ads campaign. The name is the only thing that changes: delivery, budget and targeting are untouched. Previews by default.",
+    throw new Error(`${contexte} : ${typeof parsed === "string" ? parsed.slice(0, 300) : JSON.stringify(parsed).slice(0, 300)}`);
+  }
+  return parsed;
+}
+var ADS_BASE = "https://googleads.googleapis.com/v25";
+function registerGoogleAdsWrites(c, config) {
+  registerGoogleExtendedWrites(c, config);
+  async function accessToken() {
+    const r = await request(
+      "https://oauth2.googleapis.com/token",
+      {
+        method: "POST",
+        headers: { "content-type": "application/x-www-form-urlencoded" },
+        body: new URLSearchParams({
+          grant_type: "refresh_token",
+          refresh_token: config.refreshToken,
+          client_id: config.clientId,
+          client_secret: config.clientSecret
+        })
+      },
+      "Google token refresh"
+    );
+    return r.access_token;
+  }
+  const headers = async (loginCustomerId) => {
+    const h = {
+      authorization: `Bearer ${await accessToken()}`,
+      "developer-token": config.developerToken,
+      "content-type": "application/json"
+    };
+    const manager = loginCustomerId ?? config.loginCustomerId;
+    if (manager) h["login-customer-id"] = manager.replace(/-/g, "");
+    return h;
+  };
+  c.tool(
+    "google_ads_update_campaign_status",
+    "Pause, re-enable or remove a Google Ads campaign. Previews by default: without confirm: true, the tool describes the change without applying it.",
     {
-      customerId: z6.string().describe("Google Ads customer ID, with or without dashes."),
-      campaignId: z6.string().describe("Campaign ID."),
-      name: z6.string().min(1).max(255).describe("New campaign name."),
-      loginCustomerId: loginCustomerIdSchema2,
+      customerId: z8.string().describe("Google Ads customer ID, with or without dashes."),
+      campaignId: z8.string().describe("Campaign ID."),
+      status: z8.enum(["PAUSED", "ENABLED", "REMOVED"]).describe("New status."),
+      loginCustomerId: z8.string().optional().describe("Manager account, if the customer sits under an MCC."),
       confirm: confirmSchema
     },
     async (a) => {
-      const cid = stripDashes(a.customerId);
-      if (!a.confirm) {
-        return preview("google_ads_rename_campaign", { customer: cid, campaign: a.campaignId, newName: a.name });
+      const { customerId, campaignId, status, loginCustomerId, confirm } = a;
+      const cid = String(customerId).replace(/-/g, "");
+      if (!confirm) {
+        return preview("google_ads_update_campaign_status", { customer: cid, campaign: campaignId, newStatus: status });
       }
-      const result = await client.mutate(cid, "campaigns", [
-        { update: { resourceName: resourceName(cid, "campaigns", a.campaignId), name: a.name }, updateMask: "name" }
-      ], a.loginCustomerId);
-      return ok2({ applied: true, action: "google_ads_rename_campaign", result });
+      const result2 = await request(
+        `${ADS_BASE}/customers/${cid}/campaigns:mutate`,
+        {
+          method: "POST",
+          headers: await headers(loginCustomerId),
+          body: JSON.stringify({
+            operations: [
+              status === "REMOVED" ? { remove: `customers/${cid}/campaigns/${campaignId}` } : { update: { resourceName: `customers/${cid}/campaigns/${campaignId}`, status }, updateMask: "status" }
+            ]
+          })
+        },
+        "Google Ads status update"
+      );
+      return ok2({ applied: true, action: "google_ads_update_campaign_status", result: result2 });
     }
   );
-  server.tool(
+  c.tool(
     "google_ads_create_campaign",
     "Create a Google Ads campaign. It is always created PAUSED and there is no option to create it active: someone has to look at it before it spends. Creates the campaign budget too. Previews by default.",
     {
-      customerId: z6.string().describe("Google Ads customer ID, with or without dashes."),
-      name: z6.string().min(1).max(255).describe("Campaign name."),
-      channelType: z6.enum(["SEARCH", "DISPLAY", "SHOPPING", "VIDEO", "PERFORMANCE_MAX"]).describe("Advertising channel."),
-      dailyBudget: z6.number().positive().describe("Daily budget in the account currency."),
-      budgetName: z6.string().min(1).max(255).describe("Name for the campaign budget. Google requires it to be unique on the account."),
-      loginCustomerId: loginCustomerIdSchema2,
+      customerId: z8.string().describe("Google Ads customer ID, with or without dashes."),
+      name: z8.string().describe("Campaign name."),
+      channelType: z8.enum(["SEARCH", "DISPLAY", "SHOPPING", "PERFORMANCE_MAX", "DEMAND_GEN"]).describe("Advertising channel. Classic VIDEO creation is not supported by Google Ads API; Demand Gen is a distinct, supported video-capable campaign type."),
+      dailyBudget: z8.number().positive().describe("Daily budget in the account currency."),
+      loginCustomerId: z8.string().optional().describe("Manager account ID, when the customer sits under an MCC. Omit otherwise."),
+      brandGuidelinesEnabled: z8.literal(false).optional().describe("For Performance Max, explicitly pass false to create an empty paused campaign without campaign-level brand assets. Brand-enabled creation is not supported by this tool."),
+      euPoliticalAdvertising: z8.boolean().optional().describe("Required for execution: explicitly declare whether this campaign contains EU political advertising."),
+      merchantId: z8.string().regex(/^\d+$/).optional().describe("Merchant Center account ID; required for Shopping."),
+      feedLabel: z8.string().optional().describe("Merchant Center feed label for Shopping."),
+      validateOnly: z8.boolean().optional().describe("Validate the atomic request with Google without creating any resources."),
       confirm: confirmSchema
     },
     async (a) => {
-      const cid = stripDashes(a.customerId);
-      let micros;
-      try {
-        micros = toMicros(Number(a.dailyBudget));
-      } catch (error) {
-        return ko(error instanceof Error ? error.message : String(error));
-      }
-      if (!a.confirm) {
+      const { customerId, name, channelType, dailyBudget, loginCustomerId, confirm } = a;
+      const cid = String(customerId).replace(/-/g, "");
+      const micros = toMicros(Number(dailyBudget));
+      if (!confirm && !a.validateOnly) {
         return preview("google_ads_create_campaign", {
           customer: cid,
-          name: a.name,
-          channelType: a.channelType,
-          dailyBudget: a.dailyBudget,
+          name,
+          channelType,
+          dailyBudget,
           inMicros: micros,
-          budgetName: a.budgetName,
-          status: "PAUSED"
+          status: "PAUSED",
+          euPoliticalAdvertising: a.euPoliticalAdvertising ?? "declaration required before execution",
+          brandGuidelinesEnabled: a.brandGuidelinesEnabled,
+          merchantId: a.merchantId,
+          feedLabel: a.feedLabel,
+          biddingStrategy: ["PERFORMANCE_MAX", "DEMAND_GEN"].includes(String(channelType)) ? "MAXIMIZE_CONVERSIONS" : "MANUAL_CPC"
         });
       }
-      const login = a.loginCustomerId;
-      const budget = await client.mutate(cid, "campaignBudgets", [
-        {
-          create: {
-            name: a.budgetName,
-            amountMicros: String(micros),
-            deliveryMethod: "STANDARD"
-          }
-        }
-      ], login);
-      const budgetResource = budget.results?.[0]?.resourceName;
-      if (!budgetResource) {
-        return ko("Google Ads did not return a budget resource name, so the campaign was not created.");
-      }
-      const campaign = await client.mutate(cid, "campaigns", [
-        {
-          create: {
-            name: a.name,
-            status: "PAUSED",
-            advertisingChannelType: a.channelType,
-            campaignBudget: budgetResource,
-            manualCpc: {}
-          }
-        }
-      ], login);
+      if (channelType === "VIDEO") throw new Error("Google Ads API cannot create VIDEO campaigns. Use an explicitly requested DEMAND_GEN video campaign through google_ads_apply_plan.");
+      if (typeof a.euPoliticalAdvertising !== "boolean") throw new Error("Declare euPoliticalAdvertising explicitly before creating the campaign.");
+      if (channelType === "PERFORMANCE_MAX" && a.brandGuidelinesEnabled !== false) throw new Error("Performance Max requires explicit brandGuidelinesEnabled: false for empty paused creation; brand assets are not supported by this tool.");
+      if (channelType === "SHOPPING" && !a.merchantId) throw new Error("Shopping requires merchantId for an accessible Merchant Center account.");
+      const budgetName = `customers/${cid}/campaignBudgets/-1`;
+      const campaignData = {
+        name,
+        status: "PAUSED",
+        advertisingChannelType: channelType,
+        campaignBudget: budgetName,
+        containsEuPoliticalAdvertising: a.euPoliticalAdvertising ? "CONTAINS_EU_POLITICAL_ADVERTISING" : "DOES_NOT_CONTAIN_EU_POLITICAL_ADVERTISING",
+        ...["PERFORMANCE_MAX", "DEMAND_GEN"].includes(String(channelType)) ? { maximizeConversions: {}, ...channelType === "PERFORMANCE_MAX" ? { brandGuidelinesEnabled: false } : {} } : { manualCpc: {} },
+        ...channelType === "SHOPPING" ? { shoppingSetting: { merchantId: a.merchantId, campaignPriority: 0, feedLabel: a.feedLabel } } : {}
+      };
+      const result2 = await request(`${ADS_BASE}/customers/${cid}/googleAds:mutate`, {
+        method: "POST",
+        headers: await headers(loginCustomerId ?? config.loginCustomerId),
+        body: JSON.stringify({ partialFailure: false, validateOnly: a.validateOnly === true, mutateOperations: [
+          { campaignBudgetOperation: { create: { resourceName: budgetName, name: `${name} budget ${randomUUID()}`, amountMicros: String(micros), deliveryMethod: "STANDARD", explicitlyShared: false } } },
+          { campaignOperation: { create: campaignData } }
+        ] })
+      }, "Google Ads campaign creation");
       return ok2({
-        applied: true,
+        applied: a.validateOnly !== true,
+        validatedByGoogle: a.validateOnly === true,
         action: "google_ads_create_campaign",
         status: "PAUSED",
-        budget: budgetResource,
-        result: campaign
+        budget: result2.mutateOperationResponses?.[0]?.campaignBudgetResult?.resourceName,
+        result: { results: result2.mutateOperationResponses?.flatMap((r) => r.campaignResult ? [r.campaignResult] : []) ?? [] }
       });
     }
   );
-  server.tool(
+  c.tool(
     "google_ads_update_campaign_budget",
     "Change the daily budget of a Google Ads campaign. The amount is in the account currency (12.50 for 12.50 EUR). Previews by default.",
     {
-      customerId: z6.string().describe("Google Ads customer ID, with or without dashes."),
-      budgetId: z6.string().describe("Campaign budget ID (campaign_budget.id)."),
-      dailyAmount: z6.number().positive().describe("New daily budget, in the account currency."),
-      loginCustomerId: loginCustomerIdSchema2,
+      customerId: z8.string().describe("Google Ads customer ID, with or without dashes."),
+      budgetId: z8.string().describe("Campaign budget ID (campaign_budget.id)."),
+      dailyAmount: z8.number().positive().describe("New daily budget, in the account currency."),
+      loginCustomerId: z8.string().optional().describe("Manager account ID, when the customer sits under an MCC. Omit otherwise."),
       confirm: confirmSchema
     },
     async (a) => {
-      const cid = stripDashes(a.customerId);
-      let micros;
-      try {
-        micros = toMicros(Number(a.dailyAmount));
-      } catch (error) {
-        return ko(error instanceof Error ? error.message : String(error));
-      }
-      if (!a.confirm) {
+      const { customerId, budgetId, dailyAmount, loginCustomerId, confirm } = a;
+      const cid = String(customerId).replace(/-/g, "");
+      const micros = toMicros(Number(dailyAmount));
+      if (!confirm) {
         return preview("google_ads_update_campaign_budget", {
           customer: cid,
-          budget: a.budgetId,
-          newDailyBudget: a.dailyAmount,
+          budget: budgetId,
+          newDailyBudget: dailyAmount,
           inMicros: micros
         });
       }
-      const result = await client.mutate(cid, "campaignBudgets", [
+      const result2 = await request(
+        `${ADS_BASE}/customers/${cid}/campaignBudgets:mutate`,
         {
-          update: {
-            resourceName: resourceName(cid, "campaignBudgets", a.budgetId),
-            amountMicros: String(micros)
-          },
-          updateMask: "amount_micros"
-        }
-      ], a.loginCustomerId);
-      return ok2({ applied: true, action: "google_ads_update_campaign_budget", result });
+          method: "POST",
+          headers: await headers(loginCustomerId),
+          body: JSON.stringify({
+            operations: [
+              {
+                update: { resourceName: `customers/${cid}/campaignBudgets/${budgetId}`, amountMicros: String(micros) },
+                updateMask: "amount_micros"
+              }
+            ]
+          })
+        },
+        "Google Ads budget update"
+      );
+      return ok2({ applied: true, action: "google_ads_update_campaign_budget", result: result2 });
     }
   );
-  server.tool(
-    "google_ads_update_adgroup_bid",
-    "Change the default CPC bid of a Google Ads ad group. The amount is in the account currency (1.20 for 1.20 EUR). Has no effect on a campaign using an automated bidding strategy. Previews by default.",
+  c.tool(
+    "google_ads_rename_campaign",
+    "Rename a Google Ads campaign. The name is the only thing that changes: delivery, budget and targeting are untouched. Previews by default.",
     {
-      customerId: z6.string().describe("Google Ads customer ID, with or without dashes."),
-      adGroupId: z6.string().describe("Ad group ID."),
-      cpcBid: z6.number().positive().describe("New default CPC bid, in the account currency."),
-      loginCustomerId: loginCustomerIdSchema2,
+      customerId: z8.string().describe("Google Ads customer ID, with or without dashes."),
+      campaignId: z8.string().describe("Campaign ID."),
+      name: z8.string().min(1).max(255).describe("New campaign name."),
+      loginCustomerId: z8.string().optional().describe("Manager account ID, when the customer sits under an MCC. Omit otherwise."),
       confirm: confirmSchema
     },
     async (a) => {
-      const cid = stripDashes(a.customerId);
-      let micros;
-      try {
-        micros = toMicros(Number(a.cpcBid));
-      } catch (error) {
-        return ko(error instanceof Error ? error.message : String(error));
-      }
-      if (!a.confirm) {
-        return preview("google_ads_update_adgroup_bid", {
-          customer: cid,
-          adGroup: a.adGroupId,
-          newCpcBid: a.cpcBid,
-          inMicros: micros
-        });
-      }
-      const result = await client.mutate(cid, "adGroups", [
+      const { customerId, campaignId, name, loginCustomerId, confirm } = a;
+      const cid = String(customerId).replace(/-/g, "");
+      if (!confirm) return preview("google_ads_rename_campaign", { customer: cid, campaign: campaignId, newName: name });
+      const result2 = await request(
+        `${ADS_BASE}/customers/${cid}/campaigns:mutate`,
         {
-          update: {
-            resourceName: resourceName(cid, "adGroups", a.adGroupId),
-            cpcBidMicros: String(micros)
-          },
-          updateMask: "cpc_bid_micros"
-        }
-      ], a.loginCustomerId);
-      return ok2({ applied: true, action: "google_ads_update_adgroup_bid", result });
+          method: "POST",
+          headers: await headers(loginCustomerId),
+          body: JSON.stringify({
+            operations: [{ update: { resourceName: `customers/${cid}/campaigns/${campaignId}`, name }, updateMask: "name" }]
+          })
+        },
+        "Google Ads rename"
+      );
+      return ok2({ applied: true, action: "google_ads_rename_campaign", result: result2 });
     }
   );
-  server.tool(
+  c.tool(
     "google_ads_update_campaign_schedule",
     "Change the start or end date of a Google Ads campaign. Dates are YYYY-MM-DD in the account time zone. Previews by default.",
     {
-      customerId: z6.string().describe("Google Ads customer ID, with or without dashes."),
-      campaignId: z6.string().describe("Campaign ID."),
-      startDate: z6.string().regex(/^\d{4}-\d{2}-\d{2}$/).optional().describe("Start date, YYYY-MM-DD, in the account time zone."),
-      endDate: z6.string().regex(/^\d{4}-\d{2}-\d{2}$/).optional().describe("End date, YYYY-MM-DD. Use 2037-12-30 to mean no end date, which is what Google stores."),
-      loginCustomerId: loginCustomerIdSchema2,
+      customerId: z8.string().describe("Google Ads customer ID, with or without dashes."),
+      campaignId: z8.string().describe("Campaign ID."),
+      startDate: z8.string().regex(/^\d{4}-\d{2}-\d{2}$/).optional().describe("Start date, YYYY-MM-DD, in the account time zone."),
+      endDate: z8.string().regex(/^\d{4}-\d{2}-\d{2}$/).optional().describe("Use 2037-12-30 to clear the end date (run indefinitely)."),
+      loginCustomerId: z8.string().optional().describe("Manager account ID, when the customer sits under an MCC. Omit otherwise."),
       confirm: confirmSchema
     },
     async (a) => {
-      const { startDate, endDate } = a;
+      const { customerId, campaignId, startDate, endDate, loginCustomerId, confirm } = a;
       if (!startDate && !endDate) return ko("Provide startDate, endDate, or both.");
-      if (startDate && endDate && startDate > endDate) {
+      for (const date of [startDate, endDate]) {
+        if (date && (Number.isNaN(Date.parse(String(date))) || new Date(String(date)).toISOString().slice(0, 10) !== date)) return ko("Invalid calendar date.");
+      }
+      if (startDate && endDate && String(startDate) > String(endDate)) {
         return ko(`startDate ${startDate} is after endDate ${endDate}.`);
       }
-      const cid = stripDashes(a.customerId);
-      const update = {
-        resourceName: resourceName(cid, "campaigns", a.campaignId)
-      };
+      const cid = String(customerId).replace(/-/g, "");
+      const update = { resourceName: `customers/${cid}/campaigns/${campaignId}` };
       const mask = [];
       if (startDate) {
-        update.startDate = startDate;
-        mask.push("start_date");
+        update.startDateTime = `${startDate} 00:00:00`;
+        mask.push("start_date_time");
       }
       if (endDate) {
-        update.endDate = endDate;
-        mask.push("end_date");
-      }
-      if (!a.confirm) {
-        return preview("google_ads_update_campaign_schedule", {
-          customer: cid,
-          campaign: a.campaignId,
-          startDate,
-          endDate
-        });
+        if (endDate !== "2037-12-30") update.endDateTime = `${endDate} 23:59:59`;
+        mask.push("end_date_time");
       }
-      const result = await client.mutate(cid, "campaigns", [
-        { update, updateMask: mask.join(",") }
-      ], a.loginCustomerId);
-      return ok2({ applied: true, action: "google_ads_update_campaign_schedule", result });
+      if (!confirm) return preview("google_ads_update_campaign_schedule", { customer: cid, campaign: campaignId, startDate, endDate });
+      const result2 = await request(
+        `${ADS_BASE}/customers/${cid}/campaigns:mutate`,
+        {
+          method: "POST",
+          headers: await headers(loginCustomerId),
+          body: JSON.stringify({ operations: [{ update, updateMask: mask.join(",") }] })
+        },
+        "Google Ads schedule update"
+      );
+      return ok2({ applied: true, action: "google_ads_update_campaign_schedule", result: result2 });
+    }
+  );
+  c.tool(
+    "google_ads_update_adgroup_status",
+    "Pause, re-enable or remove a Google Ads ad group. Previews by default.",
+    {
+      customerId: z8.string().describe("Google Ads customer ID, with or without dashes."),
+      adGroupId: z8.string().describe("Ad group ID."),
+      status: z8.enum(["PAUSED", "ENABLED", "REMOVED"]).describe("New status."),
+      loginCustomerId: z8.string().optional().describe("Manager account ID, when the customer sits under an MCC. Omit otherwise."),
+      confirm: confirmSchema
+    },
+    async (a) => {
+      const { customerId, adGroupId, status, loginCustomerId, confirm } = a;
+      const cid = String(customerId).replace(/-/g, "");
+      if (!confirm) return preview("google_ads_update_adgroup_status", { customer: cid, adGroup: adGroupId, newStatus: status });
+      const result2 = await request(
+        `${ADS_BASE}/customers/${cid}/adGroups:mutate`,
+        {
+          method: "POST",
+          headers: await headers(loginCustomerId),
+          body: JSON.stringify({
+            operations: [status === "REMOVED" ? { remove: `customers/${cid}/adGroups/${adGroupId}` } : { update: { resourceName: `customers/${cid}/adGroups/${adGroupId}`, status }, updateMask: "status" }]
+          })
+        },
+        "Google Ads ad group status"
+      );
+      return ok2({ applied: true, action: "google_ads_update_adgroup_status", result: result2 });
+    }
+  );
+  c.tool(
+    "google_ads_update_adgroup_bid",
+    "Change the default CPC bid of a Google Ads ad group. The amount is in the account currency (1.20 for 1.20 EUR). Has no effect on a campaign using an automated bidding strategy. Previews by default.",
+    {
+      customerId: z8.string().describe("Google Ads customer ID, with or without dashes."),
+      adGroupId: z8.string().describe("Ad group ID."),
+      cpcBid: z8.number().positive().describe("New default CPC bid, in the account currency."),
+      loginCustomerId: z8.string().optional().describe("Manager account ID, when the customer sits under an MCC. Omit otherwise."),
+      confirm: confirmSchema
+    },
+    async (a) => {
+      const { customerId, adGroupId, cpcBid, loginCustomerId, confirm } = a;
+      const cid = String(customerId).replace(/-/g, "");
+      const micros = toMicros(Number(cpcBid));
+      if (!confirm) return preview("google_ads_update_adgroup_bid", { customer: cid, adGroup: adGroupId, newCpcBid: cpcBid, inMicros: micros });
+      const result2 = await request(
+        `${ADS_BASE}/customers/${cid}/adGroups:mutate`,
+        {
+          method: "POST",
+          headers: await headers(loginCustomerId),
+          body: JSON.stringify({
+            operations: [{
+              update: { resourceName: `customers/${cid}/adGroups/${adGroupId}`, cpcBidMicros: String(micros) },
+              updateMask: "cpc_bid_micros"
+            }]
+          })
+        },
+        "Google Ads ad group bid"
+      );
+      return ok2({ applied: true, action: "google_ads_update_adgroup_bid", result: result2 });
     }
   );
 }
@@ -8703,21 +9927,23 @@ function registerGoogleAdsWrites(server, config) {
 // src/platforms/google-ads/index.ts
 function registerGoogleAds(server, config) {
   registerGoogleAdsTools(server, config);
+  registerGoogleVideoReads(server, config);
   registerGoogleAdsResources(server);
-  logger.info("google-ads", "Registered 31 read tools and 5 resources");
+  logger.info("google-ads", "Registered 35 read tools and 5 resources");
   if (config.enableWrites) {
     registerGoogleAdsWrites(server, config);
-    logger.info("google-ads", "Registered 7 write tools (every one previews before it applies)");
+    logger.info("google-ads", "Registered 10 write tools (every one previews before it applies)");
   }
 }
 
 // src/server.ts
-var PACKAGE_VERSION = "1.0.0";
+var PACKAGE_VERSION = "2.0.0";
 function createServer(config) {
   const server = new McpServer(
-    { name: "google-ads-mcp", version: PACKAGE_VERSION },
+    { name: "google-ads-mcp", version: PACKAGE_VERSION, title: "Google Ads", websiteUrl: "https://www.getmcpads.com/tools/google-ads", icons: [{ src: "https://mcp.getmcpads.com/icon.svg", mimeType: "image/svg+xml" }] },
     { capabilities: { tools: { listChanged: true }, resources: { subscribe: false, listChanged: true } } }
   );
+  installToolQuality(server);
   registerGoogleAds(server, config);
   logger.system(
     `google-ads-mcp v${PACKAGE_VERSION} ready, writes ${config.enableWrites ? "enabled" : "disabled"}`