lfx-nightly 0.2.0.dev0__py3-none-any.whl → 0.2.0.dev26__py3-none-any.whl

lfx/services/session.py

@@ -75,6 +75,11 @@ class NoopSession:
         """Context manager that disables autoflush (no-op implementation)."""
         return self
 
+    @property
+    def is_active(self):
+        """Check if session is active (always True for NoopSession)."""
+        return True
+
     def __enter__(self):
         return self
 

lfx/services/settings/base.py

@@ -17,7 +17,7 @@ from typing_extensions import override
 from lfx.constants import BASE_COMPONENTS_PATH
 from lfx.log.logger import logger
 from lfx.serialization.constants import MAX_ITEMS_LENGTH, MAX_TEXT_LENGTH
-from lfx.services.settings.constants import VARIABLES_TO_GET_FROM_ENVIRONMENT
+from lfx.services.settings.constants import AGENTIC_VARIABLES, VARIABLES_TO_GET_FROM_ENVIRONMENT
 from lfx.utils.util_strings import is_valid_database_url
 
 
@@ -87,6 +87,10 @@ class Settings(BaseSettings):
     db_connect_timeout: int = 30
     """The number of seconds to wait before giving up on a lock to released or establishing a connection to the
     database."""
+    migration_lock_namespace: str | None = None
+    """Optional namespace identifier for PostgreSQL advisory lock during migrations.
+    If not provided, a hash of the database URL will be used. Useful when multiple Langflow
+    instances share the same database and need coordinated migration locking."""
 
     mcp_server_timeout: int = 20
     """The number of seconds to wait before giving up on a lock to released or establishing a connection to the
@@ -109,7 +113,7 @@ class Settings(BaseSettings):
     reap idle sessions."""
 
     # sqlite configuration
-    sqlite_pragmas: dict | None = {"synchronous": "NORMAL", "journal_mode": "WAL"}
+    sqlite_pragmas: dict | None = {"synchronous": "NORMAL", "journal_mode": "WAL", "busy_timeout": 30000}
     """SQLite pragmas to use when connecting to the database."""
 
     db_driver_connection_settings: dict | None = None
@@ -187,6 +191,13 @@ class Settings(BaseSettings):
     like_webhook_url: str | None = "https://api.langflow.store/flows/trigger/64275852-ec00-45c1-984e-3bff814732da"
 
     storage_type: str = "local"
+    """Storage type for file storage. Defaults to 'local'. Supports 'local' and 's3'."""
+    object_storage_bucket_name: str | None = "langflow-bucket"
+    """Object storage bucket name for file storage. Defaults to 'langflow-bucket'."""
+    object_storage_prefix: str | None = "files"
+    """Object storage prefix for file storage. Defaults to 'files'."""
+    object_storage_tags: dict[str, str] | None = None
+    """Object storage tags for file storage."""
 
     celery_enabled: bool = False
 
@@ -245,6 +256,8 @@ class Settings(BaseSettings):
     """The path to log file for Langflow."""
     alembic_log_file: str = "alembic/alembic.log"
     """The path to log file for Alembic for SQLAlchemy."""
+    alembic_log_to_stdout: bool = False
+    """If set to True, the log file will be ignored and Alembic will log to stdout."""
     frontend_path: str | None = None
     """The path to the frontend directory containing build files. This is for development purposes only.."""
     open_browser: bool = False
@@ -292,9 +305,13 @@ class Settings(BaseSettings):
     # MCP Composer
     mcp_composer_enabled: bool = True
     """If set to False, Langflow will not start the MCP Composer service."""
-    mcp_composer_version: str = "~=0.1.0.7"
-    """Version constraint for mcp-composer when using uvx. Uses PEP 440 syntax.
-    ~=0.1.0.7 allows patch updates (0.1.0.x) but prevents minor/major version changes."""
+    mcp_composer_version: str = "==0.1.0.8.10"
+    """Version constraint for mcp-composer when using uvx. Uses PEP 440 syntax."""
+
+    # Agentic Experience
+    agentic_experience: bool = False
+    """If set to True, Langflow will start the agentic MCP server that provides tools for
+    flow/component operations, template search, and graph visualization."""
 
     # Public Flow Settings
     public_flow_cleanup_interval: int = Field(default=3600, gt=600)
@@ -317,6 +334,23 @@ class Settings(BaseSettings):
     update_starter_projects: bool = True
     """If set to True, Langflow will update starter projects."""
 
