adloop 0.18.1__tar.gz → 0.19.0__tar.gz

{adloop-0.18.1 → adloop-0.19.0}/PKG-INFO

@@ -1,12 +1,12 @@
 Metadata-Version: 2.3
 Name: adloop
-Version: 0.18.1
+Version: 0.19.0
 Summary: The AI command center for Google Ads, Reddit Ads, GA4, and tracking code.
 Keywords: mcp,google-ads,reddit-ads,google-analytics,ga4,cursor,marketing
 Author: Daniel Klose
 Author-email: Daniel Klose <info@daniel-klose.com>
 License: MIT
-Requires-Dist: fastmcp>=3.0.0
+Requires-Dist: fastmcp>=4.0
 Requires-Dist: google-ads>=32.0.0
 Requires-Dist: google-analytics-data>=0.20.0
 Requires-Dist: google-analytics-admin>=0.27.0
@@ -254,7 +254,7 @@ All write operations follow a **draft → preview → confirm** workflow. Nothin
 | `draft_responsive_search_ad` | Create RSA preview (3-15 headlines ≤30 chars, 2-4 descriptions ≤90 chars). Warns if headline/description count is below best practice. |
 | `draft_callouts` | Create campaign callout assets from 1-25 character text snippets. |
 | `draft_structured_snippets` | Create campaign structured snippet assets using official header values and 3-10 snippet values. |
-| `draft_image_assets` | Create campaign image assets from local PNG, JPEG, or GIF files. |
+| `draft_image_assets` | Create campaign image assets from local files or public image URLs (PNG, JPEG, or GIF). |
 | `draft_keywords` | Propose keyword additions with match types. Proactively checks bidding strategy — blocks BROAD match on Manual CPC campaigns. |
 | `add_negative_keywords` | Propose negative keywords directly on a campaign |
 | `add_negative_locations` | Propose negative geo exclusions on a campaign — exclude cities/regions while keeping broader positive targets |

{adloop-0.18.1 → adloop-0.19.0}/README.md

@@ -227,7 +227,7 @@ All write operations follow a **draft → preview → confirm** workflow. Nothin
 | `draft_responsive_search_ad` | Create RSA preview (3-15 headlines ≤30 chars, 2-4 descriptions ≤90 chars). Warns if headline/description count is below best practice. |
 | `draft_callouts` | Create campaign callout assets from 1-25 character text snippets. |
 | `draft_structured_snippets` | Create campaign structured snippet assets using official header values and 3-10 snippet values. |
-| `draft_image_assets` | Create campaign image assets from local PNG, JPEG, or GIF files. |
+| `draft_image_assets` | Create campaign image assets from local files or public image URLs (PNG, JPEG, or GIF). |
 | `draft_keywords` | Propose keyword additions with match types. Proactively checks bidding strategy — blocks BROAD match on Manual CPC campaigns. |
 | `add_negative_keywords` | Propose negative keywords directly on a campaign |
 | `add_negative_locations` | Propose negative geo exclusions on a campaign — exclude cities/regions while keeping broader positive targets |

