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

lfx/components/files_and_knowledge/save_file.py

@@ -77,7 +77,10 @@ class SaveToFileComponent(Component):
         BoolInput(
             name="append_mode",
             display_name="Append",
-            info="Append to file if it exists (only for plain text formats). Disabled for binary formats like Excel.",
+            info=(
+                "Append to file if it exists (only for Local storage with plain text formats). "
+                "Not supported for cloud storage (AWS/Google Drive)."
+            ),
             value=False,
             show=False,
         ),
@@ -157,6 +160,7 @@ class SaveToFileComponent(Component):
                 "The Google Drive folder ID where the file will be uploaded. "
                 "The folder must be shared with the service account email."
             ),
+            required=True,
             show=False,
             advanced=True,
         ),
@@ -196,11 +200,13 @@ class SaveToFileComponent(Component):
         if len(selected) == 1:
             location = selected[0]
 
-            # Show file_name and append_mode when any storage location is selected
+            # Show file_name when any storage location is selected
             if "file_name" in build_config:
                 build_config["file_name"]["show"] = True
+
+            # Show append_mode only for Local storage (not supported for cloud storage)
             if "append_mode" in build_config:
-                build_config["append_mode"]["show"] = True
+                build_config["append_mode"]["show"] = location == "Local"
 
             if location == "Local":
                 if "local_format" in build_config:
@@ -575,7 +581,9 @@ class SaveToFileComponent(Component):
         # Create temporary file
         import tempfile
 
-        with tempfile.NamedTemporaryFile(mode="w", suffix=f".{file_format}", delete=False) as temp_file:
+        with tempfile.NamedTemporaryFile(
+            mode="w", encoding="utf-8", suffix=f".{file_format}", delete=False
+        ) as temp_file:
             temp_file.write(content)
             temp_file_path = temp_file.name
 
@@ -611,16 +619,57 @@ class SaveToFileComponent(Component):
             msg = "Google API client libraries are not installed. Please install them."
             raise ImportError(msg) from e
 
-        # Parse credentials
+        # 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)
+            credentials_dict = json.loads(self.service_account_key, strict=False)
         except json.JSONDecodeError as e:
-            msg = f"Invalid JSON in service account key: {e!s}"
-            raise ValueError(msg) from 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
+        # 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.file"]
+            credentials_dict, scopes=["https://www.googleapis.com/auth/drive"]
         )
         drive_service = build("drive", "v3", credentials=credentials)
 
@@ -634,16 +683,34 @@ class SaveToFileComponent(Component):
 
         # Create temporary file
         file_path = f"{self.file_name}.{file_format}"
-        with tempfile.NamedTemporaryFile(mode="w", suffix=f".{file_format}", delete=False) as temp_file:
+        with tempfile.NamedTemporaryFile(
+            mode="w",
+            encoding="utf-8",
+            suffix=f".{file_format}",
+            delete=False,
+        ) as temp_file:
             temp_file.write(content)
             temp_file_path = temp_file.name
 
         try:
             # Upload to Google Drive
+            # Note: We skip explicit folder verification since it requires broader permissions.
+            # If the folder doesn't exist or isn't accessible, the create() call will fail with a clear error.
             file_metadata = {"name": file_path, "parents": [self.folder_id]}
             media = MediaFileUpload(temp_file_path, resumable=True)
 
-            uploaded_file = drive_service.files().create(body=file_metadata, media_body=media, fields="id").execute()
+            try:
+                uploaded_file = (
+                    drive_service.files().create(body=file_metadata, media_body=media, fields="id").execute()
+                )
+            except Exception as e:
+                msg = (
+                    f"Unable to upload file to Google Drive folder '{self.folder_id}'. "
+                    f"Error: {e!s}. "
+                    "Please ensure: 1) The folder ID is correct, 2) The folder exists, "
+                    "3) The service account has been granted access to this folder."
+                )
+                raise ValueError(msg) from e
 
             file_id = uploaded_file.get("id")
             file_url = f"https://drive.google.com/file/d/{file_id}/view"

lfx/components/ibm/watsonx.py

@@ -197,8 +197,14 @@ class WatsonxAIComponent(LCModelComponent):
             "logit_bias": logit_bias,
         }
 