+    # SSRF Protection
+    ssrf_protection_enabled: bool = False
+    """If set to True, Langflow will enable SSRF (Server-Side Request Forgery) protection.
+    When enabled, blocks requests to private IP ranges, localhost, and cloud metadata endpoints.
+    When False (default), no URL validation is performed, allowing requests to any destination
+    including internal services, private networks, and cloud metadata endpoints.
+    Default is False for backward compatibility. In v2.0, this will be changed to True.
+
+    Note: When ssrf_protection_enabled is disabled, the ssrf_allowed_hosts setting is ignored and has no effect."""
+    ssrf_allowed_hosts: list[str] = []
+    """Comma-separated list of hosts/IPs/CIDR ranges to allow despite SSRF protection.
+    Examples: 'internal-api.company.local,192.168.1.0/24,10.0.0.5,*.dev.internal'
+    Supports exact hostnames, wildcard domains (*.example.com), exact IPs, and CIDR ranges.
+
+    Note: This setting only takes effect when ssrf_protection_enabled is True.
+    When protection is disabled, all hosts are allowed regardless of this setting."""
+
     @field_validator("cors_origins", mode="before")
     @classmethod
     def validate_cors_origins(cls, value):
@@ -367,7 +401,7 @@ class Settings(BaseSettings):
         Supports PEP 440 specifiers: ==, !=, <=, >=, <, >, ~=, ===
         """
         if not value:
-            return "~=0.1.0.7"  # Default
+            return "==0.1.0.8.10"  # Default
 
         # Check if it already has a version specifier
         # Order matters: check longer specifiers first to avoid false matches
@@ -389,9 +423,19 @@ class Settings(BaseSettings):
     @field_validator("variables_to_get_from_environment", mode="before")
     @classmethod
     def set_variables_to_get_from_environment(cls, value):
+        import os
+
         if isinstance(value, str):
             value = value.split(",")
-        return list(set(VARIABLES_TO_GET_FROM_ENVIRONMENT + value))
+
+        result = list(set(VARIABLES_TO_GET_FROM_ENVIRONMENT + value))
+
+        # Add agentic variables if agentic_experience is enabled
+        # Check env var directly since we can't access instance attributes in validator
+        if os.getenv("LANGFLOW_AGENTIC_EXPERIENCE", "true").lower() == "true":
+            result.extend(AGENTIC_VARIABLES)
+
+        return list(set(result))
 
     @field_validator("log_file", mode="before")
     @classmethod

lfx/services/settings/constants.py

@@ -33,3 +33,11 @@ VARIABLES_TO_GET_FROM_ENVIRONMENT = [
     "TAVILY_API_KEY",
     "COMETAPI_KEY",
 ]
+
+# Agentic experience specific variables
+AGENTIC_VARIABLES = [
+    "FLOW_ID",
+    "COMPONENT_ID",
+    "FIELD_NAME",
+    "ASTRA_TOKEN",
+]

lfx/services/storage/local.py

@@ -1,30 +1,70 @@
 """Local file-based storage service for lfx package."""
 
-from pathlib import Path
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from aiofile import async_open
 
 from lfx.log.logger import logger
 from lfx.services.storage.service import StorageService
 
+if TYPE_CHECKING:
+    from langflow.services.session.service import SessionService
+
+    from lfx.services.settings.service import SettingsService
+
+# Constants for path parsing
+EXPECTED_PATH_PARTS = 2  # Path format: "flow_id/filename"
+
 
 class LocalStorageService(StorageService):
     """A service class for handling local file storage operations."""
 
-    def __init__(self, data_dir: str | Path | None = None) -> None:
-        """Initialize the local storage service."""
-        super().__init__(data_dir)
-        self.set_ready()
+    def __init__(
+        self,
+        session_service: SessionService,
+        settings_service: SettingsService,
+    ) -> None:
+        """Initialize the local storage service.
+
+        Args:
+            session_service: Session service instance
+            settings_service: Settings service instance containing configuration
+        """
+        # Initialize base class with services
+        super().__init__(session_service, settings_service)
+        # Base class already sets self.data_dir as anyio.Path from settings_service.settings.config_dir
+
+    def resolve_component_path(self, logical_path: str) -> str:
+        """Convert logical path to absolute filesystem path for local storage.
+
+        Args:
+            logical_path: Path in format "flow_id/filename"
+        Returns:
+            str: Absolute filesystem path
+        """
+        # Split the logical path into flow_id and filename
+        parts = logical_path.split("/", 1)
+        if len(parts) != EXPECTED_PATH_PARTS:
+            # Handle edge case - return as-is if format is unexpected
+            return logical_path
+
+        flow_id, file_name = parts
+        return self.build_full_path(flow_id, file_name)
 
     def build_full_path(self, flow_id: str, file_name: str) -> str:
         """Build the full path of a file in the local storage."""
         return str(self.data_dir / flow_id / file_name)
 
-    async def save_file(self, flow_id: str, file_name: str, data: bytes) -> None:
+    async def save_file(self, flow_id: str, file_name: str, data: bytes, *, append: bool = False) -> None:
         """Save a file in the local storage.
 
         Args:
             flow_id: The identifier for the flow.
             file_name: The name of the file to be saved.
             data: The byte content of the file.
