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

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",
         ]
 

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,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"
@@ -524,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:
@@ -568,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_")
@@ -587,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
@@ -604,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/storage/local.py

@@ -57,6 +57,38 @@ 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]:
+        """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.
 

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/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}}

{lfx_nightly-0.2.0.dev26.dist-info → lfx_nightly-0.2.0.dev41.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lfx-nightly
-Version: 0.2.0.dev26
+Version: 0.2.0.dev41
 Summary: Langflow Executor - A lightweight CLI tool for executing and serving Langflow AI flows
 Author-email: Gabriel Luiz Freitas Almeida <gabriel@langflow.org>
 Requires-Python: <3.14,>=3.10