+        # Pass API key as plain string to avoid SecretStr serialization issues
+        # when model is configured with with_config() or used in batch operations
+        api_key_value = self.api_key
+        if isinstance(api_key_value, SecretStr):
+            api_key_value = api_key_value.get_secret_value()
+
         return ChatWatsonx(
-            apikey=SecretStr(self.api_key).get_secret_value(),
+            apikey=api_key_value,
             url=self.base_url,
             project_id=self.project_id,
             model_id=self.model_name,

lfx/components/input_output/chat_output.py

@@ -121,13 +121,19 @@ class ChatOutput(ChatComponent):
             message = self.input_value
             # Update message properties
             message.text = text
+            # Preserve existing session_id from the incoming message if it exists
+            existing_session_id = message.session_id
         else:
             message = Message(text=text)
+            existing_session_id = None
 
         # Set message properties
         message.sender = self.sender
         message.sender_name = self.sender_name
-        message.session_id = self.session_id or self.graph.session_id or ""
+        # Preserve session_id from incoming message, or use component/graph session_id
+        message.session_id = (
+            self.session_id or existing_session_id or (self.graph.session_id if hasattr(self, "graph") else None) or ""
+        )
         message.context_id = self.context_id
         message.flow_id = self.graph.flow_id if hasattr(self, "graph") else None
         message.properties.source = self._build_source(source_id, display_name, source)

lfx/components/llm_operations/batch_run.py

@@ -159,13 +159,22 @@ class BatchRunComponent(Component):
             ]
 
             # Configure the model with project info and callbacks
-            model = model.with_config(
-                {
-                    "run_name": self.display_name,
-                    "project_name": self.get_project_name(),
-                    "callbacks": self.get_langchain_callbacks(),
-                }
-            )
+            # Some models (e.g., ChatWatsonx) may have serialization issues with with_config()
+            # due to SecretStr or other non-serializable attributes
+            try:
+                model = model.with_config(
+                    {
+                        "run_name": self.display_name,
+                        "project_name": self.get_project_name(),
+                        "callbacks": self.get_langchain_callbacks(),
+                    }
+                )
+            except (TypeError, ValueError, AttributeError) as e:
+                # Log warning and continue without configuration
+                await logger.awarning(
+                    f"Could not configure model with callbacks and project info: {e!s}. "
+                    "Proceeding with batch processing without configuration."
+                )
             # Process batches and track progress
             responses_with_idx = list(
                 zip(

lfx/components/models_and_agents/agent.py

@@ -619,9 +619,11 @@ class AgentComponent(ToolCallingAgentComponent):
                     # Call each component class's update_build_config method
                     # remove the prefix from the field_name
                     if isinstance(field_name, str) and isinstance(prefix, str):
-                        field_name = field_name.replace(prefix, "")
+                        field_name_without_prefix = field_name.replace(prefix, "")
+                    else:
+                        field_name_without_prefix = field_name
                     build_config = await update_component_build_config(
-                        component_class, build_config, field_value, "model_name"
+                        component_class, build_config, field_value, field_name_without_prefix
                     )
         return dotdict({k: v.to_dict() if hasattr(v, "to_dict") else v for k, v in build_config.items()})
 

lfx/components/models_and_agents/embedding_model.py

@@ -4,7 +4,6 @@ import requests
 from ibm_watsonx_ai.metanames import EmbedTextParamsMetaNames
 from langchain_openai import OpenAIEmbeddings
 
-from lfx.base.embeddings.embeddings_class import EmbeddingsWithModels
 from lfx.base.embeddings.model import LCEmbeddingsModel
 from lfx.base.models.model_utils import get_ollama_models, is_valid_ollama_url
 from lfx.base.models.openai_constants import OPENAI_EMBEDDING_MODEL_NAMES
@@ -152,7 +151,7 @@ class EmbeddingModelComponent(LCEmbeddingsModel):
             logger.exception("Error fetching models")
             return WATSONX_EMBEDDING_MODEL_NAMES
 
-    async def build_embeddings(self) -> Embeddings:
+    def build_embeddings(self) -> Embeddings:
         provider = self.provider
         model = self.model
         api_key = self.api_key
@@ -170,9 +169,7 @@ class EmbeddingModelComponent(LCEmbeddingsModel):
             if not api_key:
                 msg = "OpenAI API key is required when using OpenAI provider"
                 raise ValueError(msg)
-
-            # Create the primary embedding instance
-            embeddings_instance = OpenAIEmbeddings(
+            return OpenAIEmbeddings(
                 model=model,
                 dimensions=dimensions or None,
                 base_url=api_base or None,
@@ -184,26 +181,6 @@ class EmbeddingModelComponent(LCEmbeddingsModel):
                 model_kwargs=model_kwargs,
             )
 
-            # Create dedicated instances for each available model
-            available_models_dict = {}
-            for model_name in OPENAI_EMBEDDING_MODEL_NAMES:
-                available_models_dict[model_name] = OpenAIEmbeddings(
-                    model=model_name,
-                    dimensions=dimensions or None,  # Use same dimensions config for all
-                    base_url=api_base or None,
-                    api_key=api_key,
-                    chunk_size=chunk_size,
-                    max_retries=max_retries,
-                    timeout=request_timeout or None,
-                    show_progress_bar=show_progress_bar,
-                    model_kwargs=model_kwargs,
-                )
-
-            return EmbeddingsWithModels(
-                embeddings=embeddings_instance,
-                available_models=available_models_dict,
-            )
-
         if provider == "Ollama":
             try:
                 from langchain_ollama import OllamaEmbeddings
@@ -227,38 +204,12 @@ class EmbeddingModelComponent(LCEmbeddingsModel):
                     "Learn more at https://docs.ollama.com/openai#openai-compatibility"
                 )
 
-            final_base_url = transformed_base_url or "http://localhost:11434"
-
-            # Create the primary embedding instance
-            embeddings_instance = OllamaEmbeddings(
+            return OllamaEmbeddings(
                 model=model,
-                base_url=final_base_url,
+                base_url=transformed_base_url or "http://localhost:11434",
                 **model_kwargs,
             )
 
-            # Fetch available Ollama models
-            available_model_names = await get_ollama_models(
-                base_url_value=self.ollama_base_url,
-                desired_capability=DESIRED_CAPABILITY,
-                json_models_key=JSON_MODELS_KEY,
-                json_name_key=JSON_NAME_KEY,
-                json_capabilities_key=JSON_CAPABILITIES_KEY,
-            )
-
-            # Create dedicated instances for each available model
-            available_models_dict = {}
-            for model_name in available_model_names:
-                available_models_dict[model_name] = OllamaEmbeddings(
-                    model=model_name,
-                    base_url=final_base_url,
-                    **model_kwargs,
-                )
-
-            return EmbeddingsWithModels(
-                embeddings=embeddings_instance,
-                available_models=available_models_dict,
-            )
-
         if provider == "IBM watsonx.ai":
             try:
                 from langchain_ibm import WatsonxEmbeddings
@@ -278,11 +229,9 @@ class EmbeddingModelComponent(LCEmbeddingsModel):
 
             from ibm_watsonx_ai import APIClient, Credentials
 
-            final_url = base_url_ibm_watsonx or "https://us-south.ml.cloud.ibm.com"
-
             credentials = Credentials(
                 api_key=self.api_key,
-                url=final_url,
+                url=base_url_ibm_watsonx or "https://us-south.ml.cloud.ibm.com",
             )
 
             api_client = APIClient(credentials)
@@ -292,32 +241,13 @@ class EmbeddingModelComponent(LCEmbeddingsModel):
                 EmbedTextParamsMetaNames.RETURN_OPTIONS: {"input_text": self.input_text},
             }
 
-            # Create the primary embedding instance
-            embeddings_instance = WatsonxEmbeddings(
+            return WatsonxEmbeddings(
                 model_id=model,
                 params=params,
                 watsonx_client=api_client,
                 project_id=project_id,
             )
 
-            # Fetch available IBM watsonx.ai models
-            available_model_names = self.fetch_ibm_models(final_url)
-
-            # Create dedicated instances for each available model
-            available_models_dict = {}
-            for model_name in available_model_names:
-                available_models_dict[model_name] = WatsonxEmbeddings(
-                    model_id=model_name,
-                    params=params,
-                    watsonx_client=api_client,
-                    project_id=project_id,
-                )
-
-            return EmbeddingsWithModels(
-                embeddings=embeddings_instance,
-                available_models=available_models_dict,
-            )
-
         msg = f"Unknown provider: {provider}"
         raise ValueError(msg)
 

lfx/components/ollama/ollama.py

@@ -350,12 +350,17 @@ class ChatOllamaComponent(LCModelComponent):
                     build_config["mirostat_tau"]["value"] = 5
 
         if field_name in {"model_name", "base_url", "tool_model_enabled"}:
-            logger.warning(f"Fetching Ollama models from updated URL: {build_config['base_url']}")
-
-            if await self.is_valid_ollama_url(self.base_url):
+            # Use field_value if base_url is being updated, otherwise use self.base_url
+            base_url_to_check = field_value if field_name == "base_url" else self.base_url
+            # Fallback to self.base_url if field_value is None or empty
+            if not base_url_to_check and field_name == "base_url":
+                base_url_to_check = self.base_url
+            logger.warning(f"Fetching Ollama models from updated URL: {base_url_to_check}")
+
+            if base_url_to_check and await self.is_valid_ollama_url(base_url_to_check):
                 tool_model_enabled = build_config["tool_model_enabled"].get("value", False) or self.tool_model_enabled
                 build_config["model_name"]["options"] = await self.get_models(
-                    self.base_url, tool_model_enabled=tool_model_enabled
+                    base_url_to_check, tool_model_enabled=tool_model_enabled
                 )
             else:
                 build_config["model_name"]["options"] = []

lfx/components/processing/__init__.py

@@ -12,7 +12,6 @@ if TYPE_CHECKING:
     from lfx.components.processing.create_list import CreateListComponent
     from lfx.components.processing.data_operations import DataOperationsComponent
     from lfx.components.processing.dataframe_operations import DataFrameOperationsComponent
-    from lfx.components.processing.dataframe_to_toolset import DataFrameToToolsetComponent
     from lfx.components.processing.json_cleaner import JSONCleaner
     from lfx.components.processing.output_parser import OutputParserComponent
     from lfx.components.processing.parse_data import ParseDataComponent
@@ -27,7 +26,6 @@ _dynamic_imports = {
     "CreateListComponent": "create_list",
     "DataOperationsComponent": "data_operations",
     "DataFrameOperationsComponent": "dataframe_operations",
-    "DataFrameToToolsetComponent": "dataframe_to_toolset",
     "JSONCleaner": "json_cleaner",
     "OutputParserComponent": "output_parser",
     "ParseDataComponent": "parse_data",
@@ -41,7 +39,6 @@ __all__ = [
     "CombineTextComponent",
     "CreateListComponent",
     "DataFrameOperationsComponent",
-    "DataFrameToToolsetComponent",
     "DataOperationsComponent",
     "JSONCleaner",
     "MessageStoreComponent",

lfx/custom/directory_reader/directory_reader.py

@@ -72,8 +72,11 @@ class DirectoryReader:
                     if component["error"] if with_errors else not component["error"]:
                         component_tuple = (*build_component(component), component)
                         components.append(component_tuple)
-                except Exception:  # noqa: BLE001
-                    logger.debug(f"Error while loading component {component['name']} from {component['file']}")
+                except Exception as exc:  # noqa: BLE001
+                    logger.debug(
+                        f"Skipping component {component['name']} from {component['file']} (load error)",
+                        exc_info=exc,
+                    )
                     continue
             items.append({"name": menu["name"], "path": menu["path"], "components": components})
         filtered = [menu for menu in items if menu["components"]]

lfx/graph/graph/base.py

@@ -1519,10 +1519,7 @@ class Graph:
         try:
             params = ""
             should_build = False
-            # Loop components must always build, even when frozen,
-            # because they need to iterate through their data
-            is_loop_component = vertex.display_name == "Loop" or vertex.is_loop
-            if not vertex.frozen or is_loop_component:
+            if not vertex.frozen:
                 should_build = True
             else:
                 # Check the cache for the vertex

lfx/graph/vertex/base.py

@@ -735,10 +735,7 @@ class Vertex:
                 self.build_inactive()
                 return None
 
-            # Loop components should always run, even when frozen,
-            # because they need to iterate through their data
-            is_loop_component = self.display_name == "Loop" or self.is_loop
-            if self.frozen and self.built and not is_loop_component:
+            if self.frozen and self.built:
                 return await self.get_requester_result(requester)
             if self.built and requester is not None:
                 # This means that the vertex has already been built

lfx/schema/image.py

@@ -74,12 +74,7 @@ def get_file_paths(files: list[str | dict]):
         if not file_path_str:  # Skip empty paths
             continue
 
-        file_path = Path(file_path_str)
-        # Handle edge case where path might be just a filename without parent
-        if file_path.parent == Path():
-            flow_id, file_name = "", file_path.name
-        else:
-            flow_id, file_name = str(file_path.parent), file_path.name
+        flow_id, file_name = storage_service.parse_file_path(file_path_str)
 
         if not file_name:  # Skip if no filename
             continue
@@ -129,12 +124,7 @@ async def get_files(
         if not file:  # Skip empty file paths
             continue
 
-        file_path = Path(file)
-        # Handle edge case where path might be just a filename without parent
-        if file_path.parent == Path():
-            flow_id, file_name = "", file_path.name
-        else:
-            flow_id, file_name = str(file_path.parent), file_path.name
+        flow_id, file_name = storage_service.parse_file_path(file)
 
         if not file_name:  # Skip if no filename
             continue

lfx/services/interfaces.py

@@ -41,6 +41,11 @@ class StorageServiceProtocol(Protocol):
         """Build the full path of a file in the storage."""
         ...
 
+    @abstractmethod
+    def parse_file_path(self, full_path: str) -> tuple[str, str]:
+        """Parse a full storage path to extract flow_id and file_name."""
+        ...
+
 
 class SettingsServiceProtocol(Protocol):
     """Protocol for settings service."""

lfx/services/manager.py

@@ -155,10 +155,11 @@ class ServiceManager:
                         factories.append(obj())
                         break
 
-            except Exception as exc:  # noqa: BLE001
-                logger.debug(
-                    f"Could not initialize services. Please check your settings. Error in {name}.", exc_info=exc
-                )
+            except Exception:  # noqa: BLE001, S110
+                # This is expected during initial service discovery - some services
+                # may not have factories yet or depend on settings service being ready first
+                # Intentionally suppressed to avoid startup noise - not an error condition
+                pass
 
         return factories