+            append: If True, append to existing file; if False, overwrite.
 
         Raises:
             FileNotFoundError: If the specified flow does not exist.
@@ -32,17 +72,18 @@ class LocalStorageService(StorageService):
             PermissionError: If there is no permission to write the file.
         """
         folder_path = self.data_dir / flow_id
-        folder_path.mkdir(parents=True, exist_ok=True)
+        await folder_path.mkdir(parents=True, exist_ok=True)
         file_path = folder_path / file_name
 
         try:
-            with file_path.open("wb") as f:
-                f.write(data)
+            mode = "ab" if append else "wb"
+            async with async_open(str(file_path), mode) as f:
+                await f.write(data)
+            action = "appended to" if append else "saved"
+            await logger.ainfo(f"File {file_name} {action} successfully in flow {flow_id}.")
         except Exception:
             logger.exception(f"Error saving file {file_name} in flow {flow_id}")
             raise
-        else:
-            logger.info(f"File {file_name} saved successfully in flow {flow_id}.")
 
     async def get_file(self, flow_id: str, file_name: str) -> bytes:
         """Retrieve a file from the local storage.
@@ -58,20 +99,16 @@ class LocalStorageService(StorageService):
             FileNotFoundError: If the file does not exist.
         """
         file_path = self.data_dir / flow_id / file_name
-        if not file_path.exists():
-            logger.warning(f"File {file_name} not found in flow {flow_id}.")
+        if not await file_path.exists():
+            await logger.awarning(f"File {file_name} not found in flow {flow_id}.")
             msg = f"File {file_name} not found in flow {flow_id}"
             raise FileNotFoundError(msg)
 
-        try:
-            with file_path.open("rb") as f:
-                content = f.read()
-        except Exception:
-            logger.exception(f"Error reading file {file_name} in flow {flow_id}")
-            raise
-        else:
-            logger.debug(f"File {file_name} retrieved successfully from flow {flow_id}.")
-            return content
+        async with async_open(str(file_path), "rb") as f:
+            content = await f.read()
+
+        logger.debug(f"File {file_name} retrieved successfully from flow {flow_id}.")
+        return content
 
     async def list_files(self, flow_id: str) -> list[str]:
         """List all files in a specific flow directory.
@@ -86,21 +123,17 @@ class LocalStorageService(StorageService):
             flow_id = str(flow_id)
 
         folder_path = self.data_dir / flow_id
-        if not folder_path.exists():
-            logger.debug(f"Flow folder {flow_id} does not exist.")
-            return []
-
-        if not folder_path.is_dir():
-            logger.warning(f"Flow path {flow_id} is not a directory.")
+        if not await folder_path.exists() or not await folder_path.is_dir():
+            await logger.awarning(f"Flow {flow_id} directory does not exist.")
             return []
 
         try:
-            files = [item.name for item in folder_path.iterdir() if item.is_file()]
+            files = [p.name async for p in folder_path.iterdir() if await p.is_file()]
         except Exception:  # noqa: BLE001
             logger.exception(f"Error listing files in flow {flow_id}")
             return []
         else:
-            logger.debug(f"Listed {len(files)} files in flow {flow_id}.")
+            await logger.ainfo(f"Listed {len(files)} files in flow {flow_id}.")
             return files
 
     async def delete_file(self, flow_id: str, file_name: str) -> None:
@@ -114,17 +147,11 @@ class LocalStorageService(StorageService):
             FileNotFoundError: If the file does not exist.
         """
         file_path = self.data_dir / flow_id / file_name
-        if not file_path.exists():
-            logger.warning(f"File {file_name} not found in flow {flow_id}.")
-            msg = f"File {file_name} not found in flow {flow_id}"
-            raise FileNotFoundError(msg)
-
-        try:
-            file_path.unlink()
-            logger.info(f"File {file_name} deleted successfully from flow {flow_id}.")
-        except Exception:
-            logger.exception(f"Error deleting file {file_name} in flow {flow_id}")
-            raise
+        if await file_path.exists():
+            await file_path.unlink()
+            await logger.ainfo(f"File {file_name} deleted successfully from flow {flow_id}.")
+        else:
+            await logger.awarning(f"Attempted to delete non-existent file {file_name} in flow {flow_id}.")
 
     async def get_file_size(self, flow_id: str, file_name: str) -> int:
         """Get the size of a file in bytes.
@@ -140,16 +167,19 @@ class LocalStorageService(StorageService):
             FileNotFoundError: If the file does not exist.
         """
         file_path = self.data_dir / flow_id / file_name
-        if not file_path.exists():
-            logger.warning(f"File {file_name} not found in flow {flow_id}.")
+        if not await file_path.exists():
+            await logger.awarning(f"File {file_name} not found in flow {flow_id}.")
             msg = f"File {file_name} not found in flow {flow_id}"
             raise FileNotFoundError(msg)
 
         try:
-            size = file_path.stat().st_size
+            file_size_stat = await file_path.stat()
         except Exception:
             logger.exception(f"Error getting size of file {file_name} in flow {flow_id}")
             raise
         else:
-            logger.debug(f"File {file_name} size: {size} bytes in flow {flow_id}.")
-            return size
+            return file_size_stat.st_size
+
+    async def teardown(self) -> None:
+        """Perform any cleanup operations when the service is being torn down."""
+        # No specific teardown actions required for local

lfx/services/storage/service.py

@@ -1,54 +1,177 @@
-"""Base storage service for lfx package."""
+from __future__ import annotations
 
-from abc import ABC, abstractmethod
-from pathlib import Path
+from abc import abstractmethod
+from typing import TYPE_CHECKING
 
+import anyio
 
-class StorageService(ABC):
-    """Abstract base class for storage services."""
+from lfx.services.base import Service
 
-    def __init__(self, data_dir: str | Path | None = None) -> None:
+if TYPE_CHECKING:
+    from collections.abc import AsyncIterator
+
+    from lfx.services.settings.service import SettingsService
+
+
+class StorageService(Service):
+    """Abstract base class for file storage services.
+
+    This class defines the interface for file storage operations that can be
+    implemented by different backends (local filesystem, S3, etc.).
+
+    All file operations are namespaced by flow_id to isolate files between
+    different flows or users.
+    """
+
+    name = "storage_service"
+
+    def __init__(self, session_service, settings_service: SettingsService):
         """Initialize the storage service.
 
         Args:
-            data_dir: Directory path for storing data. Defaults to ~/.lfx/data
+            session_service: The session service instance
+            settings_service: The settings service instance containing configuration
+        """
+        self.settings_service = settings_service
+        self.session_service = session_service
+        self.data_dir: anyio.Path = anyio.Path(settings_service.settings.config_dir)
+        self.set_ready()
+
+    def build_full_path(self, flow_id: str, file_name: str) -> str:
+        """Build the full path/key for a file.
+
+        Args:
+            flow_id: The flow/user identifier for namespacing
+            file_name: The name of the file
+
+        Returns:
+            str: The full path or key for the file
+        """
+        raise NotImplementedError
+
+    def resolve_component_path(self, logical_path: str) -> str:
+        """Convert a logical path to a format that components can use directly.
+
+        Logical paths are in the format "{flow_id}/{filename}" as stored in the database.
+        This method converts them to a format appropriate for the storage backend:
+        - Local storage: Absolute filesystem path (/data_dir/flow_id/filename)
+        - S3 storage: Logical path as-is (flow_id/filename)
+
+        Components receive this resolved path and can use it without knowing the
+        storage implementation details.
+
+        Args:
+            logical_path: Path in the format "flow_id/filename"
+
+        Returns:
+            str: A path that components can use directly
         """
-        if data_dir is None:
-            data_dir = Path.home() / ".lfx" / "data"
-        self.data_dir = Path(data_dir)
-        self._ready = False
+        raise NotImplementedError
 
     def set_ready(self) -> None:
         """Mark the service as ready."""
         self._ready = True
-        # Ensure the data directory exists
-        self.data_dir.mkdir(parents=True, exist_ok=True)
-
-    @property
-    def ready(self) -> bool:
-        """Check if the service is ready."""
-        return self._ready
 
     @abstractmethod
-    def build_full_path(self, flow_id: str, file_name: str) -> str:
-        """Build the full path for a file."""
+    async def save_file(self, flow_id: str, file_name: str, data: bytes, *, append: bool = False) -> None:
+        """Save a file to storage.
 
