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

lfx/components/files_and_knowledge/save_file.py

@@ -1,6 +1,7 @@
 import json
 from collections.abc import AsyncIterator, Iterator
 from pathlib import Path
+from typing import Any
 
 import orjson
 import pandas as pd
@@ -13,6 +14,15 @@ from lfx.io import BoolInput, DropdownInput, HandleInput, SecretStrInput, StrInp
 from lfx.schema import Data, DataFrame, Message
 from lfx.services.deps import get_settings_service, get_storage_service, session_scope
 from lfx.template.field.base import Output
+from lfx.utils.validate_cloud import is_astra_cloud_environment
+
+
+def _get_storage_location_options():
+    """Get storage location options, filtering out Local if in Astra cloud environment."""
+    all_options = [{"name": "AWS", "icon": "Amazon"}, {"name": "Google Drive", "icon": "google"}]
+    if is_astra_cloud_environment():
+        return all_options
+    return [{"name": "Local", "icon": "hard-drive"}, *all_options]
 
 
 class SaveToFileComponent(Component):
@@ -49,11 +59,7 @@ class SaveToFileComponent(Component):
             display_name="Storage Location",
             placeholder="Select Location",
             info="Choose where to save the file.",
-            options=[
-                {"name": "Local", "icon": "hard-drive"},
-                {"name": "AWS", "icon": "Amazon"},
-                {"name": "Google Drive", "icon": "google"},
-            ],
+            options=_get_storage_location_options(),
             real_time_refresh=True,
             limit=1,
         ),
@@ -116,6 +122,7 @@ class SaveToFileComponent(Component):
             info="AWS Access key ID.",
             show=False,
             advanced=True,
