lfx-nightly 0.1.12.dev35__py3-none-any.whl → 0.1.12.dev37__py3-none-any.whl

lfx/base/composio/composio_base.py

@@ -1,6 +1,7 @@
 import copy
 import json
 import re
+from contextlib import suppress
 from typing import Any
 
 from composio import Composio
@@ -381,9 +382,9 @@ class ComposioBaseComponent(Component):
                             if clean_field == "user_id":
                                 clean_field = f"{self.app_name}_user_id"
 
-                            # Handle reserved attribute name conflicts (e.g., 'status') by prefixing with app name
-                            # This prevents clashes with component attributes like self.status
-                            if clean_field in {"status"}:
+                            # Handle reserved attribute name conflicts (e.g., 'status', 'name')
+                            # Prefix with app name to prevent clashes with component attributes
+                            if clean_field in {"status", "name"}:
                                 clean_field = f"{self.app_name}_{clean_field}"
 
                             action_fields.append(clean_field)
@@ -549,6 +550,13 @@ class ComposioBaseComponent(Component):
                     field_schema_copy["description"] = f"Status for {self.app_name.title()}: " + field_schema.get(
                         "description", ""
                     )
+                elif clean_field_name == "name":
+                    clean_field_name = f"{self.app_name}_name"
+                    # Update the field schema description to reflect the name change
+                    field_schema_copy = field_schema.copy()
+                    field_schema_copy["description"] = f"Name for {self.app_name.title()}: " + field_schema.get(
+                        "description", ""
+                    )
                 else:
                     # Use the original field schema for all other fields
                     field_schema_copy = field_schema
@@ -571,7 +579,17 @@ class ComposioBaseComponent(Component):
 
             # Also update required fields to match cleaned names
             if flat_schema.get("required"):
-                cleaned_required = [field.replace("[0]", "") for field in flat_schema["required"]]
+                cleaned_required = []
+                for field in flat_schema["required"]:
+                    base = field.replace("[0]", "")
+                    if base == "user_id":
+                        cleaned_required.append(f"{self.app_name}_user_id")
+                    elif base == "status":
+                        cleaned_required.append(f"{self.app_name}_status")
+                    elif base == "name":
+                        cleaned_required.append(f"{self.app_name}_name")
+                    else:
+                        cleaned_required.append(base)
                 flat_schema["required"] = cleaned_required
 
             input_schema = create_input_schema_from_json_schema(flat_schema)
@@ -756,6 +774,9 @@ class ComposioBaseComponent(Component):
         # Ensure _all_fields includes new ones
         self._all_fields.update({i.name for i in lf_inputs if i.name is not None})
 
+        # Normalize input_types to prevent None values
+        self.update_input_types(build_config)
+
     def _is_tool_mode_enabled(self) -> bool:
         """Check if tool_mode is currently enabled."""
         return getattr(self, "tool_mode", False)
@@ -1094,6 +1115,20 @@ class ComposioBaseComponent(Component):
         # Also clear any tracked dynamic fields
         self._clear_auth_dynamic_fields(build_config)
 
+    def update_input_types(self, build_config: dict) -> dict:
+        """Normalize input_types to [] wherever None appears in the build_config template."""
+        try:
+            for key, value in list(build_config.items()):
+                if isinstance(value, dict):
+                    if value.get("input_types") is None:
+                        build_config[key]["input_types"] = []
+                elif hasattr(value, "input_types") and value.input_types is None:
+                    with suppress(AttributeError, TypeError):
+                        value.input_types = []
+        except (RuntimeError, KeyError):
+            pass
+        return build_config
+
     def update_build_config(self, build_config: dict, field_value: Any, field_name: str | None = None) -> dict:
         """Update build config for auth and action selection."""
         # Avoid normalizing legacy input_types here; rely on upstream fixes
@@ -1233,7 +1268,7 @@ class ComposioBaseComponent(Component):
             build_config["auth_link"].pop("connection_id", None)
             build_config["action_button"]["helper_text"] = "Please connect before selecting actions."
             build_config["action_button"]["helper_text_metadata"] = {"variant": "destructive"}
-            return build_config
+            return self.update_input_types(build_config)
 
         # Handle auth mode change -> render appropriate fields based on schema
         if field_name == "auth_mode":
@@ -1290,7 +1325,7 @@ class ComposioBaseComponent(Component):
                         }
                     build_config["action_button"]["helper_text"] = ""
                     build_config["action_button"]["helper_text_metadata"] = {}
-                    return build_config
+                    return self.update_input_types(build_config)
             if mode:
                 managed = schema.get("composio_managed_auth_schemes") or []
                 # Always hide the Create Auth Config control (used internally only)
@@ -1306,7 +1341,7 @@ class ComposioBaseComponent(Component):
                 else:
                     # Custom → render only required fields based on the toolkit schema
                     self._render_custom_auth_fields(build_config, schema, mode)
-                return build_config
+                return self.update_input_types(build_config)
 
         # Handle connection initiation when tool mode is enabled
         if field_name == "auth_link" and isinstance(field_value, dict):