-    @abstractmethod
-    async def save_file(self, flow_id: str, file_name: str, data: bytes) -> None:
-        """Save a file."""
+        Args:
+            flow_id: The flow/user identifier for namespacing
+            file_name: The name of the file to save
+            data: The file content as bytes
+            append: If True, append to existing file instead of overwriting.
+
+        Raises:
+            Exception: If the file cannot be saved
+        """
+        raise NotImplementedError
 
     @abstractmethod
     async def get_file(self, flow_id: str, file_name: str) -> bytes:
-        """Retrieve a file."""
+        """Retrieve a file from storage.
+
+        Args:
+            flow_id: The flow/user identifier for namespacing
+            file_name: The name of the file to retrieve
+
+        Returns:
+            bytes: The file content
+
+        Raises:
+            FileNotFoundError: If the file does not exist
+        """
+        raise NotImplementedError
+
+    async def get_file_stream(self, flow_id: str, file_name: str, chunk_size: int = 8192) -> AsyncIterator[bytes]:
+        """Retrieve a file from storage as a stream.
+
+        Default implementation loads the entire file and yields it in chunks.
+        Subclasses can override this for more efficient streaming.
+
+        Args:
+            flow_id: The flow/user identifier for namespacing
+            file_name: The name of the file to retrieve
+            chunk_size: Size of chunks to yield (default: 8192 bytes)
+
+        Yields:
+            bytes: Chunks of the file content
+
+        Raises:
+            FileNotFoundError: If the file does not exist
+        """
+        # Default implementation - subclasses can override for true streaming
+        content = await self.get_file(flow_id, file_name)
+        for i in range(0, len(content), chunk_size):
+            yield content[i : i + chunk_size]
 
     @abstractmethod
     async def list_files(self, flow_id: str) -> list[str]:
-        """List files in a flow."""
+        """List all files in a flow's storage namespace.
 
-    @abstractmethod
-    async def delete_file(self, flow_id: str, file_name: str) -> None:
-        """Delete a file."""
+        Args:
+            flow_id: The flow/user identifier for namespacing
+
+        Returns:
+            list[str]: List of file names in the namespace
+
+        Raises:
+            FileNotFoundError: If the namespace directory does not exist
+        """
+        raise NotImplementedError
 
     @abstractmethod
     async def get_file_size(self, flow_id: str, file_name: str) -> int:
-        """Get the size of a file."""
+        """Get the size of a file in bytes.
+
+        Args:
+            flow_id: The flow/user identifier for namespacing
+            file_name: The name of the file
+
+        Returns:
+            int: Size of the file in bytes
+
+        Raises:
+            FileNotFoundError: If the file does not exist
+        """
+        raise NotImplementedError
+
+    @abstractmethod
+    async def delete_file(self, flow_id: str, file_name: str) -> None:
+        """Delete a file from storage.
+
+        Args:
+            flow_id: The flow/user identifier for namespacing
+            file_name: The name of the file to delete
+
+        Note:
+            Should not raise an error if the file doesn't exist
+        """
+        raise NotImplementedError
+
+    async def teardown(self) -> None:
+        """Perform cleanup operations when the service is being shut down.
+
+        Subclasses should override this to clean up any resources (connections, etc.)
+        """
+        raise NotImplementedError

lfx/template/field/base.py

@@ -208,6 +208,9 @@ class Output(BaseModel):
     allows_loop: bool = Field(default=False)
     """Specifies if the output allows looping."""
 
+    loop_types: list[str] | None = Field(default=None)
+    """List of additional types to include for loop inputs when allows_loop is True."""
+
     group_outputs: bool = Field(default=False)
     """Specifies if all outputs should be grouped and shown without dropdowns."""