+            required=True,
         ),
         SecretStrInput(
             name="aws_secret_access_key",
@@ -123,6 +130,7 @@ class SaveToFileComponent(Component):
             info="AWS Secret Key.",
             show=False,
             advanced=True,
+            required=True,
         ),
         StrInput(
             name="bucket_name",
@@ -130,6 +138,7 @@ class SaveToFileComponent(Component):
             info="Enter the name of the S3 bucket.",
             show=False,
             advanced=True,
+            required=True,
         ),
         StrInput(
             name="aws_region",
@@ -152,6 +161,7 @@ class SaveToFileComponent(Component):
             info="Your Google Cloud Platform service account JSON key as a secret string (complete JSON content).",
             show=False,
             advanced=True,
+            required=True,
         ),
         StrInput(
             name="folder_id",
@@ -170,6 +180,12 @@ class SaveToFileComponent(Component):
 
     def update_build_config(self, build_config, field_value, field_name=None):
         """Update build configuration to show/hide fields based on storage location selection."""
+        # Update options dynamically based on cloud environment
+        # This ensures options are refreshed when build_config is updated
+        if "storage_location" in build_config:
+            updated_options = _get_storage_location_options()
+            build_config["storage_location"]["options"] = updated_options
+
         if field_name != "storage_location":
             return build_config
 
@@ -224,12 +240,14 @@ class SaveToFileComponent(Component):
                 for f_name in aws_fields:
                     if f_name in build_config:
                         build_config[f_name]["show"] = True
+                        build_config[f_name]["advanced"] = False
 
             elif location == "Google Drive":
                 gdrive_fields = ["gdrive_format", "service_account_key", "folder_id"]
                 for f_name in gdrive_fields:
                     if f_name in build_config:
                         build_config[f_name]["show"] = True
+                        build_config[f_name]["advanced"] = False
 
         return build_config
 
@@ -249,6 +267,11 @@ class SaveToFileComponent(Component):
             msg = "Storage location must be selected."
             raise ValueError(msg)
 
+        # Check if Local storage is disabled in cloud environment
+        if storage_location == "Local" and is_astra_cloud_environment():
+            msg = "Local storage is not available in cloud environment. Please use AWS or Google Drive."
+            raise ValueError(msg)
+
         # Route to appropriate save method based on storage location
         if storage_location == "Local":
             return await self._save_to_local()
@@ -540,32 +563,67 @@ class SaveToFileComponent(Component):
 
     async def _save_to_aws(self) -> Message:
         """Save file to AWS S3 using S3 functionality."""
+        import os
+
+        import boto3
+
+        from lfx.base.data.cloud_storage_utils import create_s3_client, validate_aws_credentials
+
+        # Get AWS credentials from component inputs or fall back to environment variables
+        aws_access_key_id = getattr(self, "aws_access_key_id", None)
+        if aws_access_key_id and hasattr(aws_access_key_id, "get_secret_value"):
+            aws_access_key_id = aws_access_key_id.get_secret_value()
+        if not aws_access_key_id:
+            aws_access_key_id = os.getenv("AWS_ACCESS_KEY_ID")
+
+        aws_secret_access_key = getattr(self, "aws_secret_access_key", None)
+        if aws_secret_access_key and hasattr(aws_secret_access_key, "get_secret_value"):
+            aws_secret_access_key = aws_secret_access_key.get_secret_value()
+        if not aws_secret_access_key:
+            aws_secret_access_key = os.getenv("AWS_SECRET_ACCESS_KEY")
+
+        bucket_name = getattr(self, "bucket_name", None)
+        if not bucket_name:
+            # Try to get from storage service settings
+            settings = get_settings_service().settings
+            bucket_name = settings.object_storage_bucket_name
+
         # Validate AWS credentials
-        if not getattr(self, "aws_access_key_id", None):
-            msg = "AWS Access Key ID is required for S3 storage"
+        if not aws_access_key_id:
+            msg = (
+                "AWS Access Key ID is required for S3 storage. Provide it as a component input "
+                "or set AWS_ACCESS_KEY_ID environment variable."
+            )
             raise ValueError(msg)
-        if not getattr(self, "aws_secret_access_key", None):
-            msg = "AWS Secret Key is required for S3 storage"
+        if not aws_secret_access_key:
+            msg = (
+                "AWS Secret Key is required for S3 storage. Provide it as a component input "
+                "or set AWS_SECRET_ACCESS_KEY environment variable."
+            )
             raise ValueError(msg)
-        if not getattr(self, "bucket_name", None):
-            msg = "S3 Bucket Name is required for S3 storage"
+        if not bucket_name:
+            msg = (
+                "S3 Bucket Name is required for S3 storage. Provide it as a component input "
+                "or set LANGFLOW_OBJECT_STORAGE_BUCKET_NAME environment variable."
+            )
             raise ValueError(msg)
 
-        # Use S3 upload functionality
-        try:
-            import boto3
-        except ImportError as e:
-            msg = "boto3 is not installed. Please install it using `uv pip install boto3`."
-            raise ImportError(msg) from e
+        # Validate AWS credentials
+        validate_aws_credentials(self)
 
         # Create S3 client
-        client_config = {
-            "aws_access_key_id": self.aws_access_key_id,
-            "aws_secret_access_key": self.aws_secret_access_key,
+        s3_client = create_s3_client(self)
+        client_config: dict[str, Any] = {
+            "aws_access_key_id": str(aws_access_key_id),
+            "aws_secret_access_key": str(aws_secret_access_key),
         }
 
-        if hasattr(self, "aws_region") and self.aws_region:
-            client_config["region_name"] = self.aws_region
+        # Get region from component input, environment variable, or settings
+        aws_region = getattr(self, "aws_region", None)
+        if not aws_region:
+            aws_region = os.getenv("AWS_DEFAULT_REGION") or os.getenv("AWS_REGION")
+        if aws_region:
+            client_config["region_name"] = str(aws_region)
 
         s3_client = boto3.client("s3", **client_config)
 
@@ -589,8 +647,8 @@ class SaveToFileComponent(Component):
 
         try:
             # Upload to S3
-            s3_client.upload_file(temp_file_path, self.bucket_name, file_path)
-            s3_url = f"s3://{self.bucket_name}/{file_path}"
+            s3_client.upload_file(temp_file_path, bucket_name, file_path)
+            s3_url = f"s3://{bucket_name}/{file_path}"
             return Message(text=f"File successfully uploaded to {s3_url}")
         finally:
             # Clean up temp file
@@ -599,6 +657,12 @@ class SaveToFileComponent(Component):
 
     async def _save_to_google_drive(self) -> Message:
         """Save file to Google Drive using Google Drive functionality."""
+        import tempfile
+
+        from googleapiclient.http import MediaFileUpload
+
+        from lfx.base.data.cloud_storage_utils import create_google_drive_service
+
         # Validate Google Drive credentials
         if not getattr(self, "service_account_key", None):
             msg = "GCP Credentials Secret Key is required for Google Drive storage"
@@ -607,71 +671,10 @@ class SaveToFileComponent(Component):
             msg = "Google Drive Folder ID is required for Google Drive storage"
             raise ValueError(msg)
 
-        # Use Google Drive upload functionality
-        try:
-            import json
-            import tempfile
-
-            from google.oauth2 import service_account
-            from googleapiclient.discovery import build
-            from googleapiclient.http import MediaFileUpload
-        except ImportError as e:
-            msg = "Google API client libraries are not installed. Please install them."
-            raise ImportError(msg) from e
-
-        # Parse credentials with multiple fallback strategies
-        credentials_dict = None
-        parse_errors = []
-
-        # Strategy 1: Parse as-is with strict=False to allow control characters
-        try:
-            credentials_dict = json.loads(self.service_account_key, strict=False)
-        except json.JSONDecodeError as e:
-            parse_errors.append(f"Standard parse: {e!s}")
-
-        # Strategy 2: Strip whitespace and try again
-        if credentials_dict is None:
-            try:
-                cleaned_key = self.service_account_key.strip()
-                credentials_dict = json.loads(cleaned_key, strict=False)
-            except json.JSONDecodeError as e:
-                parse_errors.append(f"Stripped parse: {e!s}")
-
-        # Strategy 3: Check if it's double-encoded (JSON string of a JSON string)
-        if credentials_dict is None:
-            try:
-                decoded_once = json.loads(self.service_account_key, strict=False)
-                if isinstance(decoded_once, str):
-                    credentials_dict = json.loads(decoded_once, strict=False)
-                else:
-                    credentials_dict = decoded_once
-            except json.JSONDecodeError as e:
-                parse_errors.append(f"Double-encoded parse: {e!s}")
-
-        # Strategy 4: Try to fix common issues with newlines in the private_key field
-        if credentials_dict is None:
-            try:
-                # Replace literal \n with actual newlines which is common in pasted JSON
-                fixed_key = self.service_account_key.replace("\\n", "\n")
-                credentials_dict = json.loads(fixed_key, strict=False)
-            except json.JSONDecodeError as e:
-                parse_errors.append(f"Newline-fixed parse: {e!s}")
-
-        if credentials_dict is None:
-            error_details = "; ".join(parse_errors)
-            msg = (
-                f"Unable to parse service account key JSON. Tried multiple strategies: {error_details}. "
-                "Please ensure you've copied the entire JSON content from your service account key file. "
-                "The JSON should start with '{' and contain fields like 'type', 'project_id', 'private_key', etc."
-            )
-            raise ValueError(msg)
-
-        # Create Google Drive service with appropriate scopes
-        # Use drive scope for folder access, file scope is too restrictive for folder verification
-        credentials = service_account.Credentials.from_service_account_info(
-            credentials_dict, scopes=["https://www.googleapis.com/auth/drive"]
+        # Create Google Drive service with full drive scope (needed for folder operations)
+        drive_service, credentials = create_google_drive_service(
+            self.service_account_key, scopes=["https://www.googleapis.com/auth/drive"], return_credentials=True
         )
-        drive_service = build("drive", "v3", credentials=credentials)
 
         # Extract content and format
         content = self._extract_content_for_upload()

lfx/components/langchain_utilities/tool_calling.py

@@ -44,12 +44,20 @@ class ToolCallingAgentComponent(LCToolsAgentComponent):
         return self.chat_history
 
     def create_agent_runnable(self):
-        messages = [
-            ("system", "{system_prompt}"),
-            ("placeholder", "{chat_history}"),
-            ("human", "{input}"),
-            ("placeholder", "{agent_scratchpad}"),
-        ]
+        messages = []
+
+        # Only include system message if system_prompt is provided and not empty
+        if hasattr(self, "system_prompt") and self.system_prompt and self.system_prompt.strip():
+            messages.append(("system", "{system_prompt}"))
+
+        messages.extend(
+            [
+                ("placeholder", "{chat_history}"),
+                ("human", "{input}"),
+                ("placeholder", "{agent_scratchpad}"),
+            ]
+        )
+
         prompt = ChatPromptTemplate.from_messages(messages)
         self.validate_tool_names()
         try:

lfx/components/llm_operations/batch_run.py

@@ -4,8 +4,13 @@ from typing import TYPE_CHECKING, Any, cast
 
 import toml  # type: ignore[import-untyped]
 
+from lfx.base.models.unified_models import (
+    get_language_model_options,
+    get_model_classes,
+    update_model_options_in_build_config,
+)
 from lfx.custom.custom_component.component import Component
-from lfx.io import BoolInput, DataFrameInput, HandleInput, MessageTextInput, MultilineInput, Output
+from lfx.io import BoolInput, DataFrameInput, MessageTextInput, ModelInput, MultilineInput, Output, SecretStrInput
 from lfx.log.logger import logger
 from lfx.schema.dataframe import DataFrame
 
@@ -20,13 +25,20 @@ class BatchRunComponent(Component):
     icon = "List"
 
     inputs = [
-        HandleInput(
+        ModelInput(
             name="model",
             display_name="Language Model",
-            info="Connect the 'Language Model' output from your LLM component here.",
-            input_types=["LanguageModel"],
+            info="Select your model provider",
+            real_time_refresh=True,
             required=True,
         ),
+        SecretStrInput(
+            name="api_key",
+            display_name="API Key",
+            info="Model Provider API key",
+            real_time_refresh=True,
+            advanced=True,
+        ),
         MultilineInput(
             name="system_message",
             display_name="Instructions",
@@ -76,6 +88,17 @@ class BatchRunComponent(Component):
         ),
     ]
 
+    def update_build_config(self, build_config: dict, field_value: str, field_name: str | None = None):
+        """Dynamically update build config with user-filtered model options."""
+        return update_model_options_in_build_config(
+            component=self,
+            build_config=build_config,
+            cache_key_prefix="language_model_options",
+            get_options_func=get_language_model_options,
+            field_name=field_name,
+            field_value=field_value,
+        )
+
     def _format_row_as_toml(self, row: dict[str, Any]) -> str:
         """Convert a dictionary (row) into a TOML-formatted string."""
         formatted_dict = {str(col): {"value": str(val)} for col, val in row.items()}
@@ -111,20 +134,43 @@ class BatchRunComponent(Component):
             }
 
     async def run_batch(self) -> DataFrame:
-        """Process each row in df[column_name] with the language model asynchronously.
-
-        Returns:
-            DataFrame: A new DataFrame containing:
-                - All original columns
-                - The model's response column (customizable name)
-                - 'batch_index' column for processing order
-                - 'metadata' (optional)
-
-        Raises:
-            ValueError: If the specified column is not found in the DataFrame
-            TypeError: If the model is not compatible or input types are wrong
-        """
-        model: Runnable = self.model
+        """Process each row in df[column_name] with the language model asynchronously."""
+        # Check if model is already an instance (for testing) or needs to be instantiated
+        if isinstance(self.model, list):
+            # Extract model configuration
+            model_selection = self.model[0]
+            model_name = model_selection.get("name")
+            provider = model_selection.get("provider")
+            metadata = model_selection.get("metadata", {})
+
+            # Get model class and parameters from metadata
+            model_class = get_model_classes().get(metadata.get("model_class"))
+            if model_class is None:
+                msg = f"No model class defined for {model_name}"
+                raise ValueError(msg)
+
+            api_key_param = metadata.get("api_key_param", "api_key")
+            model_name_param = metadata.get("model_name_param", "model")
+
+            # Get API key from global variables
+            from lfx.base.models.unified_models import get_api_key_for_provider
+
+            api_key = get_api_key_for_provider(self.user_id, provider, self.api_key)
+
+            if not api_key and provider != "Ollama":
+                msg = f"{provider} API key is required. Please configure it globally."
+                raise ValueError(msg)
+
+            # Instantiate the model
+            kwargs = {
+                model_name_param: model_name,
+                api_key_param: api_key,
+            }
+            model: Runnable = model_class(**kwargs)
+        else:
+            # Model is already an instance (typically in tests)
+            model = self.model
+
         system_msg = self.system_message or ""
         df: DataFrame = self.df
         col_name = self.column_name or ""

lfx/components/llm_operations/lambda_filter.py

@@ -4,14 +4,23 @@ import json
 import re
 from typing import TYPE_CHECKING, Any
 
+from lfx.base.models.unified_models import (
+    get_language_model_options,
+    get_llm,
+    update_model_options_in_build_config,
+)
 from lfx.custom.custom_component.component import Component
-from lfx.io import DataInput, HandleInput, IntInput, MultilineInput, Output
+from lfx.io import DataInput, IntInput, ModelInput, MultilineInput, Output, SecretStrInput
 from lfx.schema.data import Data
 from lfx.schema.dataframe import DataFrame
 
 if TYPE_CHECKING:
     from collections.abc import Callable
 
+# # Compute model options once at module level
+# _MODEL_OPTIONS = get_language_model_options()
+# _PROVIDERS = [provider["provider"] for provider in _MODEL_OPTIONS]
+
 
 class LambdaFilterComponent(Component):
     display_name = "Smart Transform"
@@ -29,13 +38,20 @@ class LambdaFilterComponent(Component):
             is_list=True,
             required=True,
         ),
-        HandleInput(
-            name="llm",
+        ModelInput(
+            name="model",
             display_name="Language Model",
-            info="Connect the 'Language Model' output from your LLM component here.",
-            input_types=["LanguageModel"],
+            info="Select your model provider",
+            real_time_refresh=True,
             required=True,
         ),
+        SecretStrInput(
+            name="api_key",
+            display_name="API Key",
+            info="Model Provider API key",
+            real_time_refresh=True,
+            advanced=True,
+        ),
         MultilineInput(
             name="filter_instruction",
             display_name="Instructions",
@@ -75,6 +91,17 @@ class LambdaFilterComponent(Component):
         ),
     ]
 
+    def update_build_config(self, build_config: dict, field_value: str, field_name: str | None = None):
+        """Dynamically update build config with user-filtered model options."""
+        return update_model_options_in_build_config(
+            component=self,
+            build_config=build_config,
+            cache_key_prefix="language_model_options",
+            get_options_func=get_language_model_options,
+            field_name=field_name,
+            field_value=field_value,
+        )
+
     def get_data_structure(self, data):
         """Extract the structure of data, replacing values with their types."""
         if isinstance(data, list):
@@ -129,7 +156,7 @@ class LambdaFilterComponent(Component):
         dump = json.dumps(data)
         self.log(str(data))
 
-        llm = self.llm
+        llm = get_llm(model=self.model, user_id=self.user_id, api_key=self.api_key)
         instruction = self.filter_instruction
         sample_size = self.sample_size
 

lfx/components/llm_operations/llm_conditional_router.py

@@ -1,7 +1,21 @@
 from typing import Any
 
+from lfx.base.models.unified_models import (
+    get_language_model_options,
+    get_llm,
+    update_model_options_in_build_config,
+)
 from lfx.custom import Component
-from lfx.io import BoolInput, HandleInput, MessageInput, MessageTextInput, MultilineInput, Output, TableInput
+from lfx.io import (
+    BoolInput,
+    MessageInput,
+    MessageTextInput,
+    ModelInput,
+    MultilineInput,
+    Output,
+    SecretStrInput,
+    TableInput,
+)
 from lfx.schema.message import Message
 from lfx.schema.table import EditMode
 
@@ -17,13 +31,20 @@ class SmartRouterComponent(Component):
         self._matched_category = None
 
     inputs = [
-        HandleInput(
-            name="llm",
+        ModelInput(
+            name="model",
             display_name="Language Model",
-            info="LLM to use for categorization.",
-            input_types=["LanguageModel"],
+            info="Select your model provider",
+            real_time_refresh=True,
             required=True,
         ),
+        SecretStrInput(
+            name="api_key",
+            display_name="API Key",
+            info="Model Provider API key",
+            real_time_refresh=True,
+            advanced=True,
+        ),
         MessageTextInput(
             name="input_text",
             display_name="Input",
@@ -111,6 +132,17 @@ class SmartRouterComponent(Component):
 
     outputs: list[Output] = []
 
+    def update_build_config(self, build_config: dict, field_value: str, field_name: str | None = None):
+        """Dynamically update build config with user-filtered model options."""
+        return update_model_options_in_build_config(
+            component=self,
+            build_config=build_config,
+            cache_key_prefix="language_model_options",
+            get_options_func=get_language_model_options,
+            field_name=field_name,
+            field_value=field_value,
+        )
+
     def update_outputs(self, frontend_node: dict, field_name: str, field_value: Any) -> dict:
         """Create a dynamic output for each category in the categories table."""
         if field_name in {"routes", "enable_else_output"}:
@@ -153,7 +185,7 @@ class SmartRouterComponent(Component):
 
         # Find the matching category using LLM-based categorization
         matched_category = None
-        llm = getattr(self, "llm", None)
+        llm = get_llm(model=self.model, user_id=self.user_id, api_key=self.api_key)
 
         if llm and categories:
             # Create prompt for categorization
@@ -315,7 +347,7 @@ class SmartRouterComponent(Component):
 
         # Check if any category matches using LLM categorization
         has_match = False
-        llm = getattr(self, "llm", None)
+        llm = get_llm(model=self.model, user_id=self.user_id, api_key=self.api_key)
 
         if llm and categories:
             try: