mcp-google-ads 1.1.0 → 1.2.2

package/README.md

@@ -1,6 +1,6 @@
 # MCP Google Ads Server
 
-An MCP (Model Context Protocol) server for the Google Ads API with built-in safeguards for review before changes go live. Production-proven with MCC (Manager Account) support, 34 tools for campaign management, reporting, and optimization.
+An MCP (Model Context Protocol) server for the Google Ads API with built-in safeguards for review before changes go live. Production-proven with MCC (Manager Account) support, 36 tools for campaign management, reporting, and optimization. v1.2.0 adds Demand Gen campaign creation end-to-end.
 
 ## Features
 
@@ -148,7 +148,7 @@ Restart Claude Code.
 5. Claude enables (requires your approval prompt)
 ```
 
-### Available Tools (34)
+### Available Tools (36)
 
 #### Context & Discovery
 | Tool | Description |
@@ -162,9 +162,11 @@ Restart Claude Code.
 #### Campaign Management
 | Tool | Description |
 |------|-------------|
-| `google_ads_create_campaign` | Create campaign (PAUSED) |
-| `google_ads_create_ad_group` | Create ad group (PAUSED) |
+| `google_ads_create_campaign` | Create campaign (PAUSED). Supports SEARCH + DEMAND_GEN channels, richer bidding (MANUAL_CPC / MAXIMIZE_CLICKS / MAXIMIZE_CONVERSIONS / TARGET_CPA), geo + language targeting, start/end dates |
+| `google_ads_create_ad_group` | Create ad group (PAUSED). `type` accepts SEARCH_STANDARD (default) or DEMAND_GEN_MULTI_ASSET_AD_GROUP |
 | `google_ads_create_responsive_search_ad` | Create RSA with validation (PAUSED) |
+| `google_ads_create_image_asset` | Upload PNG/JPG/GIF image asset (validates ≤5MB, ≥600×314) for use in Demand Gen ads |
+| `google_ads_create_demand_gen_multi_asset_ad` | Create a Demand Gen multi-asset ad (PAUSED) — validates char/count caps before API call, fails fast if ad_group isn't DG |
 | `google_ads_create_keywords` | Create keywords (PAUSED) |
 | `google_ads_validate_ad` | Validate RSA without creating |
 | `google_ads_enable_items` | Enable items (make LIVE) — **requires approval** |
@@ -233,6 +235,55 @@ Restart Claude Code.
 "Run a GAQL query to get all ad groups with CTR below 2%"
 ```
 
+### Example: Create a Demand Gen Campaign End-to-End
+
+```
+# 1. Campaign: $75/day, DEMAND_GEN channel, MAXIMIZE_CONVERSIONS default,
+#    targeting Alaska (21134) + Maine (21141) in English
+google_ads_create_campaign({
+  name: "DG - Spring Promo",
+  daily_budget: 75,
+  channel_type: "DEMAND_GEN",
+  geo_target_ids: ["21134", "21141"],
+  start_date: "2026-05-01",
+  end_date: "2026-06-30"
+})
+# → campaign_id: 555123
+
+# 2. Ad group: DEMAND_GEN_MULTI_ASSET_AD_GROUP
+google_ads_create_ad_group({
+  campaign_id: "555123",
+  name: "DG AG 1",
+  type: "DEMAND_GEN_MULTI_ASSET_AD_GROUP"
+})
+# → ad_group_id: 555456
+
+# 3. Image assets (PNG/JPG/GIF, ≥600×314, ≤5MB). Returns {asset_id, ...}
+google_ads_create_image_asset({ name: "hero-landscape", file_path: "/abs/path/hero.png" })
+# → asset_id: 42001
+google_ads_create_image_asset({ name: "hero-square",    file_path: "/abs/path/square.png" })
+# → asset_id: 42002
+google_ads_create_image_asset({ name: "logo",           file_path: "/abs/path/logo.png" })
+# → asset_id: 42003
+
+# 4. Demand Gen multi-asset ad (PAUSED). Validates char + count caps first.
+google_ads_create_demand_gen_multi_asset_ad({
+  ad_group_id: "555456",
+  final_urls: ["https://example.com/spring"],
+  business_name: "Example Org",
+  call_to_action: "LEARN_MORE",
+  marketing_image_asset_ids: ["42001"],          // 1.91:1 landscape, ≥1 required
+  square_marketing_image_asset_ids: ["42002"],   // 1:1 optional
+  logo_image_asset_ids: ["42003"],               // logo optional
+  headlines: ["Spring Sale Now On", "Save 20% Today"],     // max 5, ≤40 chars each
+  long_headlines: ["A longer pitch under ninety characters."], // max 5, ≤90 chars
+  descriptions: ["Shop the latest looks.", "Free returns."]   // max 5, ≤90 chars each
+})
+# → resource_name: customers/.../adGroupAds/555456~67890000
+```
+
+After all four calls the campaign, ad group, and ad all live in your account in PAUSED state and are labeled `Claude-MM-DD-YY`. Review in the Google Ads UI, then enable via `google_ads_enable_items`.
+
 ## Safety Features
 
 1. **Everything starts PAUSED** — Nothing goes live until you explicitly enable it

package/dist/adGroupBuilder.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Pure builder for ad-group creation payloads. Separate from the manager so
+ * it can be unit-tested without stubbing the live API.
+ *
+ * `type` for DEMAND_GEN_MULTI_ASSET_AD_GROUP emits the raw proto value 21
+ * because the google-ads-api v23 enum map does not include it; the typed
+ * AdGroup create path validates against the local enum, so DG creation must
+ * flow through customer.mutateResources (which trusts the numeric value).
+ */
+export type AdGroupTypeName = "SEARCH_STANDARD" | "DEMAND_GEN_MULTI_ASSET_AD_GROUP";
+export declare const AD_GROUP_TYPE_DEMAND_GEN_MULTI_ASSET = 21;
+export interface AdGroupCreateInput {
+    customer_id_clean: string;
+    name: string;
+    campaign_id: string;
+    cpc_bid_micros?: number;
+    type?: AdGroupTypeName;
+}
+export interface AdGroupCreatePayload {
+    name: string;
+    campaign: string;
+    status: number;
+    cpc_bid_micros: number;
+    type: number;
+}
+export declare function buildAdGroupCreatePayload(input: AdGroupCreateInput): AdGroupCreatePayload;

package/dist/adGroupBuilder.js

@@ -0,0 +1,17 @@
+import { enums } from "google-ads-api";
+const AD_GROUP_TYPE_DEMAND_GEN_MULTI_ASSET = 21;
+function buildAdGroupCreatePayload(input) {
+  const typeEnum = input.type === "DEMAND_GEN_MULTI_ASSET_AD_GROUP" ? AD_GROUP_TYPE_DEMAND_GEN_MULTI_ASSET : enums.AdGroupType.SEARCH_STANDARD;
+  return {
+    name: input.name,
+    campaign: `customers/${input.customer_id_clean}/campaigns/${input.campaign_id}`,
+    status: enums.AdGroupStatus.PAUSED,
+    cpc_bid_micros: input.cpc_bid_micros ?? 1e6,
+    type: typeEnum
+  };
+}
+export {
+  AD_GROUP_TYPE_DEMAND_GEN_MULTI_ASSET,
+  buildAdGroupCreatePayload
+};
+//# sourceMappingURL=adGroupBuilder.js.map

package/dist/assetHelpers.d.ts

@@ -0,0 +1,55 @@
+export interface AssetUrlUpdate {
+    asset_id: string;
+    final_urls: string[];
+}
+export interface UpdateAssetUrlsArgs {
+    customer_id?: string;
+    updates: AssetUrlUpdate[];
+    confirm?: boolean;
+}
+export interface PauseAssetLinksArgs {
+    customer_id?: string;
+    resource_names: string[];
+    confirm?: boolean;
+}
+export type AssetLinkLevel = "customer_asset" | "campaign_asset" | "ad_group_asset";
+export interface ParsedAssetLink {
+    level: AssetLinkLevel;
+    customer_id: string;
+    resource_name: string;
+}
+export declare function parseAssetLinkResourceName(rn: string): ParsedAssetLink | {
+    error: string;
+};
+export declare function validateFinalUrls(urls: unknown): {
+    ok: true;
+    urls: string[];
+} | {
+    ok: false;
+    error: string;
+};
+export declare function normalizeUpdateAssetUrlsArgs(raw: Record<string, unknown> | undefined): UpdateAssetUrlsArgs | {
+    error: string;
+};
+export declare function normalizePauseAssetLinksArgs(raw: Record<string, unknown> | undefined): PauseAssetLinksArgs | {
+    error: string;
+};
+export interface UpdateUrlsDryRun {
+    dry_run: true;
+    message: string;
+    customer_id: string;
+    updates: AssetUrlUpdate[];
+    warning: string;
+}
+export declare function buildUpdateUrlsDryRun(args: UpdateAssetUrlsArgs): UpdateUrlsDryRun;
+export interface PauseLinksDryRun {
+    dry_run: true;
+    message: string;
+    customer_id: string;
+    would_pause: {
+        customer_asset: string[];
+        campaign_asset: string[];
+        ad_group_asset: string[];
+    };
+}
+export declare function buildPauseLinksDryRun(args: PauseAssetLinksArgs): PauseLinksDryRun;

package/dist/assetHelpers.js

@@ -0,0 +1,129 @@
+const RE_CUSTOMER_ASSET = /^customers\/(\d+)\/customerAssets\/[^/]+$/;
+const RE_CAMPAIGN_ASSET = /^customers\/(\d+)\/campaignAssets\/[^/]+$/;
+const RE_AD_GROUP_ASSET = /^customers\/(\d+)\/adGroupAssets\/[^/]+$/;
+function parseAssetLinkResourceName(rn) {
+  const trimmed = rn.trim();
+  let m = trimmed.match(RE_CUSTOMER_ASSET);
+  if (m) return { level: "customer_asset", customer_id: m[1], resource_name: trimmed };
+  m = trimmed.match(RE_CAMPAIGN_ASSET);
+  if (m) return { level: "campaign_asset", customer_id: m[1], resource_name: trimmed };
+  m = trimmed.match(RE_AD_GROUP_ASSET);
+  if (m) return { level: "ad_group_asset", customer_id: m[1], resource_name: trimmed };
+  return {
+    error: `Unrecognized asset-link resource name: "${rn}". Expected customers/{cid}/customerAssets/..., customers/{cid}/campaignAssets/..., or customers/{cid}/adGroupAssets/...`
+  };
+}
+function validateFinalUrls(urls) {
+  if (!Array.isArray(urls) || urls.length === 0) {
+    return { ok: false, error: "final_urls must be a non-empty array" };
+  }
+  const cleaned = [];
+  for (const u of urls) {
+    if (typeof u !== "string") return { ok: false, error: `final_urls entries must be strings, got ${typeof u}` };
+    const t = u.trim();
+    if (!t) return { ok: false, error: "final_urls entries must be non-empty" };
+    if (!/^https?:\/\//i.test(t)) {
+      return { ok: false, error: `final_urls entry "${t}" must start with http:// or https://` };
+    }
+    cleaned.push(t);
+  }
+  return { ok: true, urls: cleaned };
+}
+function coerceArray(v) {
+  if (Array.isArray(v)) return v;
+  if (typeof v === "string") {
+    const t = v.trim();
+    if (t.startsWith("[")) {
+      try {
+        const p = JSON.parse(t);
+        if (Array.isArray(p)) return p;
+      } catch {
+      }
+    }
+  }
+  return void 0;
+}
+function normalizeUpdateAssetUrlsArgs(raw) {
+  const r = raw ?? {};
+  const customer_id = typeof r.customer_id === "string" ? r.customer_id : void 0;
+  const rawUpdates = coerceArray(r.updates);
+  if (!rawUpdates || rawUpdates.length === 0) {
+    return { error: "updates must be a non-empty array" };
+  }
+  const updates = [];
+  for (const u of rawUpdates) {
+    if (!u || typeof u !== "object") return { error: "each updates entry must be an object" };
+    const obj = u;
+    const asset_id = typeof obj.asset_id === "string" ? obj.asset_id.trim() : typeof obj.asset_id === "number" ? String(obj.asset_id) : "";
+    if (!asset_id || !/^\d+$/.test(asset_id)) {
+      return { error: `invalid asset_id: ${JSON.stringify(obj.asset_id)}. Expected numeric asset ID.` };
+    }
+    const v = validateFinalUrls(obj.final_urls);
+    if (!v.ok) return { error: `asset_id ${asset_id}: ${v.error}` };
+    updates.push({ asset_id, final_urls: v.urls });
+  }
+  return {
+    customer_id,
+    updates,
+    confirm: r.confirm === true || r.confirm === "true"
+  };
+}
+function normalizePauseAssetLinksArgs(raw) {
+  const r = raw ?? {};
+  const customer_id = typeof r.customer_id === "string" ? r.customer_id : void 0;
+  const rawRns = coerceArray(r.resource_names);
+  if (!rawRns || rawRns.length === 0) {
+    return { error: "resource_names must be a non-empty array" };
+  }
+  const resource_names = [];
+  for (const rn of rawRns) {
+    if (typeof rn !== "string" || !rn.trim()) {
+      return { error: "each resource_names entry must be a non-empty string" };
+    }
+    const parsed = parseAssetLinkResourceName(rn);
+    if ("error" in parsed) return { error: parsed.error };
+    resource_names.push(parsed.resource_name);
+  }
+  return {
+    customer_id,
+    resource_names,
+    confirm: r.confirm === true || r.confirm === "true"
+  };
+}
+function buildUpdateUrlsDryRun(args) {
+  return {
+    dry_run: true,
+    message: "DRY RUN. Nothing changed. Pass confirm: true to actually update.",
+    customer_id: args.customer_id ?? "",
+    updates: args.updates,
+    warning: "Updating an asset's final_urls affects EVERY campaign/ad group/customer link that uses this asset ID. Verify attachments before confirming."
+  };
+}
+function buildPauseLinksDryRun(args) {
+  const would = {
+    customer_asset: [],
+    campaign_asset: [],
+    ad_group_asset: []
+  };
+  for (const rn of args.resource_names) {
+    const parsed = parseAssetLinkResourceName(rn);
+    if (!("error" in parsed)) {
+      would[parsed.level].push(parsed.resource_name);
+    }
+  }
+  return {
+    dry_run: true,
+    message: "DRY RUN. Nothing paused. Pass confirm: true to actually pause.",
+    customer_id: args.customer_id ?? "",
+    would_pause: would
+  };
+}
+export {
+  buildPauseLinksDryRun,
+  buildUpdateUrlsDryRun,
+  normalizePauseAssetLinksArgs,
+  normalizeUpdateAssetUrlsArgs,
+  parseAssetLinkResourceName,
+  validateFinalUrls
+};
+//# sourceMappingURL=assetHelpers.js.map

