lfx-nightly 0.2.0.dev0__py3-none-any.whl → 0.2.0.dev41__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/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

@@ -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
@@ -433,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
@@ -454,10 +496,8 @@ 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}")
 
             pre_db_file_name = "langflow-pre.db"
             db_file_name = "langflow.db"
@@ -480,7 +520,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:
@@ -524,15 +563,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_")
@@ -543,13 +577,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
@@ -560,17 +591,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

@@ -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,102 @@
 """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:
+    def parse_file_path(self, full_path: str) -> tuple[str, str]:
+        """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"
+
+        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):
+            path_without_prefix = full_path[len(data_dir_str) :].lstrip("/")
+
+        # Split from the right to get the filename
+        # Everything before the last "/" is the flow_id
+        if "/" not in path_without_prefix:
+            return "", path_without_prefix
+
+        # Use rsplit to split from the right, limiting to 1 split
+        flow_id, file_name = path_without_prefix.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.
 
         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 +104,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 +131,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 +155,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 +179,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 +199,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