"""Editor prompt content -> ``prompt.submit`` text and staged image attachments (ACP gateway bridge).""" from __future__ import annotations import asyncio import logging import os from contextlib import suppress from hermes_cli.gateway_client import GatewayClientError logger = logging.getLogger(__name__) async def _fetch_remote_image(url): """Bytes of an editor's remote image URL, or None when it cannot be fetched. The in-process server passed such a URL to the model as an image part; admission carries only staged bytes, so the adapter downloads it through the gateway's SSRF-guarded image fetcher (pre-flight and per-redirect address checks, the inbound media size cap) and stages the bytes like any other image (#134889 ACP-16).""" from gateway.platforms.base import cache_image_from_url try: path = await cache_image_from_url(url, ".img", retries=0) except Exception: # Boundary: an unsafe address, an HTTP error, a non-image body or a transport failure # degrades to the URL as text, never a failed prompt. logger.info("ACP remote image not fetched; sent as text", exc_info=True) return None return await asyncio.to_thread(_take, path) def _take(path): """The fetched file's bytes; the cache copy is removed (staging writes its own sniffed-type file).""" try: with open(path, "rb") as fetched: return fetched.read() finally: with suppress(OSError): os.unlink(path) async def stage_user_content(content, home=None): """Shared-converter output -> ``(text, attachments)`` for ``prompt.submit``. Text-only prompts stay a plain string. Media parts (image ``data:`` URLs from image blocks, image resource links and embedded blobs, and remote image URLs once fetched) are staged as bytes in the profile image cache; the authority commits them at admission. A remote image URL that cannot be fetched is kept as text so the model still sees it. Only a remote image awaits (its download); every other part stages inline. ``home`` is the owner's profile home: a per-task overlay ``HERMES_HOME`` does not share ``cache/images``, and admission accepts only the owner's cache (never relaxed here).""" if isinstance(content, str): return content, [] if home is not None: from hermes_constants import reset_hermes_home_override, set_hermes_home_override token = set_hermes_home_override(home) try: return await stage_user_content(content) finally: reset_hermes_home_override(token) import base64 import binascii from gateway.platforms.base import cache_image_from_bytes from gateway.session_ingress_media import _ATTACHMENT_LIMIT, _IMAGE_EXT, sniff_image_mime texts, attachments = [], [] for part in content: if part.get('type') == 'text': texts.append(part['text']) continue url = part['image_url']['url'] if len(attachments) >= _ATTACHMENT_LIMIT: raise GatewayClientError('acp_content_invalid') if url.startswith('data:'): try: raw = base64.b64decode(url.partition(',')[2], validate=True) except (binascii.Error, ValueError) as exc: raise GatewayClientError('acp_content_invalid') from exc else: raw = await _fetch_remote_image(url) if url.startswith(('http://', 'https://')) else None if raw is None: texts.append(f"[Image attached: {url}]") continue # The sniffed bytes are authoritative for the staged extension and admitted type; the # client's declared type (a file suffix, or image/png by default) is never trusted. A # part admission cannot carry (bmp/svg, over the media cap) degrades to a text note so # the user's text still runs, as main's in-process server did for oversize images. mime = sniff_image_mime(raw) if mime is None: texts.append("[Image omitted: unsupported image format]") continue try: path = cache_image_from_bytes(raw, _IMAGE_EXT[mime]) except ValueError as exc: texts.append(f"[Image omitted: {exc}]") continue attachments.append({'path': path, 'mime': mime}) return "\n".join(texts), attachments def submit_fingerprint(session_id, content): """Identity of one logical prompt as the editor sent it (text, image ``data:`` bytes, remote image URLs), taken before staging: a retry of the same prompt matches without re-fetching a remote image, whose second download could fail or return other bytes and so change what is submitted.""" import hashlib digest = hashlib.sha256() for part in [content] if isinstance(content, str) else content: kind, value = ('text', part) if isinstance(part, str) else \ ('text', part['text']) if part.get('type') == 'text' else ('image', part['image_url']['url']) digest.update(kind.encode() + len(value).to_bytes(8, 'big') + value.encode()) return session_id, digest.hexdigest()