@@ -1323,7 +1358,7 @@ class ComposioBaseComponent(Component):
                     build_config["action_button"]["helper_text"] = ""
                     build_config["action_button"]["helper_text_metadata"] = {}
                     logger.info(f"Using existing ACTIVE connection {connection_id} for {toolkit_slug}")
-                    return build_config
+                    return self.update_input_types(build_config)
 
                 # Only reuse ACTIVE connections; otherwise create a new connection
                 stored_connection_id = None
@@ -1342,11 +1377,11 @@ class ComposioBaseComponent(Component):
                             redirect_url, connection_id = self._initiate_connection(toolkit_slug)
                             build_config["auth_link"]["value"] = redirect_url
                             logger.info(f"New OAuth URL created for {toolkit_slug}: {redirect_url}")
-                            return build_config
+                            return self.update_input_types(build_config)
                         if not mode:
                             build_config["auth_link"]["value"] = "connect"
                             build_config["auth_link"]["auth_tooltip"] = "Select Auth Mode"
-                            return build_config
+                            return self.update_input_types(build_config)
                         # Custom modes: create auth config and/or initiate with config
                         # Validate required fields before creating any auth config
                         required_missing = []
@@ -1403,7 +1438,7 @@ class ComposioBaseComponent(Component):
                             build_config["auth_mode"]["helper_text_metadata"] = {"variant": "destructive"}
                             build_config["auth_link"]["value"] = "connect"
                             build_config["auth_link"]["auth_tooltip"] = f"Missing: {missing_joined}"
-                            return build_config
+                            return self.update_input_types(build_config)
                         composio = self._build_wrapper()
                         if mode == "OAUTH2":
                             # If an auth_config was already created via the button, use it and include initiation fields
@@ -1437,7 +1472,7 @@ class ComposioBaseComponent(Component):
                                 # Clear action blocker text on successful initiation
                                 build_config["action_button"]["helper_text"] = ""
                                 build_config["action_button"]["helper_text_metadata"] = {}
-                                return build_config
+                                return self.update_input_types(build_config)
                             # Otherwise, create custom OAuth2 auth config using schema-declared required fields
                             credentials = {}
                             missing = []
@@ -1487,7 +1522,7 @@ class ComposioBaseComponent(Component):
                                 build_config["auth_link"]["auth_config_id"] = auth_config_id
                                 build_config["auth_link"]["value"] = "connect"
                                 build_config["auth_link"]["auth_tooltip"] = "Connect"
