lfx-nightly 0.2.0.dev26__py3-none-any.whl → 0.2.1.dev7__py3-none-any.whl

lfx/schema/image.py

@@ -7,6 +7,7 @@ from platformdirs import user_cache_dir
 from pydantic import BaseModel
 
 from lfx.services.deps import get_storage_service
+from lfx.utils.image import create_image_content_dict
 
 IMAGE_ENDPOINT = "/files/images/"
 
@@ -37,7 +38,14 @@ def get_file_paths(files: list[str | dict]):
             if not file:  # Skip empty/None files
                 continue
 
-            file_path = file["path"] if isinstance(file, dict) and "path" in file else file
+            # Handle Image objects, dicts, and strings
+            if isinstance(file, dict) and "path" in file:
+                file_path = file["path"]
+            elif hasattr(file, "path") and file.path:
+                file_path = file.path
+            else:
+                file_path = file
+
             if not file_path:  # Skip empty paths
                 continue
 
@@ -74,12 +82,7 @@ def get_file_paths(files: list[str | dict]):
         if not file_path_str:  # Skip empty paths
             continue
 
-        file_path = Path(file_path_str)
-        # Handle edge case where path might be just a filename without parent
-        if file_path.parent == Path():
-            flow_id, file_name = "", file_path.name
-        else:
-            flow_id, file_name = str(file_path.parent), file_path.name
+        flow_id, file_name = storage_service.parse_file_path(file_path_str)
 
         if not file_name:  # Skip if no filename
             continue