{adloop-0.18.1 → adloop-0.19.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "adloop"
-version = "0.18.1"
+version = "0.19.0"
 description = "The AI command center for Google Ads, Reddit Ads, GA4, and tracking code."
 readme = "README.md"
 requires-python = ">=3.11"
@@ -14,7 +14,7 @@ keywords = [
     "marketing",
 ]
 dependencies = [
-    "fastmcp>=3.0.0",
+    "fastmcp>=4.0",
     "google-ads>=32.0.0",
     "google-analytics-data>=0.20.0",
     "google-analytics-admin>=0.27.0",

{adloop-0.18.1 → adloop-0.19.0}/pyproject.toml.orig

@@ -1,6 +1,6 @@
 [project]
 name = "adloop"
-version = "0.18.1"
+version = "0.19.0"
 description = "The AI command center for Google Ads, Reddit Ads, GA4, and tracking code."
 readme = "README.md"
 authors = [
@@ -10,7 +10,7 @@ requires-python = ">=3.11"
 license = { text = "MIT" }
 keywords = ["mcp", "google-ads", "reddit-ads", "google-analytics", "ga4", "cursor", "marketing"]
 dependencies = [
-    "fastmcp>=3.0.0",
+    "fastmcp>=4.0",
     "google-ads>=32.0.0",
     "google-analytics-data>=0.20.0",
     "google-analytics-admin>=0.27.0",

{adloop-0.18.1 → adloop-0.19.0}/src/adloop/_mcp_patches.py

@@ -71,7 +71,13 @@ def _patch_request_responder_cancel_race() -> None:
     """
     try:
         from mcp.shared import session as _session_module
-    except Exception as exc:  # pragma: no cover — mcp is a hard dep
+    except ModuleNotFoundError:
+        # mcp 2 rewrote the session layer: the racing RequestResponder is gone
+        # and the new dispatcher has a single response writer, so there is
+        # nothing to patch. Not an error.
+        _log("pysdk-2416 not applicable: mcp>=2 has no RequestResponder race")
+        return
+    except Exception as exc:  # pragma: no cover — unexpected import failure
         _log(f"skip pysdk-2416: cannot import mcp.shared.session ({exc})")
         return
 

adloop-0.19.0/src/adloop/ads/image_fetch.py

@@ -0,0 +1,331 @@
+"""Fetch ad images from public URLs without letting the fetch reach private hosts.
+
+The fetched bytes are uploaded into the user's Google Ads account, where
+they become visible. A fetch that could be steered at an internal address
+(cloud metadata, a database admin page, a loopback service) would therefore
+be a way to exfiltrate whatever lives there. So, unlike the up/down
+reachability check for landing pages, this fetcher closes the DNS-rebinding
+gap:
+
+* the hostname is resolved exactly once per request, and every resolved
+  address must be public;
+* the TCP connection goes to that resolved address (pinning) — the socket
+  never resolves the name again — while the request still carries the
+  original ``Host`` header and, for https, TLS uses the original hostname
+  for SNI and certificate verification;
+* redirects are followed by hand (at most ``MAX_REDIRECTS``), each hop
+  re-validated and re-pinned;
+* the body is streamed under a hard size cap and a wall-clock deadline;
+* the content is trusted only after sniffing the bytes, never by
+  ``Content-Type``.
+
+No cookies, credentials or auth headers are ever sent.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import http.client
+import ipaddress
+import socket
+import ssl
+import time
+from dataclasses import dataclass
+from urllib.parse import urljoin, urlsplit
+
+# Google Ads rejects image assets above 5120 KB.
+MAX_IMAGE_BYTES = 5120 * 1024
+MAX_REDIRECTS = 3
+TIMEOUT_SECONDS = 10.0
+
+_REDIRECT_STATUSES = frozenset({301, 302, 303, 307, 308})
+_CHUNK_SIZE = 64 * 1024
+_NAT64_PREFIX = ipaddress.ip_network("64:ff9b::/96")
+
+
+class ImageFetchError(ValueError):
+    """The image URL could not be fetched safely or is not a usable image."""
+
+
+@dataclass(frozen=True)
+class FetchedImage:
+    """Bytes fetched from ``url`` (after following ``final_url`` redirects)."""
+
+    url: str
+    final_url: str
+    data: bytes
+
+    @property
+    def sha256(self) -> str:
+        return hashlib.sha256(self.data).hexdigest()
+
+
+def non_public_reason(
+    addr: ipaddress.IPv4Address | ipaddress.IPv6Address,
+) -> str | None:
+    """Return why ``addr`` must not be fetched from, or None if it is public.
+
+    IPv6 forms that embed an IPv4 address (IPv4-mapped, 6to4, Teredo,
+    NAT64) are judged by the embedded address too, so ``::ffff:127.0.0.1``
+    cannot slip past as "an IPv6 address that isn't loopback".
+    """
+    if isinstance(addr, ipaddress.IPv6Address):
+        if addr.ipv4_mapped is not None:
+            # The socket really talks IPv4 to the mapped address, so that
+            # address alone decides.
+            inner_reason = non_public_reason(addr.ipv4_mapped)
+            if inner_reason is not None:
+                return f"maps to {addr.ipv4_mapped}, {inner_reason}"
+            return None
+        embedded = [addr.sixtofour, *(addr.teredo or ())]
+        if addr in _NAT64_PREFIX:
+            embedded.append(ipaddress.IPv4Address(int(addr) & 0xFFFFFFFF))
+        for inner in embedded:
+            if inner is not None and non_public_reason(inner) is not None:
+                return f"embeds non-public address {inner}"
+
+    for label in (
+        "unspecified",
+        "loopback",
+        "link_local",
+        "multicast",
+        "private",
+        "reserved",
+    ):
+        if getattr(addr, f"is_{label}"):
+            return label.replace("_", "-")
+    if not addr.is_global:
+        return "not globally routable"
+    return None
+
+
+def resolve_public_address(host: str, port: int) -> str:
+    """Resolve ``host`` once and return the address to connect to.
+
+    Raises ImageFetchError when the name does not resolve or when ANY of
+    its addresses is non-public — a hostname that mixes public and private
+    records is refused outright rather than having one picked.
+    """
+    try:
+        literal = ipaddress.ip_address(host)
+    except ValueError:
+        literal = None
+
+    if literal is not None:
+        addresses = [literal]
+    else:
+        try:
+            infos = socket.getaddrinfo(
+                host, port, type=socket.SOCK_STREAM, proto=socket.IPPROTO_TCP
+            )
+        except (OSError, UnicodeError) as exc:
+            raise ImageFetchError(f"hostname {host!r} does not resolve: {exc}") from exc
+        addresses = []
+        for info in infos:
+            try:
+                addresses.append(ipaddress.ip_address(info[4][0]))
+            except ValueError as exc:
+                raise ImageFetchError(
+                    f"hostname {host!r} resolved to an unusable address {info[4][0]!r}"
+                ) from exc
+        if not addresses:
+            raise ImageFetchError(f"hostname {host!r} has no addresses")
+
+    for addr in addresses:
+        reason = non_public_reason(addr)
+        if reason is not None:
+            raise ImageFetchError(
+                f"{host} resolves to a non-public address ({addr}, {reason}) — "
+                "refusing to fetch"
+            )
+    return str(addresses[0])
+
+
+class _PinnedHTTPConnection(http.client.HTTPConnection):
+    """HTTP connection that dials a pre-resolved IP instead of ``host``.
+
+    ``self.host`` stays the original hostname, so http.client still sends
+    the right ``Host`` header.
+    """
+
+    def __init__(self, host: str, port: int, *, pinned_ip: str, timeout: float) -> None:
+        super().__init__(host, port, timeout=timeout)
+        self.pinned_ip = pinned_ip
+
+    def connect(self) -> None:
+        self.sock = socket.create_connection((self.pinned_ip, self.port), self.timeout)
+
+
+class _PinnedHTTPSConnection(http.client.HTTPSConnection):
+    """HTTPS connection that dials a pre-resolved IP.
+
+    TLS still uses the original hostname for SNI and certificate
+    verification, so pinning cannot be abused to accept a certificate for
+    a different name.
+    """
+
+    def __init__(
+        self,
+        host: str,
+        port: int,
+        *,
+        pinned_ip: str,
+        timeout: float,
+        context: ssl.SSLContext,
+    ) -> None:
+        super().__init__(host, port, timeout=timeout, context=context)
+        self.pinned_ip = pinned_ip
+        self.tls_context = context
+
+    def connect(self) -> None:
+        raw = socket.create_connection((self.pinned_ip, self.port), self.timeout)
+        try:
+            self.sock = self.tls_context.wrap_socket(raw, server_hostname=self.host)
+        except BaseException:
+            raw.close()
+            raise
+
+
+def _tls_context() -> ssl.SSLContext:
+    """Default verifying context: CERT_REQUIRED + hostname checking."""
+    return ssl.create_default_context()
+
+
+def _user_agent() -> str:
+    from adloop import __version__
+
+    return f"AdLoop/{__version__} (image asset fetch)"
+
+
+@dataclass(frozen=True)
+class _Target:
+    scheme: str
+    host: str
+    port: int
+    path: str
+
+
+def _parse_target(url: str) -> _Target:
+    try:
+        parts = urlsplit(url)
+        port = parts.port
+    except ValueError as exc:
+        raise ImageFetchError(f"unparseable URL {url!r}: {exc}") from exc
+
+    scheme = parts.scheme.lower()
+    if scheme not in ("http", "https"):
+        raise ImageFetchError(
+            f"unsupported URL scheme {parts.scheme!r} in {url!r} (only http/https)"
+        )
+    if parts.username is not None or parts.password is not None:
+        raise ImageFetchError(f"URL {url!r} contains credentials — refusing to fetch")
+    host = parts.hostname
+    if not host:
+        raise ImageFetchError(f"URL {url!r} has no hostname")
+    try:
+        ipaddress.ip_address(host)
+    except ValueError:
+        try:
+            host = host.encode("idna").decode("ascii")
+        except UnicodeError as exc:
+            raise ImageFetchError(f"invalid hostname in {url!r}: {exc}") from exc
+
+    path = parts.path or "/"
+    if parts.query:
+        path = f"{path}?{parts.query}"
+    return _Target(
+        scheme=scheme,
+        host=host,
+        port=port or (443 if scheme == "https" else 80),
+        path=path,
+    )
+
+
+def _open_connection(target: _Target, pinned_ip: str) -> http.client.HTTPConnection:
+    if target.scheme == "https":
+        return _PinnedHTTPSConnection(
+            target.host,
+            target.port,
+            pinned_ip=pinned_ip,
+            timeout=TIMEOUT_SECONDS,
+            context=_tls_context(),
+        )
+    return _PinnedHTTPConnection(
+        target.host, target.port, pinned_ip=pinned_ip, timeout=TIMEOUT_SECONDS
+    )
+
+
+def _read_capped(response: http.client.HTTPResponse, url: str, deadline: float) -> bytes:
+    """Stream the body, aborting the moment it exceeds the size cap."""
+    declared = response.getheader("Content-Length")
+    if declared is not None and declared.strip().isdigit():
+        if int(declared) > MAX_IMAGE_BYTES:
+            raise ImageFetchError(
+                f"image at {url} is {int(declared) // 1024} KB; Google Ads "
+                f"accepts at most {MAX_IMAGE_BYTES // 1024} KB"
+            )
+
+    read = getattr(response, "read1", None) or response.read
+    chunks: list[bytes] = []
+    total = 0
+    while True:
+        if time.monotonic() > deadline:
+            raise ImageFetchError(
+                f"fetching {url} took longer than {TIMEOUT_SECONDS:.0f}s"
+            )
+        # read1 returns whatever has arrived instead of waiting for a full
+        # chunk, so a server trickling a byte at a time cannot outlast the
+        # deadline: the per-recv socket timeout alone would never fire.
+        chunk = read(_CHUNK_SIZE)
+        if not chunk:
+            break
+        total += len(chunk)
+        if total > MAX_IMAGE_BYTES:
+            raise ImageFetchError(
+                f"image at {url} exceeds {MAX_IMAGE_BYTES // 1024} KB, the "
+                "Google Ads image asset limit"
+            )
+        chunks.append(chunk)
+    return b"".join(chunks)
+
+
+def fetch_image_bytes(url: str) -> FetchedImage:
+    """Fetch ``url`` safely and return the raw bytes (not yet sniffed)."""
+    current = url
+    for _hop in range(MAX_REDIRECTS + 1):
+        target = _parse_target(current)
+        pinned_ip = resolve_public_address(target.host, target.port)
+        deadline = time.monotonic() + TIMEOUT_SECONDS
+        connection = _open_connection(target, pinned_ip)
+        try:
+            connection.request(
+                "GET",
+                target.path,
+                headers={
+                    "User-Agent": _user_agent(),
+                    "Accept": "image/png, image/jpeg, image/gif",
+                    "Accept-Encoding": "identity",
+                    "Connection": "close",
+                },
+            )
+            response = connection.getresponse()
+            if response.status in _REDIRECT_STATUSES:
+                location = response.getheader("Location")
+                if not location:
+                    raise ImageFetchError(
+                        f"{current} answered HTTP {response.status} without a Location"
+                    )
+                current = urljoin(current, location.strip())
+                continue
+            if response.status != 200:
+                raise ImageFetchError(f"{current} answered HTTP {response.status}")
+            data = _read_capped(response, current, deadline)
+        except ImageFetchError:
+            raise
+        except (OSError, http.client.HTTPException) as exc:
+            raise ImageFetchError(f"could not fetch {current}: {exc}") from exc
+        finally:
+            connection.close()
+        return FetchedImage(url=url, final_url=current, data=data)
+
+    raise ImageFetchError(f"{url} redirected more than {MAX_REDIRECTS} times")

{adloop-0.18.1 → adloop-0.19.0}/src/adloop/ads/write.py

@@ -8,7 +8,7 @@ from __future__ import annotations
 
 import hashlib
 import struct
-from pathlib import Path
+from pathlib import Path, PurePath, PurePosixPath
 from typing import TYPE_CHECKING
 
 if TYPE_CHECKING:
@@ -209,7 +209,9 @@ def _ssrf_error(url: str) -> str | None:
     Note: the fetch re-resolves DNS after this check, so a hostile DNS
     server could still rebind between check and fetch — acceptable here
     because the fetch result is only an up/down signal, never returned
-    to the caller.
+    to the caller. Fetches whose bytes ARE used (image assets) go through
+    ``adloop.ads.image_fetch``, which pins the connection to the checked
+    address.
     """
     import ipaddress
     import socket
@@ -238,15 +240,10 @@ def _ssrf_error(url: str) -> str | None:
             ipaddress.ip_address(info[4][0]) for info in addr_info
         ]
 
+    from adloop.ads.image_fetch import non_public_reason
+
     for addr in addresses:
-        if (
-            addr.is_private
-            or addr.is_loopback
-            or addr.is_link_local
-            or addr.is_multicast
-            or addr.is_reserved
-            or addr.is_unspecified
-        ):
+        if non_public_reason(addr) is not None:
             return (
                 f"URL resolves to a non-public address ({addr}) — "
                 "refusing to fetch"
@@ -383,10 +380,67 @@ def _parse_image_metadata(path_str: str) -> dict[str, object]:
         "mime_type": mime_type,
         "width": width,
         "height": height,
+        "size_kb": _size_kb(data),
     }
 
 
-def _build_image_asset_name(path: Path, data: bytes) -> str:
+def _parse_image_url_metadata(url: str) -> dict[str, object]:
+    """Fetch an image URL safely and return metadata used for asset creation.
+
+    The bytes themselves are NOT returned: plans are persisted, so only a
+    sha256 of the approved bytes is kept. Apply re-fetches the URL and
+    refuses if the digest no longer matches.
+    """
+    from adloop.ads.image_fetch import fetch_image_bytes
+
+    fetched = fetch_image_bytes(url)
+    mime_type, width, height = _detect_image_type_and_size(fetched.data)
+    return {
+        "url": url,
+        "sha256": fetched.sha256,
+        "name": _build_image_asset_name(_url_path(url), fetched.data),
+        "mime_type": mime_type,
+        "width": width,
+        "height": height,
+        "size_kb": _size_kb(fetched.data),
+    }
+
+
+def _fetch_approved_image_url(payload: dict) -> bytes:
+    """Re-fetch a URL image at apply time and check it is the previewed one."""
+    from adloop.ads.image_fetch import fetch_image_bytes
+
+    url = str(payload["url"])
+    fetched = fetch_image_bytes(url)
+    if fetched.sha256 != payload.get("sha256"):
+        raise ValueError(
+            f"The image at {url} changed since the preview; draft again."
+        )
+    return fetched.data
+
+
+def _url_path(url: str) -> PurePosixPath:
+    """The URL's path, so asset names use its file stem like local images do."""
+    from urllib.parse import unquote, urlsplit
+
+    return PurePosixPath(unquote(urlsplit(url).path))
+
+
+def _size_kb(data: bytes) -> float:
+    return round(len(data) / 1024, 1)
+
+
+def _describe_image(image: dict[str, object]) -> str:
+    """One preview line: source, type, dimensions and size."""
+    source = image.get("url") or image.get("path")
+    kind = str(image.get("mime_type", "")).removeprefix("image/").upper()
+    return (
+        f"{source} — {kind} {image.get('width')}x{image.get('height')}, "
+        f"{image.get('size_kb')} KB"
+    )
+
+
+def _build_image_asset_name(path: PurePath, data: bytes) -> str:
     """Build a deterministic asset name required by Google Ads image assets."""
     digest = hashlib.sha1(data).hexdigest()[:12]
     stem = path.stem.strip() or "image"
@@ -394,7 +448,7 @@ def _build_image_asset_name(path: Path, data: bytes) -> str:
 
 
 def _detect_image_type_and_size(data: bytes) -> tuple[str, int, int]:
-    """Return MIME type plus width/height for supported local image files."""
+    """Return MIME type plus width/height, sniffed from the bytes alone."""
     if data.startswith(b"\x89PNG\r\n\x1a\n") and len(data) >= 24:
         width, height = struct.unpack(">II", data[16:24])
         return "image/png", width, height
@@ -439,7 +493,7 @@ def _detect_image_type_and_size(data: bytes) -> tuple[str, int, int]:
             index += segment_length
 
     raise ValueError(
-        "Unsupported image type. Use a local PNG, JPEG, or GIF file."
+        "Unsupported image type. Use a PNG, JPEG, or GIF image."
     )
 
 
@@ -2402,18 +2456,27 @@ def draft_image_assets(
     customer_id: str = "",
     campaign_id: str = "",
     image_paths: list[str] | None = None,
+    image_urls: list[str] | None = None,
 ) -> dict:
-    """Draft campaign image assets from local files."""
+    """Draft campaign image assets from local files and/or public image URLs.
+
+    URL images are fetched now (public addresses only, pinned against DNS
+    rebinding, capped at Google's 5120 KB limit) and their sha256 is kept
+    in the plan; apply re-fetches and refuses if the bytes changed.
+    """
     from adloop.runtime import deployment_mode
     from adloop.safety.guards import SafetyViolation, check_blocked_operation
     from adloop.safety.preview import ChangePlan, store_plan
 
-    if deployment_mode() == "server":
+    image_paths = list(image_paths or [])
+    image_urls = list(image_urls or [])
+
+    if image_paths and deployment_mode() == "server":
         return {
             "error": (
-                "draft_image_assets reads image files from the local "
-                "filesystem and is not available on the hosted server. "
-                "Use the self-hosted AdLoop MCP server for image assets."
+                "image_paths can't be used here: local file paths aren't "
+                "available on a hosted server; pass image_urls (public "
+                "https/http links to PNG, JPEG or GIF images) instead."
             )
         }
 
@@ -2422,7 +2485,9 @@ def draft_image_assets(
     except SafetyViolation as e:
         return {"error": str(e)}
 
-    validated_images, errors = _validate_image_assets(campaign_id, image_paths or [])
+    validated_images, errors = _validate_image_assets(
+        campaign_id, image_paths, image_urls
+    )
     if errors:
         return {"error": "Validation failed", "details": errors}
 
@@ -2434,6 +2499,7 @@ def draft_image_assets(
         changes={
             "campaign_id": campaign_id,
             "images": validated_images,
+            "summary": [_describe_image(image) for image in validated_images],
         },
     )
     store_plan(plan)
@@ -3018,15 +3084,16 @@ def _validate_structured_snippets(
 
 
 def _validate_image_assets(
-    campaign_id: str, image_paths: list[str]
+    campaign_id: str, image_paths: list[str], image_urls: list[str] | None = None
 ) -> tuple[list[dict[str, object]], list[str]]:
     errors = []
     validated = []
+    image_urls = image_urls or []
 
     if not campaign_id:
         errors.append("campaign_id is required")
-    if not image_paths:
-        errors.append("At least one image path is required")
+    if not image_paths and not image_urls:
+        errors.append("At least one image (image_paths or image_urls) is required")
 
     for index, image_path in enumerate(image_paths):
         try:
@@ -3034,6 +3101,12 @@ def _validate_image_assets(
         except ValueError as exc:
             errors.append(f"Image {index + 1}: {exc}")
 
+    for index, image_url in enumerate(image_urls):
+        try:
+            validated.append(_parse_image_url_metadata(image_url))
+        except ValueError as exc:
+            errors.append(f"Image URL {index + 1} ({image_url}): {exc}")
+
     return validated, errors
 
 
@@ -4576,13 +4649,30 @@ def _apply_create_structured_snippets(
 
 
 def _apply_create_image_assets(client: object, cid: str, changes: dict) -> dict:
-    """Create image assets from local files and link them to a campaign."""
+    """Create image assets from local files or URLs and link them to a campaign.
+
+    URL images are re-fetched through the same safe fetcher and must match
+    the sha256 approved in the preview.
+    """
+
+    from adloop.runtime import deployment_mode
 
     def populate(asset: object, payload: dict) -> None:
-        image_path = Path(str(payload["path"]))
-        image_bytes = image_path.read_bytes()
+        if payload.get("url"):
+            image_bytes = _fetch_approved_image_url(payload)
+            name_source = _url_path(str(payload["url"]))
+        elif deployment_mode() == "server":
+            # Drafts refuse paths on a server; never read server files even
+            # if a path-based plan reached apply some other way.
+            raise ValueError(
+                "local file paths aren't available on a hosted server; "
+                "pass image_urls"
+            )
+        else:
+            name_source = Path(str(payload["path"]))
+            image_bytes = name_source.read_bytes()
         mime_type_name = _VALID_IMAGE_MIME_TYPES[str(payload["mime_type"])]
-        asset.name = str(payload.get("name") or _build_image_asset_name(image_path, image_bytes))
+        asset.name = str(payload.get("name") or _build_image_asset_name(name_source, image_bytes))
         asset.type_ = client.enums.AssetTypeEnum.IMAGE
         asset.image_asset.data = image_bytes
         asset.image_asset.mime_type = getattr(client.enums.MimeTypeEnum, mime_type_name)

{adloop-0.18.1 → adloop-0.19.0}/src/adloop/rules/adloop.md

@@ -203,7 +203,7 @@ Reddit is a second ad platform with its own connection (own OAuth app, no develo
 | `draft_responsive_search_ad` | Create RSA preview (does NOT publish) | 3-15 headlines (≤30 chars), 2-4 descriptions (≤90 chars), final_url required, path1/path2 (≤15 chars each). Each headline/description may be a plain string (unpinned) or `{"text": "...", "pinned_field": "HEADLINE_1"}` (pinned). Valid pin slots: `HEADLINE_1/2/3`, `DESCRIPTION_1/2`. Google permits ≤2 headlines per slot, ≤1 description per slot. |
 | `draft_callouts` | Create callout assets for a campaign (does NOT publish) | `campaign_id`, `callouts` list with 1-25 chars each |
 | `draft_structured_snippets` | Create structured snippet assets for a campaign (does NOT publish) | `campaign_id`, `snippets` list of `{header, values}` with official header values and 3-10 values |
-| `draft_image_assets` | Create image assets for a campaign from local files (does NOT publish) | `campaign_id`, `image_paths` list of local PNG/JPEG/GIF files |
+| `draft_image_assets` | Create image assets for a campaign from local files or public image URLs (does NOT publish) | `campaign_id`, `image_paths` (local PNG/JPEG/GIF files; not on a hosted server) and/or `image_urls` (public http(s) image links, ≤5120 KB; re-checked at apply — if the image changed since the preview, draft again) |
 | `draft_sitelinks` | Create sitelink extensions for a campaign (does NOT publish) | `campaign_id`, `sitelinks` list of {link_text ≤25 chars, final_url, description1 ≤35 chars, description2 ≤35 chars} |
 | `draft_keywords` | Propose keyword additions (does NOT add) | Each keyword needs `text` and `match_type` (EXACT/PHRASE/BROAD) |
 | `add_negative_keywords` | Propose negative keywords directly on a campaign (does NOT add) | `campaign_id`, keyword list, `match_type` |

{adloop-0.18.1 → adloop-0.19.0}/src/adloop/server.py

@@ -2458,10 +2458,25 @@ def draft_structured_snippets(
 @_safe
 def draft_image_assets(
     campaign_id: str,
-    image_paths: _StrList,
+    image_paths: _StrList = [],  # noqa: B006 — mutable default required for MCP JSON schema
+    image_urls: _StrList = [],  # noqa: B006
     customer_id: str = "",
 ) -> dict:
-    """Draft campaign image assets from local PNG, JPEG, or GIF files."""
+    """Draft campaign image assets from local files or public image URLs — returns a PREVIEW.
+
+    Pass at least one image in total across image_paths and image_urls.
+    Images must be PNG, JPEG or GIF and at most 5120 KB (Google's limit).
+    URL images are downloaded now and checked; applying re-downloads them
+    and refuses if the image changed since the preview.
+
+    Args:
+        campaign_id: Numeric ID of the campaign to attach the images to.
+        image_paths: Local PNG/JPEG/GIF file paths on the machine running
+            AdLoop. Not available on a hosted server — use image_urls there.
+        image_urls: Public http(s) URLs of PNG/JPEG/GIF images. Links to
+            private, local or internal addresses are refused.
+        customer_id: Ads account ID. Defaults to the configured account.
+    """
     from adloop.ads.write import draft_image_assets as _impl
 
     return _impl(
@@ -2469,6 +2484,7 @@ def draft_image_assets(
         customer_id=customer_id or current_config().ads.customer_id,
         campaign_id=campaign_id,
         image_paths=image_paths,
+        image_urls=image_urls,
     )