-                                return build_config
+                                return self.update_input_types(build_config)
                             # Otherwise initiate immediately
                             redirect = composio.connected_accounts.initiate(
                                 user_id=self.entity_id,
@@ -1504,7 +1539,7 @@ class ComposioBaseComponent(Component):
                             self._clear_auth_fields_from_schema(build_config, schema)
                             build_config["action_button"]["helper_text"] = ""
                             build_config["action_button"]["helper_text_metadata"] = {}
-                            return build_config
+                            return self.update_input_types(build_config)
                         if mode == "API_KEY":
                             ac = composio.auth_configs.create(
                                 toolkit=toolkit_slug,
@@ -1550,7 +1585,7 @@ class ComposioBaseComponent(Component):
                             self._clear_auth_fields_from_schema(build_config, schema)
                             build_config["action_button"]["helper_text"] = ""
                             build_config["action_button"]["helper_text_metadata"] = {}
-                            return build_config
+                            return self.update_input_types(build_config)
                         # Generic custom auth flow for any other mode (treat like API_KEY)
                         ac = composio.auth_configs.create(
                             toolkit=toolkit_slug,
@@ -1584,13 +1619,13 @@ class ComposioBaseComponent(Component):
                         else:
                             build_config["auth_link"]["value"] = "validated"
                             build_config["auth_link"]["auth_tooltip"] = "Disconnect"
-                        return build_config
+                        return self.update_input_types(build_config)
                     except (ValueError, ConnectionError, TypeError) as e:
                         logger.error(f"Error creating connection: {e}")
                         build_config["auth_link"]["value"] = "connect"
                         build_config["auth_link"]["auth_tooltip"] = f"Error: {e!s}"
                     else:
-                        return build_config
+                        return self.update_input_types(build_config)
                 else:
                     # We already have a usable connection; no new OAuth request
                     build_config["auth_link"]["auth_tooltip"] = "Disconnect"
@@ -1732,7 +1767,7 @@ class ComposioBaseComponent(Component):
                 build_config["action_button"]["show"] = True  # Show action field when tool mode is disabled
                 for field in self._all_fields:
                     build_config[field]["show"] = True  # Update show status for all fields based on tool mode
-            return build_config
+            return self.update_input_types(build_config)
 
         if field_name == "action_button":
             # If selection is cancelled/cleared, remove generated fields
@@ -1748,12 +1783,12 @@ class ComposioBaseComponent(Component):
 
             if _is_cleared(field_value):
                 self._hide_all_action_fields(build_config)
-                return build_config
+                return self.update_input_types(build_config)
 
             self._update_action_config(build_config, field_value)
             # Keep the existing show/hide behaviour
             self.show_hide_fields(build_config, field_value)
-            return build_config
+            return self.update_input_types(build_config)
 
         # Handle auth config button click
         if field_name == "create_auth_config" and field_value == "create":
@@ -1798,7 +1833,7 @@ class ComposioBaseComponent(Component):
                         build_config["auth_link"]["auth_config_id"] = auth_config_id
                         build_config["auth_link"]["value"] = "connect"
                         build_config["auth_link"]["auth_tooltip"] = "Connect"
-                        return build_config
+                        return self.update_input_types(build_config)
                     # If no initiation fields required, initiate immediately
                     connection_request = composio.connected_accounts.initiate(
                         user_id=self.entity_id, auth_config_id=auth_config_id
@@ -1824,7 +1859,7 @@ class ComposioBaseComponent(Component):
                 logger.error(f"Error creating new auth config: {e}")
                 build_config["auth_link"]["value"] = "error"
                 build_config["auth_link"]["auth_tooltip"] = f"Error: {e!s}"
-            return build_config
+            return self.update_input_types(build_config)
 
         # Handle API key removal
         if field_name == "api_key" and len(field_value) == 0:
@@ -1861,16 +1896,16 @@ class ComposioBaseComponent(Component):
                 self._hide_all_action_fields(build_config)
             except (TypeError, ValueError, AttributeError):
                 pass
-            return build_config
+            return self.update_input_types(build_config)
 
         # Only proceed with connection logic if we have an API key
         if not hasattr(self, "api_key") or not self.api_key:
-            return build_config
+            return self.update_input_types(build_config)
 
         # CRITICAL: If tool_mode is enabled (check both instance and build_config), skip all connection logic
         if current_tool_mode:
             build_config["action_button"]["show"] = False
-            return build_config
+            return self.update_input_types(build_config)
 
         # Update action options only if tool_mode is disabled
         self._build_action_maps()
@@ -1931,7 +1966,7 @@ class ComposioBaseComponent(Component):
         if self._is_tool_mode_enabled():
             build_config["action_button"]["show"] = False
 
-        return build_config
+        return self.update_input_types(build_config)
 
     def configure_tools(self, composio: Composio, limit: int | None = None) -> list[Tool]:
         if limit is None:
@@ -2039,6 +2074,10 @@ class ComposioBaseComponent(Component):
                 final_field_name = field
                 if field.endswith("_user_id") and field.startswith(self.app_name):
                     final_field_name = "user_id"
+                elif field == f"{self.app_name}_status":
+                    final_field_name = "status"
+                elif field == f"{self.app_name}_name":
+                    final_field_name = "name"
 
                 arguments[final_field_name] = value
 

lfx/base/data/base_file.py

@@ -304,11 +304,12 @@ class BaseFileComponent(Component, ABC):
                     parts.append(str(data_text))
                 elif isinstance(d.data, dict):
                     # convert the data dict to a readable string
-                    parts.append(orjson.dumps(d.data, default=str).decode())
+                    parts.append(orjson.dumps(d.data, option=orjson.OPT_INDENT_2, default=str).decode())
                 else:
                     parts.append(str(d))
-            except (AttributeError, TypeError, ValueError):
+            except Exception:  # noqa: BLE001
                 # Final fallback - just try to convert to string
+                # TODO: Consider downstream error case more. Should this raise an error?
                 parts.append(str(d))
 
         return Message(text=sep.join(parts), **metadata)
@@ -671,6 +672,9 @@ class BaseFileComponent(Component, ABC):
         def _safe_extract_zip(bundle: ZipFile, output_dir: Path):
             """Safely extract ZIP files."""
             for member in bundle.namelist():
+                # Filter out resource fork information for automatic production of mac
+                if Path(member).name.startswith("._"):
+                    continue
                 member_path = output_dir / member
                 # Ensure no path traversal outside `output_dir`
                 if not member_path.resolve().is_relative_to(output_dir.resolve()):
@@ -681,6 +685,9 @@ class BaseFileComponent(Component, ABC):
         def _safe_extract_tar(bundle: tarfile.TarFile, output_dir: Path):
             """Safely extract TAR files."""
             for member in bundle.getmembers():
+                # Filter out resource fork information for automatic production of mac
+                if Path(member.name).name.startswith("._"):
+                    continue
                 member_path = output_dir / member.name
                 # Ensure no path traversal outside `output_dir`
                 if not member_path.resolve().is_relative_to(output_dir.resolve()):

lfx/components/__init__.py

@@ -96,6 +96,7 @@ if TYPE_CHECKING:
         vectara,
         vectorstores,
         vertexai,
+        vlmrun,
         weaviate,
         wikipedia,
         wolframalpha,
@@ -198,6 +199,7 @@ _dynamic_imports = {
     "vectara": "__module__",
     "vectorstores": "__module__",
     "vertexai": "__module__",
+    "vlmrun": "__module__",
     "weaviate": "__module__",
     "wikipedia": "__module__",
     "wolframalpha": "__module__",
@@ -326,6 +328,7 @@ __all__ = [
     "vectara",
     "vectorstores",
     "vertexai",
+    "vlmrun",
     "weaviate",
     "wikipedia",
     "wolframalpha",

lfx/components/vectorstores/local_db.py

@@ -22,7 +22,6 @@ class LocalDBComponent(LCVectorStoreComponent):
     name = "LocalDB"
     icon = "database"
     legacy = True
-    replacement = ["knowledgebases.KnowledgeRetrieval", "knowledgebases.KnowledgeIngestion"]
 
     inputs = [
         TabInput(

lfx/components/vlmrun/__init__.py

@@ -0,0 +1,34 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from langflow.components._importing import import_mod
+
+if TYPE_CHECKING:
+    from .vlmrun_transcription import VLMRunTranscription
+
+_dynamic_imports = {
+    "VLMRunTranscription": "vlmrun_transcription",
+}
+
+__all__ = [
+    "VLMRunTranscription",
+]
+
+
+def __getattr__(attr_name: str) -> Any:
+    """Lazily import VLMRun components on attribute access."""
+    if attr_name not in _dynamic_imports:
+        msg = f"module '{__name__}' has no attribute '{attr_name}'"
+        raise AttributeError(msg)
+    try:
+        result = import_mod(attr_name, _dynamic_imports[attr_name], __spec__.parent)
+    except (ModuleNotFoundError, ImportError, AttributeError) as e:
+        msg = f"Could not import '{attr_name}' from '{__name__}': {e}"
+        raise AttributeError(msg) from e
+    globals()[attr_name] = result
+    return result
+
+
+def __dir__() -> list[str]:
+    return list(__all__)

lfx/components/vlmrun/vlmrun_transcription.py

@@ -0,0 +1,224 @@
+from pathlib import Path
+from urllib.parse import urlparse
+
+from langflow.custom.custom_component.component import Component
+from langflow.io import (
+    DropdownInput,
+    FileInput,
+    IntInput,
+    MessageTextInput,
+    Output,
+    SecretStrInput,
+)
+from langflow.schema.data import Data
+from loguru import logger
+
+
+class VLMRunTranscription(Component):
+    display_name = "VLM Run Transcription"
+    description = "Extract structured data from audio and video using [VLM Run AI](https://app.vlm.run)"
+    documentation = "https://docs.vlm.run"
+    icon = "VLMRun"
+    beta = True
+
+    inputs = [
+        SecretStrInput(
+            name="api_key",
+            display_name="VLM Run API Key",
+            info="Get your API key from https://app.vlm.run",
+            required=True,
+        ),
+        DropdownInput(
+            name="media_type",
+            display_name="Media Type",
+            options=["audio", "video"],
+            value="audio",
+            info="Select the type of media to process",
+        ),
+        FileInput(
+            name="media_files",
+            display_name="Media Files",
+            file_types=[
+                "mp3",
+                "wav",
+                "m4a",
+                "flac",
+                "ogg",
+                "opus",
+                "webm",
+                "aac",
+                "mp4",
+                "mov",
+                "avi",
+                "mkv",
+                "flv",
+                "wmv",
+                "m4v",
+            ],
+            info="Upload one or more audio/video files",
+            required=False,
+            is_list=True,
+        ),
+        MessageTextInput(
+            name="media_url",
+            display_name="Media URL",
+            info="URL to media file (alternative to file upload)",
+            required=False,
+            advanced=True,
+        ),
+        IntInput(
+            name="timeout_seconds",
+            display_name="Timeout (seconds)",
+            value=600,
+            info="Maximum time to wait for processing completion",
+            advanced=True,
+        ),
+        DropdownInput(
+            name="domain",
+            display_name="Processing Domain",
+            options=["transcription"],
+            value="transcription",
+            info="Select the processing domain",
+            advanced=True,
+        ),
+    ]
+
+    outputs = [
+        Output(
+            display_name="Result",
+            name="result",
+            method="process_media",
+        ),
+    ]
+
+    def _check_inputs(self) -> str | None:
+        """Validate that either media files or URL is provided."""
+        if not self.media_files and not self.media_url:
+            return "Either media files or media URL must be provided"
+        return None
+
+    def _import_vlmrun(self):
+        """Import and return VLMRun client class."""
+        try:
+            from vlmrun.client import VLMRun
+        except ImportError as e:
+            error_msg = "VLM Run SDK not installed. Run: pip install 'vlmrun[all]'"
+            raise ImportError(error_msg) from e
+        else:
+            return VLMRun
+
+    def _generate_media_response(self, client, media_source):
+        """Generate response for audio or video media."""
+        domain_str = f"{self.media_type}.{self.domain}"
+
+        if self.media_type == "audio":
+            if isinstance(media_source, Path):
+                return client.audio.generate(file=media_source, domain=domain_str, batch=True)
+            return client.audio.generate(url=media_source, domain=domain_str, batch=True)
+        # video
+        if isinstance(media_source, Path):
+            return client.video.generate(file=media_source, domain=domain_str, batch=True)
+        return client.video.generate(url=media_source, domain=domain_str, batch=True)
+
+    def _wait_for_response(self, client, response):
+        """Wait for batch processing to complete if needed."""
+        if hasattr(response, "id"):
+            return client.predictions.wait(response.id, timeout=self.timeout_seconds)
+        return response
+
+    def _extract_transcription(self, segments: list) -> list[str]:
+        """Extract transcription parts from segments."""
+        transcription_parts = []
+        for segment in segments:
+            if self.media_type == "audio" and "audio" in segment:
+                transcription_parts.append(segment["audio"].get("content", ""))
+            elif self.media_type == "video" and "video" in segment:
+                transcription_parts.append(segment["video"].get("content", ""))
+                # Also include audio if available for video
+                if "audio" in segment:
+                    audio_content = segment["audio"].get("content", "")
+                    if audio_content and audio_content.strip():
+                        transcription_parts.append(f"[Audio: {audio_content}]")
+        return transcription_parts
+
+    def _create_result_dict(self, response, transcription_parts: list, source_name: str) -> dict:
+        """Create a standardized result dictionary."""
+        response_data = response.response if hasattr(response, "response") else {}
+        result = {
+            "prediction_id": response.id if hasattr(response, "id") else None,
+            "transcription": " ".join(transcription_parts),
+            "full_response": response_data,
+            "metadata": {
+                "media_type": self.media_type,
+                "duration": response_data.get("metadata", {}).get("duration", 0),
+            },
+            "usage": response.usage if hasattr(response, "usage") else None,
+            "status": response.status if hasattr(response, "status") else "completed",
+        }
+
+        # Add source-specific field
+        parsed_url = urlparse(source_name)
+        if parsed_url.scheme in ["http", "https", "s3", "gs", "ftp", "ftps"]:
+            result["source"] = source_name
+        else:
+            result["filename"] = source_name
+
+        return result
+
+    def _process_single_media(self, client, media_source, source_name: str) -> dict:
+        """Process a single media file or URL."""
+        response = self._generate_media_response(client, media_source)
+        response = self._wait_for_response(client, response)
+        response_data = response.response if hasattr(response, "response") else {}
+        segments = response_data.get("segments", [])
+        transcription_parts = self._extract_transcription(segments)
+        return self._create_result_dict(response, transcription_parts, source_name)
+
+    def process_media(self) -> Data:
+        """Process audio or video file and extract structured data."""
+        # Validate inputs
+        error_msg = self._check_inputs()
+        if error_msg:
+            self.status = error_msg
+            return Data(data={"error": error_msg})
+
+        try:
+            # Import and initialize client
+            vlmrun_class = self._import_vlmrun()
+            client = vlmrun_class(api_key=self.api_key)
+            all_results = []
+
+            # Handle multiple files
+            if self.media_files:
+                files_to_process = self.media_files if isinstance(self.media_files, list) else [self.media_files]
+                for idx, media_file in enumerate(files_to_process):
+                    self.status = f"Processing file {idx + 1} of {len(files_to_process)}..."
+                    result = self._process_single_media(client, Path(media_file), Path(media_file).name)
+                    all_results.append(result)
+
+            # Handle URL
+            elif self.media_url:
+                result = self._process_single_media(client, self.media_url, self.media_url)
+                all_results.append(result)
+
+            # Return clean, flexible output structure
+            output_data = {
+                "results": all_results,
+                "total_files": len(all_results),
+            }
+            self.status = f"Successfully processed {len(all_results)} file(s)"
+            return Data(data=output_data)
+
+        except ImportError as e:
+            self.status = str(e)
+            return Data(data={"error": str(e)})
+        except (ValueError, ConnectionError, TimeoutError) as e:
+            logger.opt(exception=True).debug("Error processing media with VLM Run")
+            error_msg = f"Processing failed: {e!s}"
+            self.status = error_msg
+            return Data(data={"error": error_msg})
+        except (AttributeError, KeyError, OSError) as e:
+            logger.opt(exception=True).debug("Unexpected error processing media with VLM Run")
+            error_msg = f"Unexpected error: {e!s}"
+            self.status = error_msg
+            return Data(data={"error": error_msg})

lfx/logging/logger.py

@@ -0,0 +1,24 @@
+"""Backwards compatibility module for lfx.logging.logger.
+
+This module provides backwards compatibility for code that imports from lfx.logging.logger.
+All functionality has been moved to lfx.log.logger.
+"""
+
+# Ensure we maintain all the original exports
+from lfx.log.logger import (
+    InterceptHandler,
+    LogConfig,
+    configure,
+    logger,
+    setup_gunicorn_logger,
+    setup_uvicorn_logger,
+)
+
+__all__ = [
+    "InterceptHandler",
+    "LogConfig",
+    "configure",
+    "logger",
+    "setup_gunicorn_logger",
+    "setup_uvicorn_logger",
+]

lfx/services/mcp_composer/service.py

@@ -417,9 +417,10 @@ class MCPComposerService(Service):
         startup_delay: float = 2.0,
     ) -> subprocess.Popen:
         """Start the MCP Composer subprocess for a specific project."""
+        settings = get_settings_service().settings
         cmd = [
             "uvx",
-            "mcp-composer",
+            f"mcp-composer{settings.mcp_composer_version}",
             "--mode",
             "sse",
             "--sse-url",
@@ -447,7 +448,7 @@ class MCPComposerService(Service):
                     "oauth_server_url": "OAUTH_SERVER_URL",
                     "oauth_callback_path": "OAUTH_CALLBACK_PATH",
                     "oauth_client_id": "OAUTH_CLIENT_ID",
-                    "oauth_client_secret": "OAUTH_CLIENT_SECRET",
+                    "oauth_client_secret": "OAUTH_CLIENT_SECRET",  # pragma: allowlist secret
                     "oauth_auth_url": "OAUTH_AUTH_URL",
                     "oauth_token_url": "OAUTH_TOKEN_URL",
                     "oauth_mcp_scope": "OAUTH_MCP_SCOPE",

lfx/services/settings/base.py

@@ -285,6 +285,9 @@ 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."""
 
     # Public Flow Settings
     public_flow_cleanup_interval: int = Field(default=3600, gt=600)
@@ -348,6 +351,34 @@ class Settings(BaseSettings):
         logger.debug(f"Setting user agent to {value}")
         return value
 
+    @field_validator("mcp_composer_version", mode="before")
+    @classmethod
+    def validate_mcp_composer_version(cls, value):
+        """Ensure the version string has a version specifier prefix.
+
+        If a bare version like '0.1.0.7' is provided, prepend '~=' to allow patch updates.
+        Supports PEP 440 specifiers: ==, !=, <=, >=, <, >, ~=, ===
+        """
+        if not value:
+            return "~=0.1.0.7"  # Default
+
+        # Check if it already has a version specifier
+        # Order matters: check longer specifiers first to avoid false matches
+        specifiers = ["===", "==", "!=", "<=", ">=", "~=", "<", ">"]
+        if any(value.startswith(spec) for spec in specifiers):
+            return value
+
+        # If it's a bare version number, add ~= prefix
+        # This regex matches version numbers like 0.1.0.7, 1.2.3, etc.
+        import re
+
+        if re.match(r"^\d+(\.\d+)*", value):
+            logger.debug(f"Adding ~= prefix to bare version '{value}' -> '~={value}'")
+            return f"~={value}"
+
+        # If we can't determine, return as-is and let uvx handle it
+        return value
+
     @field_validator("variables_to_get_from_environment", mode="before")
     @classmethod
     def set_variables_to_get_from_environment(cls, value):

{lfx_nightly-0.1.12.dev35.dist-info → lfx_nightly-0.1.12.dev37.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lfx-nightly
-Version: 0.1.12.dev35
+Version: 0.1.12.dev37
 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

{lfx_nightly-0.1.12.dev35.dist-info → lfx_nightly-0.1.12.dev37.dist-info}/RECORD

@@ -22,13 +22,13 @@ lfx/base/astra_assistants/util.py,sha256=T_W44VFoOXBF3m-0eCSrHvzbKx1gdyBF9IAWKMX
 lfx/base/chains/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 lfx/base/chains/model.py,sha256=QSYJBc0Ygpx2Ko273u1idL_gPK2xpvRQgJb4oTx8x8s,766
 lfx/base/composio/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-lfx/base/composio/composio_base.py,sha256=orFVSLWDCmvxarzCHAJdXlMhT7dr4MxGZNEeNmx76hc,113150
+lfx/base/composio/composio_base.py,sha256=pltCXF0eQVfGbetksE2sXMTPMji8lR1jSryeMNrYNZM,115607
 lfx/base/compressors/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 lfx/base/compressors/model.py,sha256=-FFBAPAy9bAgvklIo7x_uwShZR5NoMHakF6f_hNnLHg,2098
 lfx/base/curl/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 lfx/base/curl/parse.py,sha256=Yw6mMbGg7e-ffrBItEUJeTiljneCXlNyt5afzEP9eUI,6094
 lfx/base/data/__init__.py,sha256=lQsYYMyAg_jA9ZF7oc-LNZsRE2uMGT6g16WzsUByHqs,81
-lfx/base/data/base_file.py,sha256=ZYAEThTcRI7Oy4aEZPMYCC0UDljXQSDVypdPRpDJEAs,27599
+lfx/base/data/base_file.py,sha256=UKpF9BsNHgg-cdB1uVB8F00czvCTLfks320aLg3F_kM,28049
 lfx/base/data/docling_utils.py,sha256=gVDxOZghSJEo5n-UNkVGBQYqkvfNqkNkltBhAnoaJd4,13048
 lfx/base/data/utils.py,sha256=dGqEO4zE5s_V2Cs4j0EEeyLjYLX6Zex-EGzIOznK76o,5960
 lfx/base/document_transformers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -94,7 +94,7 @@ lfx/cli/run.py,sha256=_7JX6YpoO3XLCfD2BtZl3FsghMyo18B9SriLyO0EaoQ,21411
 lfx/cli/script_loader.py,sha256=xWSpx57cBeX0UHmUgAk97aye9-hhD2Y6nKh68A-xaTA,8997
 lfx/cli/serve_app.py,sha256=3U0QsoCkf-1DxSpxfNOr8ap7Giaxm_MfuLrii5GpIHM,22485
 lfx/cli/validation.py,sha256=xZfL-rKt_Y-Lek19GMZffyxhPIyYMQHBIpR0Hwa_Ji8,2615
-lfx/components/__init__.py,sha256=3oqczcZDZEpgm8p3QLotXwgmAvBJDYUW8ME5CrDb2Ac,10994
+lfx/components/__init__.py,sha256=aZTGgShKOfNK2G6MPCYMWYQB7PX-achWa1ZqGD0a51E,11052
 lfx/components/_importing.py,sha256=XYMV7cnw6QAw9hdY5dOybc3RZ7esDVYd8pOV822xdsU,1625
 lfx/components/FAISS/__init__.py,sha256=gbdyinU7MBtv4PRUfUcPuR08_Ixx0W95LdIXHEgmrfg,935
 lfx/components/FAISS/faiss.py,sha256=K9egZNckeHOrPqxuFia4VL4-mFphyEl6dQ_F-lXvax8,3893
@@ -515,7 +515,7 @@ lfx/components/vectorstores/elasticsearch.py,sha256=WcBi8THcOzopZeYOQeEoHxsZkACH
 lfx/components/vectorstores/faiss.py,sha256=K9egZNckeHOrPqxuFia4VL4-mFphyEl6dQ_F-lXvax8,3893
 lfx/components/vectorstores/graph_rag.py,sha256=4NmYQkjSru_zaDhJfxdaYtap-RMGJfv2AYN2NEYSdds,5163
 lfx/components/vectorstores/hcd.py,sha256=Fo7Zj4U-A1ZcbsdhlTxheMJDy8EzbYWlo85iY6vASnQ,12379
-lfx/components/vectorstores/local_db.py,sha256=i2GxQ7SwtcCED0bqXWkc7lMtfT0vzsKWUC0NLtEhCXk,10741
+lfx/components/vectorstores/local_db.py,sha256=bruzpEk6PQc1DeGqSWJblsVplJ5eC1JsSlncxRc4yuQ,10648
 lfx/components/vectorstores/milvus.py,sha256=_jMyO4l5y6O2Lkx9eHyuhgcHtXcApkI-ktuqa1YxnGI,4395
 lfx/components/vectorstores/mongodb_atlas.py,sha256=OlAstNMToHuvGI-8djkiGr7kdGBr927O0SE5cnVd0O0,8594
 lfx/components/vectorstores/opensearch.py,sha256=P8Eq4KsjHT8b7iOUOKMFRwOLwgRfIWfxIHLD0GJsw24,9080
@@ -530,6 +530,8 @@ lfx/components/vectorstores/weaviate.py,sha256=ZrqR1qRA3IZsJB-TB07C7Qyqt5ysh-eEi
 lfx/components/vertexai/__init__.py,sha256=bIcDPTzHyUujS75CWtFxYCvdY7eygvH3UDmWVAcX8I0,1090
 lfx/components/vertexai/vertexai.py,sha256=2fdSgdP6lfVYZElxWvuwi5wylpwFEtlSUlT1zaCGtgE,2992
 lfx/components/vertexai/vertexai_embeddings.py,sha256=Or1cFSZKKUp063yZVny7oqKiWgEqonhhCHPbRjY4CMA,3135
+lfx/components/vlmrun/__init__.py,sha256=RTywYzmYq35aiPiJL0_01KhphJewLTDNBSUVmsM9y-E,953
+lfx/components/vlmrun/vlmrun_transcription.py,sha256=yR4jSaPfAhkh5-Xcc5artMbuBD_Tcsl5gwxCjPOdshg,8667
 lfx/components/weaviate/__init__.py,sha256=IJPCeA67vEeqHcsf_DqbKV5DXKmHEKBVTxPgBHlrzuU,953
 lfx/components/weaviate/weaviate.py,sha256=zMnx4BSdt7HmXj4r_CHLEq4g93kW7sGFDstJT1n89n0,3271
 lfx/components/wikipedia/__init__.py,sha256=sOp1c_gIOcIL-XZFqFExa_DTklDOCIdzVl_OUVV9-yE,137
@@ -628,6 +630,7 @@ lfx/load/utils.py,sha256=qa8aoMLW-X8FO8xVz3YVHQwjTSJYbYr_AOQAAp3smlc,3705
 lfx/log/__init__.py,sha256=UATLSm1Fp9rVclAXP00LKQzzYKcaboVSuWNujlRR6P4,119
 lfx/log/logger.py,sha256=UaUlWEwws7SVa24_9ZuPwRgefoatzRV7nnZV7YQZjwU,14238
 lfx/logging/__init__.py,sha256=X5tXF5e1hc62adprRPLtKeaqm8-tpl6loXsxbh9IO-Q,367
+lfx/logging/logger.py,sha256=y7ophyWX5-r8RCxHJeAmGKyGeEhR-7imR-D8YBXU7CE,546
 lfx/memory/__init__.py,sha256=s7nCNKlcwLfT6Z_cXbiYjvoXQXZ-H2GqK1qsAuKBV08,1815
 lfx/memory/stubs.py,sha256=kR6TRI2t6rPvA5Pja5XPC4yvKRBFBuJfdI0hJL8vfwU,9924
 lfx/processing/__init__.py,sha256=jERZg6it9mhOzrbTAt9YtakSNXPSjUXFh5MfKBN48wA,41
@@ -674,10 +677,10 @@ lfx/services/chat/config.py,sha256=l2btsQ3xp-CYD5XiatZC8y23gkUn0Qr4_TzVjPpzwJo,4
 lfx/services/chat/schema.py,sha256=MHq5o3adAiLZIpR8OxM2vEkxRmEtZURIvvB9S4-pXoc,286
 lfx/services/mcp_composer/__init__.py,sha256=Y5IahKX0siDJuRCvUF_KrpAQq6UmHzQtXu8rXvdThqM,242
 lfx/services/mcp_composer/factory.py,sha256=f8Bj0ZR9A_o1c3Kw5JKyR6SbtbCEPNWOy8b0OK990Z8,530
-lfx/services/mcp_composer/service.py,sha256=Binv29dXSRscUPOa40714w_NYmebZB3gwBp68KnaSFc,25765
+lfx/services/mcp_composer/service.py,sha256=TdQoQ1VV_aATRGCYNm9MZRj_WEb45LLP4ACub_ChCXg,25876
 lfx/services/settings/__init__.py,sha256=UISBvOQIqoA3a8opwJrTQp4PSTqpReY6GQ_7O6WuqJQ,65
 lfx/services/settings/auth.py,sha256=_18KZipq0udCJPq-4xCD_juhqSwAEvoCqxOTSYsNv5w,5720
-lfx/services/settings/base.py,sha256=8_eiUe90Yi_YKw-abRurGXgbmVmOAbSXEbUDTabXbas,26221
+lfx/services/settings/base.py,sha256=xtqqE4f8Bo-Dt0D2DlB83-BHss8BACYioaQ08y5ETYY,27558
 lfx/services/settings/constants.py,sha256=ZBJolZ4kx0ZoYp2BDyHkgDFgaXEQAH-ZcLqgunv_MqQ,908
 lfx/services/settings/factory.py,sha256=NezZ6TE_xP955B9l9pI6ONNyoylrHPfUZN8arvLVRXg,615
 lfx/services/settings/feature_flags.py,sha256=HGuDGgfOBIDtuEiEVTgoWHxKqX2vuVBRgsqdX_4D9kg,205
@@ -721,7 +724,7 @@ lfx/utils/schemas.py,sha256=NbOtVQBrn4d0BAu-0H_eCTZI2CXkKZlRY37XCSmuJwc,3865
 lfx/utils/util.py,sha256=Ww85wbr1-vjh2pXVtmTqoUVr6MXAW8S7eDx_Ys6HpE8,20696
 lfx/utils/util_strings.py,sha256=nU_IcdphNaj6bAPbjeL-c1cInQPfTBit8mp5Y57lwQk,1686
 lfx/utils/version.py,sha256=cHpbO0OJD2JQAvVaTH_6ibYeFbHJV0QDHs_YXXZ-bT8,671
-lfx_nightly-0.1.12.dev35.dist-info/METADATA,sha256=15fUNw16xD_P0VF15znV4v47_8SRS1cEOAY2R05g-Fg,8290
-lfx_nightly-0.1.12.dev35.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-lfx_nightly-0.1.12.dev35.dist-info/entry_points.txt,sha256=1724p3RHDQRT2CKx_QRzEIa7sFuSVO0Ux70YfXfoMT4,42
-lfx_nightly-0.1.12.dev35.dist-info/RECORD,,
+lfx_nightly-0.1.12.dev37.dist-info/METADATA,sha256=d776iFhCA-JXSNc7oP-rmjUilfF7E-LU99hI434WnDs,8290
+lfx_nightly-0.1.12.dev37.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+lfx_nightly-0.1.12.dev37.dist-info/entry_points.txt,sha256=1724p3RHDQRT2CKx_QRzEIa7sFuSVO0Ux70YfXfoMT4,42
+lfx_nightly-0.1.12.dev37.dist-info/RECORD,,