@@ -129,12 +132,7 @@ async def get_files(
         if not file:  # Skip empty file paths
             continue
 
-        file_path = Path(file)
-        # Handle edge case where path might be just a filename without parent
-        if file_path.parent == Path():
-            flow_id, file_name = "", file_path.name
-        else:
-            flow_id, file_name = str(file_path.parent), file_path.name
+        flow_id, file_name = storage_service.parse_file_path(file)
 
         if not file_name:  # Skip if no filename
             continue
@@ -172,12 +170,23 @@ class Image(BaseModel):
         msg = "Image path is not set."
         raise ValueError(msg)
 
-    def to_content_dict(self):
-        """Convert image to content dictionary."""
-        return {
-            "type": "image_url",
-            "image_url": self.to_base64(),
-        }
+    def to_content_dict(self, flow_id: str | None = None):
+        """Convert image to content dictionary.
+
+        Args:
+            flow_id: Optional flow ID to prepend to the path if it doesn't contain one
+        """
+        if not self.path:
+            msg = "Image path is not set."
+            raise ValueError(msg)
+
+        # If the path doesn't contain a "/" and we have a flow_id, prepend it
+        image_path = self.path
+        if flow_id and "/" not in self.path:
+            image_path = f"{flow_id}/{self.path}"
+
+        # Use the utility function that properly handles the conversion
+        return create_image_content_dict(image_path, None, None)
 
     def get_url(self) -> str:
         """Get the URL for the image."""

lfx/schema/message.py

@@ -109,7 +109,22 @@ class Message(Data):
     def model_post_init(self, /, _context: Any) -> None:
         new_files: list[Any] = []
         for file in self.files or []:
-            if is_image_file(file):
+            # Skip if already an Image instance
+            if isinstance(file, Image):
+                new_files.append(file)
+            # Get the path string if file is a dict or has path attribute
+            elif isinstance(file, dict) and "path" in file:
+                file_path = file["path"]
+                if file_path and is_image_file(file_path):
+                    new_files.append(Image(path=file_path))
+                else:
+                    new_files.append(file_path if file_path else file)
+            elif hasattr(file, "path") and file.path:
+                if is_image_file(file.path):
+                    new_files.append(Image(path=file.path))
+                else:
+                    new_files.append(file.path)
+            elif isinstance(file, str) and is_image_file(file):
                 new_files.append(Image(path=file))
             else:
                 new_files.append(file)
@@ -213,7 +228,8 @@ class Message(Data):
 
         for file in files:
             if isinstance(file, Image):
-                content_dicts.append(file.to_content_dict())
+                # Pass the message's flow_id to the Image for proper path resolution
+                content_dicts.append(file.to_content_dict(flow_id=self.flow_id))
             else:
                 content_dicts.append(create_image_content_dict(file, None, model_name))
         return content_dicts
@@ -286,7 +302,7 @@ class Message(Data):
     @classmethod
     async def create(cls, **kwargs):
         """If files are present, create the message in a separate thread as is_image_file is blocking."""
-        if "files" in kwargs:
+        if kwargs.get("files"):
             return await asyncio.to_thread(cls, **kwargs)
         return cls(**kwargs)
 

lfx/services/interfaces.py

@@ -41,6 +41,11 @@ class StorageServiceProtocol(Protocol):
         """Build the full path of a file in the storage."""
         ...
 
+    @abstractmethod
+    def parse_file_path(self, full_path: str) -> tuple[str, str]:
+        """Parse a full storage path to extract flow_id and file_name."""
+        ...
+
 
 class SettingsServiceProtocol(Protocol):
     """Protocol for settings service."""

lfx/services/manager.py

@@ -155,10 +155,11 @@ class ServiceManager:
                         factories.append(obj())
                         break
 
-            except Exception as exc:  # noqa: BLE001
-                logger.debug(
-                    f"Could not initialize services. Please check your settings. Error in {name}.", exc_info=exc
-                )
+            except Exception:  # noqa: BLE001, S110
+                # This is expected during initial service discovery - some services
+                # may not have factories yet or depend on settings service being ready first
+                # Intentionally suppressed to avoid startup noise - not an error condition
+                pass
 
         return factories
 

lfx/services/mcp_composer/service.py

@@ -73,7 +73,9 @@ class MCPComposerService(Service):
 
     def __init__(self):
         super().__init__()
-        self.project_composers: dict[str, dict] = {}  # project_id -> {process, host, port, sse_url, auth_config}
+        self.project_composers: dict[
+            str, dict
+        ] = {}  # project_id -> {process, host, port, streamable_http_url, auth_config}
         self._start_locks: dict[
             str, asyncio.Lock
         ] = {}  # Lock to prevent concurrent start operations for the same project
@@ -949,21 +951,24 @@ class MCPComposerService(Service):
     async def start_project_composer(
         self,
         project_id: str,
-        sse_url: str,
+        streamable_http_url: str,
         auth_config: dict[str, Any] | None,
         max_retries: int = 3,
         max_startup_checks: int = 40,
         startup_delay: float = 2.0,
+        *,
+        legacy_sse_url: str | None = None,
     ) -> None:
         """Start an MCP Composer instance for a specific project.
 
         Args:
             project_id: The project ID
-            sse_url: The SSE URL to connect to
+            streamable_http_url: Streamable HTTP endpoint for the remote Langflow MCP server
             auth_config: Authentication configuration
             max_retries: Maximum number of retry attempts (default: 3)
             max_startup_checks: Number of checks per retry attempt (default: 40)
             startup_delay: Delay between checks in seconds (default: 2.0)
+            legacy_sse_url: Optional legacy SSE URL used for backward compatibility
 
         Raises:
             MCPComposerError: Various specific errors if startup fails
@@ -994,7 +999,13 @@ class MCPComposerService(Service):
 
         try:
             await self._do_start_project_composer(
-                project_id, sse_url, auth_config, max_retries, max_startup_checks, startup_delay
+                project_id,
+                streamable_http_url,
+                auth_config,
+                max_retries,
+                max_startup_checks,
+                startup_delay,
+                legacy_sse_url=legacy_sse_url,
             )
         finally:
             # Clean up the task reference when done
@@ -1004,25 +1015,29 @@ class MCPComposerService(Service):
     async def _do_start_project_composer(
         self,
         project_id: str,
-        sse_url: str,
+        streamable_http_url: str,
         auth_config: dict[str, Any] | None,
         max_retries: int = 3,
         max_startup_checks: int = 40,
         startup_delay: float = 2.0,
+        *,
+        legacy_sse_url: str | None = None,
     ) -> None:
         """Internal method to start an MCP Composer instance.
 
         Args:
             project_id: The project ID
-            sse_url: The SSE URL to connect to
+            streamable_http_url: Streamable HTTP endpoint for the remote Langflow MCP server
             auth_config: Authentication configuration
             max_retries: Maximum number of retry attempts (default: 3)
             max_startup_checks: Number of checks per retry attempt (default: 40)
             startup_delay: Delay between checks in seconds (default: 2.0)
+            legacy_sse_url: Optional legacy SSE URL used for backward compatibility
 
         Raises:
             MCPComposerError: Various specific errors if startup fails
         """
+        legacy_sse_url = legacy_sse_url or f"{streamable_http_url.rstrip('/')}/sse"
         if not auth_config:
             no_auth_error_msg = "No auth settings provided"
             raise MCPComposerConfigError(no_auth_error_msg, project_id)
@@ -1126,10 +1141,11 @@ class MCPComposerService(Service):
                             project_id,
                             project_host,
                             project_port,
-                            sse_url,
+                            streamable_http_url,
                             auth_config,
                             max_startup_checks,
                             startup_delay,
+                            legacy_sse_url=legacy_sse_url,
                         )
 
                     except MCPComposerError as e:
@@ -1174,7 +1190,9 @@ class MCPComposerService(Service):
                             "process": process,
                             "host": project_host,
                             "port": project_port,
-                            "sse_url": sse_url,
+                            "streamable_http_url": streamable_http_url,
+                            "legacy_sse_url": legacy_sse_url,
+                            "sse_url": legacy_sse_url,
                             "auth_config": auth_config,
                         }
                         self._port_to_project[project_port] = project_id
@@ -1209,10 +1227,12 @@ class MCPComposerService(Service):
         project_id: str,
         host: str,
         port: int,
-        sse_url: str,
+        streamable_http_url: str,
         auth_config: dict[str, Any] | None = None,
         max_startup_checks: int = 40,
         startup_delay: float = 2.0,
+        *,
+        legacy_sse_url: str | None = None,
     ) -> subprocess.Popen:
         """Start the MCP Composer subprocess for a specific project.
 
@@ -1220,10 +1240,11 @@ class MCPComposerService(Service):
             project_id: The project ID
             host: Host to bind to
             port: Port to bind to
-            sse_url: SSE URL to connect to
+            streamable_http_url: Streamable HTTP endpoint to connect to
             auth_config: Authentication configuration
             max_startup_checks: Number of port binding checks (default: 40)
             startup_delay: Delay between checks in seconds (default: 2.0)
+            legacy_sse_url: Optional legacy SSE URL used for backward compatibility when required by tooling
 
         Returns:
             The started subprocess
@@ -1232,6 +1253,9 @@ class MCPComposerService(Service):
             MCPComposerStartupError: If startup fails
         """
         settings = get_settings_service().settings
+        # Some composer tooling still uses the --sse-url flag for backwards compatibility even in HTTP mode.
+        effective_legacy_sse_url = legacy_sse_url or f"{streamable_http_url.rstrip('/')}/sse"
+
         cmd = [
             "uvx",
             f"mcp-composer{settings.mcp_composer_version}",
@@ -1240,9 +1264,11 @@ class MCPComposerService(Service):
             "--host",
             host,
             "--mode",
-            "sse",
+            "http",
+            "--endpoint",
+            streamable_http_url,
             "--sse-url",
-            sse_url,
+            effective_legacy_sse_url,
             "--disable-composer-tools",
         ]
 
@@ -1266,7 +1292,7 @@ class MCPComposerService(Service):
                     "oauth_host": "OAUTH_HOST",
                     "oauth_port": "OAUTH_PORT",
                     "oauth_server_url": "OAUTH_SERVER_URL",
-                    "oauth_callback_path": "OAUTH_CALLBACK_PATH",
+                    "oauth_callback_url": "OAUTH_CALLBACK_URL",
                     "oauth_client_id": "OAUTH_CLIENT_ID",
                     "oauth_client_secret": "OAUTH_CLIENT_SECRET",  # pragma: allowlist secret
                     "oauth_auth_url": "OAUTH_AUTH_URL",
@@ -1275,6 +1301,12 @@ class MCPComposerService(Service):
                     "oauth_provider_scope": "OAUTH_PROVIDER_SCOPE",
                 }
 
+                # Backwards compatibility: if oauth_callback_url not set, try oauth_callback_path
+                if ("oauth_callback_url" not in auth_config or not auth_config.get("oauth_callback_url")) and (
+                    "oauth_callback_path" in auth_config and auth_config.get("oauth_callback_path")
+                ):
+                    auth_config["oauth_callback_url"] = auth_config["oauth_callback_path"]
+
                 # Add environment variables as command line arguments
                 # Only set non-empty values to avoid Pydantic validation errors
                 for config_key, env_key in oauth_env_mapping.items():

lfx/services/settings/auth.py

@@ -27,6 +27,16 @@ class AuthSettings(BaseSettings):
     API_KEY_ALGORITHM: str = "HS256"
     API_V1_STR: str = "/api/v1"
 
+    # API Key Source Configuration
+    API_KEY_SOURCE: Literal["db", "env"] = Field(
+        default="db",
+        description=(
+            "Source for API key validation. "
+            "'db' validates against database-stored API keys (default behavior). "
+            "'env' validates against the LANGFLOW_API_KEY environment variable."
+        ),
+    )
+
     AUTO_LOGIN: bool = Field(
         default=True,  # TODO: Set to False in v2.0
         description=(
@@ -115,19 +125,16 @@ class AuthSettings(BaseSettings):
             logger.debug("Secret key provided")
             secret_value = value.get_secret_value() if isinstance(value, SecretStr) else value
             write_secret_to_file(secret_key_path, secret_value)
-        else:
-            logger.debug("No secret key provided, generating a random one")
-
-            if secret_key_path.exists():
-                value = read_secret_from_file(secret_key_path)
-                logger.debug("Loaded secret key")
-                if not value:
-                    value = secrets.token_urlsafe(32)
-                    write_secret_to_file(secret_key_path, value)
-                    logger.debug("Saved secret key")
-            else:
+        elif secret_key_path.exists():
+            value = read_secret_from_file(secret_key_path)
+            logger.debug("Loaded secret key")
+            if not value:
                 value = secrets.token_urlsafe(32)
                 write_secret_to_file(secret_key_path, value)
                 logger.debug("Saved secret key")
+        else:
+            value = secrets.token_urlsafe(32)
+            write_secret_to_file(secret_key_path, value)
+            logger.debug("Saved secret key")
 
         return value if isinstance(value, SecretStr) else SecretStr(value).get_secret_value()

lfx/services/settings/base.py

@@ -477,12 +477,10 @@ class Settings(BaseSettings):
             msg = f"Invalid database_url provided: '{value}'"
             raise ValueError(msg)
 
-        logger.debug("No database_url provided, trying LANGFLOW_DATABASE_URL env variable")
         if langflow_database_url := os.getenv("LANGFLOW_DATABASE_URL"):
             value = langflow_database_url
-            logger.debug("Using LANGFLOW_DATABASE_URL env variable.")
+            logger.debug("Using LANGFLOW_DATABASE_URL env variable")
         else:
-            logger.debug("No database_url env variable, using sqlite database")
             # Originally, we used sqlite:///./langflow.db
             # so we need to migrate to the new format
             # if there is a database in that location
@@ -498,10 +496,14 @@ class Settings(BaseSettings):
 
             if info.data["save_db_in_config_dir"]:
                 database_dir = info.data["config_dir"]
-                logger.debug(f"Saving database to config_dir: {database_dir}")
             else:
-                database_dir = Path(__file__).parent.parent.parent.resolve()
-                logger.debug(f"Saving database to langflow directory: {database_dir}")
+                # Use langflow package path, not lfx, for backwards compatibility
+                try:
+                    import langflow
+
+                    database_dir = Path(langflow.__file__).parent.resolve()
+                except ImportError:
+                    database_dir = Path(__file__).parent.parent.parent.resolve()
 
             pre_db_file_name = "langflow-pre.db"
             db_file_name = "langflow.db"
@@ -524,7 +526,6 @@ class Settings(BaseSettings):
                     logger.debug(f"Creating new database at {new_pre_path}")
                     final_path = new_pre_path
             elif Path(new_path).exists():
-                logger.debug(f"Database already exists at {new_path}, using it")
                 final_path = new_path
             elif Path(f"./{db_file_name}").exists():
                 try:
@@ -568,15 +569,10 @@ class Settings(BaseSettings):
 
         if not value:
             value = [BASE_COMPONENTS_PATH]
-            logger.debug("Setting default components path to components_path")
-        else:
-            if isinstance(value, Path):
-                value = [str(value)]
-            elif isinstance(value, list):
-                value = [str(p) if isinstance(p, Path) else p for p in value]
-            logger.debug("Adding default components path to components_path")
-
-        logger.debug(f"Components path: {value}")
+        elif isinstance(value, Path):
+            value = [str(value)]
+        elif isinstance(value, list):
+            value = [str(p) if isinstance(p, Path) else p for p in value]
         return value
 
     model_config = SettingsConfigDict(validate_assignment=True, extra="ignore", env_prefix="LANGFLOW_")
@@ -587,13 +583,10 @@ class Settings(BaseSettings):
         self.dev = dev
 
     def update_settings(self, **kwargs) -> None:
-        logger.debug("Updating settings")
         for key, value in kwargs.items():
             # value may contain sensitive information, so we don't want to log it
             if not hasattr(self, key):
-                logger.debug(f"Key {key} not found in settings")
                 continue
-            logger.debug(f"Updating {key}")
             if isinstance(getattr(self, key), list):
                 # value might be a '[something]' string
                 value_ = value
@@ -604,17 +597,12 @@ class Settings(BaseSettings):
                         item_ = str(item) if isinstance(item, Path) else item
                         if item_ not in getattr(self, key):
                             getattr(self, key).append(item_)
-                    logger.debug(f"Extended {key}")
                 else:
                     value_ = str(value_) if isinstance(value_, Path) else value_
                     if value_ not in getattr(self, key):
                         getattr(self, key).append(value_)
-                        logger.debug(f"Appended {key}")
-
             else:
                 setattr(self, key, value)
-                logger.debug(f"Updated {key}")
-            logger.debug(f"{key}: {getattr(self, key)}")
 
     @property
     def voice_mode_available(self) -> bool:

lfx/services/settings/constants.py

@@ -41,3 +41,5 @@ AGENTIC_VARIABLES = [
     "FIELD_NAME",
     "ASTRA_TOKEN",
 ]
+
+DEFAULT_AGENTIC_VARIABLE_VALUE = ""

lfx/services/storage/local.py

@@ -57,6 +57,43 @@ class LocalStorageService(StorageService):
         """Build the full path of a file in the local storage."""
         return str(self.data_dir / flow_id / file_name)
 
+    def parse_file_path(self, full_path: str) -> tuple[str, str]:
+        r"""Parse a full local storage path to extract flow_id and file_name.
+
+        Args:
+            full_path: Filesystem path, may or may not include data_dir
+                e.g., "/data/user_123/image.png" or "user_123/image.png". On Windows the
+                separators may be backslashes ("\\"). This method handles both.
+
+        Returns:
+            tuple[str, str]: A tuple of (flow_id, file_name)
+
+        Examples:
+            >>> parse_file_path("/data/user_123/image.png")  # with data_dir
+            ("user_123", "image.png")
+            >>> parse_file_path("user_123/image.png")  # without data_dir
+            ("user_123", "image.png")
+        """
+        data_dir_str = str(self.data_dir)
+
+        # Remove data_dir if present (but don't require it)
+        path_without_prefix = full_path
+        if full_path.startswith(data_dir_str):
+            # Strip both POSIX and Windows separators
+            path_without_prefix = full_path[len(data_dir_str) :].lstrip("/").lstrip("\\")
+
+        # Normalize separators so downstream logic is platform-agnostic
+        normalized_path = path_without_prefix.replace("\\", "/")
+
+        # Split from the right to get the filename; everything before the last
+        # "/" is the flow_id
+        if "/" not in normalized_path:
+            return "", normalized_path
+
+        # Use rsplit to split from the right, limiting to 1 split
+        flow_id, file_name = normalized_path.rsplit("/", 1)
+        return flow_id, file_name
+
     async def save_file(self, flow_id: str, file_name: str, data: bytes, *, append: bool = False) -> None:
         """Save a file in the local storage.
 

lfx/services/storage/service.py

@@ -37,6 +37,7 @@ class StorageService(Service):
         self.data_dir: anyio.Path = anyio.Path(settings_service.settings.config_dir)
         self.set_ready()
 
+    @abstractmethod
     def build_full_path(self, flow_id: str, file_name: str) -> str:
         """Build the full path/key for a file.
 
@@ -49,6 +50,24 @@ class StorageService(Service):
         """
         raise NotImplementedError
 
+    @abstractmethod
+    def parse_file_path(self, full_path: str) -> tuple[str, str]:
+        """Parse a full storage path to extract flow_id and file_name.
+
+        This reverses the build_full_path operation.
+
+        Args:
+            full_path: Full path as returned by build_full_path
+
+        Returns:
+            tuple[str, str]: A tuple of (flow_id, file_name)
+
+        Raises:
+            ValueError: If the path format is invalid or doesn't match expected structure
+        """
+        raise NotImplementedError
+
+    @abstractmethod
     def resolve_component_path(self, logical_path: str) -> str:
         """Convert a logical path to a format that components can use directly.
 

lfx/utils/constants.py

@@ -82,6 +82,7 @@ DIRECT_TYPES = [
     "query",
     "tools",
     "mcp",
+    "model",
 ]
 
 

lfx/utils/image.py

@@ -6,14 +6,19 @@ import base64
 from functools import lru_cache
 from pathlib import Path
 
+from lfx.log import logger
+from lfx.services.deps import get_storage_service
+from lfx.utils.async_helpers import run_until_complete
 from lfx.utils.helpers import get_mime_type
 
 
 def convert_image_to_base64(image_path: str | Path) -> str:
     """Convert an image file to a base64 encoded string.
 
+    Handles both local files and S3 storage paths.
+
     Args:
-        image_path: Path to the image file
+        image_path: Path to the image file (local or S3 path like "flow_id/filename")
 
     Returns:
         Base64 encoded string of the image
@@ -22,6 +27,20 @@ def convert_image_to_base64(image_path: str | Path) -> str:
         FileNotFoundError: If the image file doesn't exist
     """
     image_path = Path(image_path)
+
+    storage_service = get_storage_service()
+    if storage_service:
+        flow_id, file_name = storage_service.parse_file_path(str(image_path))
+        try:
+            file_content = run_until_complete(
+                storage_service.get_file(flow_id=flow_id, file_name=file_name)  # type: ignore[call-arg]
+            )
+            return base64.b64encode(file_content).decode("utf-8")
+        except Exception as e:
+            logger.error(f"Error reading image file: {e}")
+            raise
+
+    # Fall back to local file access
     if not image_path.exists():
         msg = f"Image file not found: {image_path}"
         raise FileNotFoundError(msg)
@@ -34,7 +53,7 @@ def create_data_url(image_path: str | Path, mime_type: str | None = None) -> str
     """Create a data URL from an image file.
 
     Args:
-        image_path: Path to the image file
+        image_path: Path to the image file (local or S3 path like "flow_id/filename")
         mime_type: MIME type of the image. If None, will be auto-detected
 
     Returns:
@@ -44,9 +63,6 @@ def create_data_url(image_path: str | Path, mime_type: str | None = None) -> str
         FileNotFoundError: If the image file doesn't exist
     """
     image_path = Path(image_path)
-    if not image_path.exists():
-        msg = f"Image file not found: {image_path}"
-        raise FileNotFoundError(msg)
 
     if mime_type is None:
         mime_type = get_mime_type(image_path)
@@ -57,14 +73,16 @@ def create_data_url(image_path: str | Path, mime_type: str | None = None) -> str
 
 @lru_cache(maxsize=50)
 def create_image_content_dict(
-    image_path: str | Path, mime_type: str | None = None, model_name: str | None = None
+    image_path: str | Path,
+    mime_type: str | None = None,
+    model_name: str | None = None,  # noqa: ARG001
 ) -> dict:
     """Create a content dictionary for multimodal inputs from an image file.
 
     Args:
-        image_path: Path to the image file
+        image_path: Path to the image file (local or S3 path like "flow_id/filename")
         mime_type: MIME type of the image. If None, will be auto-detected
-        model_name: Optional model parameter to determine content dict structure
+        model_name: Optional model parameter (kept for backward compatibility, no longer used)
 
     Returns:
         Content dictionary with type and image_url fields
@@ -74,6 +92,6 @@ def create_image_content_dict(
     """
     data_url = create_data_url(image_path, mime_type)
 
-    if model_name == "OllamaModel":
-        return {"type": "image_url", "source_type": "url", "image_url": data_url}
-    return {"type": "image", "source_type": "url", "url": data_url}
+    # Standard format for OpenAI, Anthropic, Gemini, and most providers
+    # Format: {"type": "image_url", "image_url": {"url": "data:..."}}
+    return {"type": "image_url", "image_url": {"url": data_url}}