package/dist/auth-cli.js

@@ -1,8 +1,9 @@
 #!/usr/bin/env node
+import { realpathSync } from "fs";
 import { GoogleAdsApi } from "google-ads-api";
 import http from "http";
 import promptsImport from "prompts";
-import { URL } from "url";
+import { URL, fileURLToPath } from "url";
 import { writeStoredCredentials, credentialsFilePath, CREDENTIALS_FILE_VERSION } from "./credentials.js";
 import {
   EMBEDDED_CLIENT_ID,
@@ -369,7 +370,17 @@ function randomState() {
   globalThis.crypto.getRandomValues(bytes);
   return Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("");
 }
-const isMain = import.meta.url === `file://${process.argv[1]}` || process.argv[1]?.endsWith("/auth-cli.js") || process.argv[1]?.endsWith("\\auth-cli.js");
+function isMainModule() {
+  if (!process.argv[1]) return false;
+  try {
+    const scriptRealPath = realpathSync(process.argv[1]);
+    const moduleRealPath = realpathSync(fileURLToPath(import.meta.url));
+    return scriptRealPath === moduleRealPath;
+  } catch {
+    return false;
+  }
+}
+const isMain = isMainModule();
 if (isMain) {
   run().catch((err) => {
     const classified = classifyError(err);

package/dist/build-info.json

@@ -1,5 +1,5 @@
 {
-  "sha": "fceb9f2",
-  "builtAt": "2026-04-13T00:50:57.276Z",
+  "sha": "d3b40c7",
+  "builtAt": "2026-04-17T20:02:21.153Z",
   "embeddedSecrets": true
 }

package/dist/campaignBuilder.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Pure builders for campaign creation. Produces the raw operation payloads
+ * that would be submitted via customer.campaigns.create / campaignBudgets.create
+ * / campaignCriteria.create. Kept as pure functions so they can be unit tested
+ * without needing a live Google Ads API client.
+ *
+ * Note: we return the payloads, not the operations, so callers can still use
+ * typed create(...) paths. For criteria, we return an array that may be empty.
+ */
+export type ChannelType = "SEARCH" | "DEMAND_GEN";
+export type BiddingStrategy = "MANUAL_CPC" | "MAXIMIZE_CLICKS" | "MAXIMIZE_CONVERSIONS" | "TARGET_CPA";
+export interface CampaignCreateInput {
+    name: string;
+    budget_amount_micros: number;
+    channel_type?: ChannelType;
+    bidding_strategy?: BiddingStrategy;
+    target_cpa?: number;
+    target_cpc_cap?: number;
+    geo_target_ids?: string[];
+    language_id?: string;
+    start_date?: string;
+    end_date?: string;
+}
+export interface CampaignCreatePayload {
+    budget: Record<string, any>;
+    campaign: Record<string, any>;
+    /** Campaign-criterion payloads. `campaign` resource name is applied later
+     *  (after the campaign exists). Here the shape is pre-resolution. */
+    criteria: Array<Record<string, any>>;
+}
+/**
+ * Build the operation payloads for a campaign creation. Does NOT attach
+ * resource_name references that only exist post-budget-create; the caller
+ * still has to call the budget first, then interpolate.
+ *
+ * Back-compat: calling with just {name, budget_amount_micros} produces the
+ * exact same SEARCH + manual_cpc + no-criteria shape as v1.1.
+ */
+export declare function buildCampaignCreatePayload(input: CampaignCreateInput): CampaignCreatePayload;

package/dist/campaignBuilder.js

@@ -0,0 +1,65 @@
+import { enums } from "google-ads-api";
+function buildCampaignCreatePayload(input) {
+  const budget = {
+    name: `${input.name} Budget`,
+    amount_micros: input.budget_amount_micros,
+    delivery_method: enums.BudgetDeliveryMethod.STANDARD,
+    // Google Ads API defaults to explicitly_shared=true when omitted, which
+    // makes auto-bidding strategies (MAXIMIZE_CONVERSIONS, TARGET_CPA, etc.)
+    // reject with "Bidding strategy type is incompatible with shared budget".
+    // Every MCP-created campaign has a 1:1 dedicated budget, so pin this
+    // explicitly to false.
+    explicitly_shared: false
+  };
+  const channelType = input.channel_type ?? "SEARCH";
+  const channelEnum = channelType === "DEMAND_GEN" ? enums.AdvertisingChannelType.DEMAND_GEN : enums.AdvertisingChannelType.SEARCH;
+  const strategy = input.bidding_strategy ?? (channelType === "DEMAND_GEN" ? "MAXIMIZE_CONVERSIONS" : "MANUAL_CPC");
+  const campaign = {
+    name: input.name,
+    status: enums.CampaignStatus.PAUSED,
+    advertising_channel_type: channelEnum
+  };
+  if (input.start_date) campaign.start_date = input.start_date;
+  if (input.end_date) campaign.end_date = input.end_date;
+  switch (strategy) {
+    case "MANUAL_CPC":
+      campaign.manual_cpc = {};
+      break;
+    case "MAXIMIZE_CONVERSIONS":
+      campaign.maximize_conversions = {};
+      break;
+    case "TARGET_CPA": {
+      if (typeof input.target_cpa !== "number") {
+        throw new Error("bidding_strategy=TARGET_CPA requires target_cpa (dollars)");
+      }
+      campaign.target_cpa = { target_cpa_micros: Math.round(input.target_cpa * 1e6) };
+      break;
+    }
+    case "MAXIMIZE_CLICKS": {
+      const cap = {};
+      if (typeof input.target_cpc_cap === "number") {
+        cap.cpc_bid_ceiling_micros = Math.round(input.target_cpc_cap * 1e6);
+      }
+      campaign.target_spend = cap;
+      break;
+    }
+  }
+  const criteria = [];
+  for (const geoId of input.geo_target_ids ?? []) {
+    criteria.push({ location: { geo_target_constant: `geoTargetConstants/${geoId}` } });
+  }
+  const hasGeo = (input.geo_target_ids?.length ?? 0) > 0;
+  if (hasGeo || input.language_id) {
+    const langId = input.language_id ?? "1000";
+    criteria.push({ language: { language_constant: `languageConstants/${langId}` } });
+  }
+  return {
+    budget,
+    campaign,
+    criteria
+  };
+}
+export {
+  buildCampaignCreatePayload
+};
+//# sourceMappingURL=campaignBuilder.js.map

package/dist/imageAsset.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Pure helpers for google_ads_create_image_asset. Separated from the manager
+ * so validation logic (mime type, size caps, min dimensions) can be unit tested
+ * without touching disk or the Google Ads API.
+ */
+export interface ImageInput {
+    name: string;
+    file_path?: string;
+    base64_data?: string;
+}
+export interface ImageValidationResult {
+    valid: boolean;
+    errors: string[];
+}
+export declare const MAX_IMAGE_BYTES = 5242880;
+export declare const MIN_IMAGE_WIDTH = 600;
+export declare const MIN_IMAGE_HEIGHT = 314;
+export declare const ALLOWED_MIME_TYPES: readonly ["image/png", "image/jpeg", "image/gif"];
+/**
+ * Detect image mime type from magic bytes. Returns null for anything that
+ * isn't PNG/JPEG/GIF. Google Ads asset uploads only accept these three formats
+ * for image assets.
+ */
+export declare function detectMimeType(bytes: Buffer | Uint8Array): "image/png" | "image/jpeg" | "image/gif" | null;
+/**
+ * Return {width, height} parsed from image headers for PNG / JPEG / GIF.
+ * Returns null if the header couldn't be parsed (too short, unexpected format).
+ * We only support these 3 formats — Google Ads image assets accept the same set.
+ */
+export declare function getImageDimensions(bytes: Buffer, mime: "image/png" | "image/jpeg" | "image/gif"): {
+    width: number;
+    height: number;
+} | null;
+export declare function validateImageInput(input: ImageInput): ImageValidationResult;
+export interface PreparedImage {
+    valid: boolean;
+    errors: string[];
+    /** Populated only when valid=true. */
+    bytes?: Buffer;
+    mime_type?: "image/png" | "image/jpeg" | "image/gif";
+    width?: number;
+    height?: number;
+}
+/**
+ * End-to-end validation + decode: given the tool inputs, read the bytes
+ * (from disk or base64), sniff the mime type, check size + dimensions, and
+ * return a PreparedImage ready to be handed to customer.assets.create.
+ *
+ * Does NOT hit the Google Ads API. All errors are returned in errors[].
+ */
+export declare function prepareImageForUpload(input: ImageInput): PreparedImage;

package/dist/imageAsset.js

@@ -0,0 +1,153 @@
+import { readFileSync, existsSync, statSync } from "fs";
+const MAX_IMAGE_BYTES = 5242880;
+const MIN_IMAGE_WIDTH = 600;
+const MIN_IMAGE_HEIGHT = 314;
+const ALLOWED_MIME_TYPES = ["image/png", "image/jpeg", "image/gif"];
+function detectMimeType(bytes) {
+  if (!bytes || bytes.length < 4) return null;
+  if (bytes[0] === 137 && bytes[1] === 80 && bytes[2] === 78 && bytes[3] === 71) {
+    return "image/png";
+  }
+  if (bytes[0] === 255 && bytes[1] === 216 && bytes[2] === 255) {
+    return "image/jpeg";
+  }
+  if (bytes.length >= 6 && bytes[0] === 71 && bytes[1] === 73 && bytes[2] === 70 && bytes[3] === 56 && (bytes[4] === 55 || bytes[4] === 57) && bytes[5] === 97) {
+    return "image/gif";
+  }
+  return null;
+}
+function getImageDimensions(bytes, mime) {
+  try {
+    if (mime === "image/png") {
+      if (bytes.length < 24) return null;
+      return {
+        width: bytes.readUInt32BE(16),
+        height: bytes.readUInt32BE(20)
+      };
+    }
+    if (mime === "image/gif") {
+      if (bytes.length < 10) return null;
+      return {
+        width: bytes.readUInt16LE(6),
+        height: bytes.readUInt16LE(8)
+      };
+    }
+    if (mime === "image/jpeg") {
+      let i = 2;
+      while (i < bytes.length - 9) {
+        if (bytes[i] !== 255) return null;
+        const marker = bytes[i + 1];
+        if (marker >= 192 && marker <= 207 && marker !== 196 && marker !== 200 && marker !== 204) {
+          const height = bytes.readUInt16BE(i + 5);
+          const width = bytes.readUInt16BE(i + 7);
+          return { width, height };
+        }
+        const segmentLen = bytes.readUInt16BE(i + 2);
+        i += 2 + segmentLen;
+      }
+      return null;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+function validateImageInput(input) {
+  const errors = [];
+  if (!input.name || !input.name.trim()) {
+    errors.push("name is required");
+  }
+  const hasPath = typeof input.file_path === "string" && input.file_path.trim().length > 0;
+  const hasData = typeof input.base64_data === "string" && input.base64_data.trim().length > 0;
+  if (!hasPath && !hasData) {
+    errors.push("Either file_path or base64_data must be provided");
+  }
+  if (hasPath && hasData) {
+    errors.push("Provide exactly one of file_path or base64_data, not both");
+  }
+  return { valid: errors.length === 0, errors };
+}
+function prepareImageForUpload(input) {
+  const inputValidation = validateImageInput(input);
+  if (!inputValidation.valid) {
+    return { valid: false, errors: inputValidation.errors };
+  }
+  let bytes;
+  try {
+    if (input.file_path) {
+      if (!existsSync(input.file_path)) {
+        return {
+          valid: false,
+          errors: [`File not found: ${input.file_path}`]
+        };
+      }
+      const stat = statSync(input.file_path);
+      if (!stat.isFile()) {
+        return {
+          valid: false,
+          errors: [`Path is not a regular file: ${input.file_path}`]
+        };
+      }
+      bytes = readFileSync(input.file_path);
+    } else {
+      bytes = Buffer.from(input.base64_data, "base64");
+      if (bytes.length === 0) {
+        return { valid: false, errors: ["base64_data decoded to zero bytes"] };
+      }
+    }
+  } catch (err) {
+    return { valid: false, errors: [`Failed to read image: ${err.message}`] };
+  }
+  const errors = [];
+  if (bytes.length > MAX_IMAGE_BYTES) {
+    errors.push(
+      `Image too large: ${bytes.length} bytes (max ${MAX_IMAGE_BYTES} = 5MB)`
+    );
+  }
+  const mime = detectMimeType(bytes);
+  if (!mime) {
+    errors.push(
+      `Unrecognized image format. Only PNG, JPEG, and GIF are accepted for Google Ads image assets.`
+    );
+    return { valid: false, errors };
+  }
+  const dims = getImageDimensions(bytes, mime);
+  if (!dims) {
+    errors.push(`Could not parse image dimensions from header (corrupt file?)`);
+    return { valid: false, errors };
+  }
+  if (dims.width < MIN_IMAGE_WIDTH || dims.height < MIN_IMAGE_HEIGHT) {
+    errors.push(
+      `Image dimensions ${dims.width}x${dims.height} are below the Demand Gen minimum ${MIN_IMAGE_WIDTH}x${MIN_IMAGE_HEIGHT}`
+    );
+  }
+  if (errors.length > 0) {
+    return {
+      valid: false,
+      errors,
+      bytes,
+      mime_type: mime,
+      width: dims.width,
+      height: dims.height
+    };
+  }
+  return {
+    valid: true,
+    errors: [],
+    bytes,
+    mime_type: mime,
+    width: dims.width,
+    height: dims.height
+  };
+}
+export {
+  ALLOWED_MIME_TYPES,
+  MAX_IMAGE_BYTES,
+  MIN_IMAGE_HEIGHT,
+  MIN_IMAGE_WIDTH,
+  detectMimeType,
+  getImageDimensions,
+  prepareImageForUpload,
+  validateImageInput
+};
+//# sourceMappingURL=imageAsset.js.map