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

lfx/components/composio/github_composio.py

@@ -3,7 +3,7 @@ from lfx.base.composio.composio_base import ComposioBaseComponent
 
 class ComposioGitHubAPIComponent(ComposioBaseComponent):
     display_name: str = "GitHub"
-    icon = "Github"
+    icon = "GithubComposio"
     documentation: str = "https://docs.composio.dev"
     app_name = "github"
 

lfx/components/cuga/cuga_agent.py

@@ -53,7 +53,7 @@ class CugaComponent(ToolCallingAgentComponent):
     """Cuga Agent Component for advanced AI task execution.
 
     The Cuga component is an advanced AI agent that can execute complex tasks using
-    various tools and browser automation. It supports custom policies, web applications,
+    various tools and browser automation. It supports custom instructions, web applications,
     and API interactions.
 
     Attributes:
@@ -65,7 +65,7 @@ class CugaComponent(ToolCallingAgentComponent):
     """
 
     display_name: str = "Cuga"
-    description: str = "Define the Cuga agent's policies, then assign it a task."
+    description: str = "Define the Cuga agent's instructions, then assign it a task."
     documentation: str = "https://docs.langflow.org/bundles-cuga"
     icon = "bot"
     name = "Cuga"
@@ -85,10 +85,10 @@ class CugaComponent(ToolCallingAgentComponent):
         ),
         *MODEL_PROVIDERS_DICT["OpenAI"]["inputs"],
         MultilineInput(
-            name="policies",
-            display_name="Policies",
+            name="instructions",
+            display_name="Instructions",
             info=(
-                "Custom instructions or policies for the agent to adhere to during its operation.\n"
+                "Custom instructions for the agent to adhere to during its operation.\n"
                 "Example:\n"
                 "## Plan\n"
                 "< planning instructions e.g. which tools and when to use>\n"
@@ -117,16 +117,16 @@ class CugaComponent(ToolCallingAgentComponent):
         BoolInput(
             name="lite_mode",
             display_name="Enable CugaLite",
-            info="Enable CugaLite for simple API tasks (faster execution).",
+            info="Faster reasoning for simple tasks. Enable CugaLite for simple API tasks.",
             value=True,
-            advanced=False,
+            advanced=True,
         ),
         IntInput(
             name="lite_mode_tool_threshold",
             display_name="CugaLite Tool Threshold",
             info="Route to CugaLite if app has fewer than this many tools.",
             value=25,
-            advanced=False,
+            advanced=True,
         ),
         DropdownInput(
             name="decomposition_strategy",
@@ -142,17 +142,17 @@ class CugaComponent(ToolCallingAgentComponent):
             display_name="Enable Browser",
             info="Toggle to enable a built-in browser tool for web scraping and searching.",
             value=False,
-            advanced=False,
+            advanced=True,
         ),
         MultilineInput(
             name="web_apps",
             display_name="Web applications",
             info=(
-                "Define a list of web applications that cuga will open when enable browser is true. "
+                "Cuga will automatically start this web application when Enable Browser is true. "
                 "Currently only supports one web application. Example: https://example.com"
             ),
             value="",
-            advanced=False,
+            advanced=True,
         ),
     ]
     outputs = [
@@ -211,7 +211,6 @@ class CugaComponent(ToolCallingAgentComponent):
                 settings.advanced_features.mode = "api"
 
             from cuga.backend.activity_tracker.tracker import ActivityTracker
-            from cuga.backend.cuga_graph.nodes.api.variables_manager.manager import VariablesManager
             from cuga.backend.cuga_graph.utils.agent_loop import StreamEvent
             from cuga.backend.cuga_graph.utils.controller import (
                 AgentRunner as CugaAgent,
@@ -222,13 +221,10 @@ class CugaComponent(ToolCallingAgentComponent):
             from cuga.backend.llm.models import LLMManager
             from cuga.configurations.instructions_manager import InstructionsManager
 
-            var_manager = VariablesManager()
-
             # Reset var_manager if this is the first message in history
             logger.debug(f"[CUGA] Checking history_messages: count={len(history_messages) if history_messages else 0}")
             if not history_messages or len(history_messages) == 0:
                 logger.debug("[CUGA] First message in history detected, resetting var_manager")
-                var_manager.reset()
             else:
                 logger.debug(f"[CUGA] Continuing conversation with {len(history_messages)} previous messages")
 
@@ -236,12 +232,14 @@ class CugaComponent(ToolCallingAgentComponent):
             llm_manager.set_llm(llm)
             instructions_manager = InstructionsManager()
 
-            policies_to_use = self.policies or ""
-            logger.debug(f"[CUGA] policies are: {policies_to_use}")
-            instructions_manager.set_instructions_from_one_file(policies_to_use)
+            instructions_to_use = self.instructions or ""
+            logger.debug(f"[CUGA] instructions are: {instructions_to_use}")
+            instructions_manager.set_instructions_from_one_file(instructions_to_use)
             tracker = ActivityTracker()
             tracker.set_tools(tools)
-            cuga_agent = CugaAgent(browser_enabled=self.browser_enabled)
+            thread_id = self.graph.session_id
+            logger.debug(f"[CUGA] Using thread_id (session_id): {thread_id}")
+            cuga_agent = CugaAgent(browser_enabled=self.browser_enabled, thread_id=thread_id)
             if self.browser_enabled:
                 await cuga_agent.initialize_freemode_env(start_url=self.web_apps.strip(), interface_mode="browser_only")
             else:
@@ -257,13 +255,20 @@ class CugaComponent(ToolCallingAgentComponent):
             logger.debug(f"[CUGA] Processing input: {current_input}")
             try:
                 # Convert history to LangChain format for the event
+                logger.debug(f"[CUGA] Converting {len(history_messages)} history messages to LangChain format")
                 lc_messages = []
-                for msg in history_messages:
+                for i, msg in enumerate(history_messages):
+                    msg_text = getattr(msg, "text", "N/A")[:50] if hasattr(msg, "text") else "N/A"
+                    logger.debug(
+                        f"[CUGA] Message {i}: type={type(msg)}, sender={getattr(msg, 'sender', 'N/A')}, "
+                        f"text={msg_text}..."
+                    )
                     if hasattr(msg, "sender") and msg.sender == "Human":
                         lc_messages.append(HumanMessage(content=msg.text))
                     else:
                         lc_messages.append(AIMessage(content=msg.text))
 
+                logger.debug(f"[CUGA] Converted to {len(lc_messages)} LangChain messages")
                 await asyncio.sleep(0.5)
 
                 # 2. Build final response
@@ -274,7 +279,9 @@ class CugaComponent(ToolCallingAgentComponent):
                 last_event: StreamEvent | None = None
                 tool_run_id: str | None = None
                 # 3. Chain end event with AgentFinish
-                async for event in cuga_agent.run_task_generic_yield(eval_mode=False, goal=current_input):
+                async for event in cuga_agent.run_task_generic_yield(
+                    eval_mode=False, goal=current_input, chat_messages=lc_messages
+                ):
                     logger.debug(f"[CUGA] recieved event {event}")
                     if last_event is not None and tool_run_id is not None:
                         logger.debug(f"[CUGA] last event {last_event}")
@@ -350,12 +357,12 @@ class CugaComponent(ToolCallingAgentComponent):
             raise ValueError(msg)
 
         try:
-            llm_model, self.chat_history, self.tools = await self.get_agent_requirements()
-
-            # Create agent message for event processing
             from lfx.schema.content_block import ContentBlock
             from lfx.schema.message import MESSAGE_SENDER_AI
 
+            llm_model, self.chat_history, self.tools = await self.get_agent_requirements()
+
+            # Create agent message for event processing
             agent_message = Message(
                 sender=MESSAGE_SENDER_AI,
                 sender_name="Cuga",
@@ -368,7 +375,7 @@ class CugaComponent(ToolCallingAgentComponent):
             # This ensures streaming works even when not connected to ChatOutput
             if not self.is_connected_to_chat_output():
                 # When not connected to ChatOutput, assign ID upfront for streaming support
-                agent_message.data["id"] = str(uuid.uuid4())
+                agent_message.data["id"] = uuid.uuid4()
 
             # Get input text
             input_text = self.input_value.text if hasattr(self.input_value, "text") else str(self.input_value)
@@ -476,9 +483,14 @@ class CugaComponent(ToolCallingAgentComponent):
         """
         logger.debug("[CUGA] Retrieving chat history messages.")
         logger.debug(f"[CUGA] Session ID: {self.graph.session_id}")
+        logger.debug(f"[CUGA] n_messages: {self.n_messages}")
+        logger.debug(f"[CUGA] input_value: {self.input_value}")
+        logger.debug(f"[CUGA] input_value type: {type(self.input_value)}")
+        logger.debug(f"[CUGA] input_value id: {getattr(self.input_value, 'id', None)}")
+
         messages = (
             await MemoryComponent(**self.get_base_args())
-            .set(session_id=self.graph.session_id, order="Ascending", n_messages=self.n_messages)
+            .set(session_id=str(self.graph.session_id), order="Ascending", n_messages=self.n_messages)
             .retrieve_messages()
         )
         logger.debug(f"[CUGA] Retrieved {len(messages)} messages from memory")
@@ -678,7 +690,7 @@ class CugaComponent(ToolCallingAgentComponent):
                 "tools",
                 "input_value",
                 "add_current_date_tool",
-                "policies",
+                "instructions",
                 "agent_description",
                 "max_iterations",
                 "handle_parsing_errors",

lfx/components/data_source/api_request.py

@@ -493,11 +493,13 @@ class APIRequestComponent(Component):
                 return self.parse_curl(self.curl_input, build_config)
             return build_config
 
-        # print(f"Current mode: {field_value}")
         if field_value == "cURL":
             set_field_display(build_config, "curl_input", value=True)
             if build_config["curl_input"]["value"]:
-                build_config = self.parse_curl(build_config["curl_input"]["value"], build_config)
+                try:
+                    build_config = self.parse_curl(build_config["curl_input"]["value"], build_config)
+                except ValueError as e:
+                    self.log(f"Failed to parse cURL input: {e}")
         else:
             set_field_display(build_config, "curl_input", value=False)
 

lfx/components/docling/__init__.py

@@ -3,35 +3,69 @@ from __future__ import annotations
 from typing import TYPE_CHECKING, Any
 
 from lfx.components._importing import import_mod
+from lfx.utils.validate_cloud import is_astra_cloud_environment
 
 if TYPE_CHECKING:
-    from .chunk_docling_document import ChunkDoclingDocumentComponent
-    from .docling_inline import DoclingInlineComponent
-    from .docling_remote import DoclingRemoteComponent
-    from .export_docling_document import ExportDoclingDocumentComponent
+    from .chunk_docling_document import ChunkDoclingDocumentComponent  # noqa: F401
+    from .docling_inline import DoclingInlineComponent  # noqa: F401
+    from .docling_remote import DoclingRemoteComponent  # noqa: F401
+    from .export_docling_document import ExportDoclingDocumentComponent  # noqa: F401
 
-_dynamic_imports = {
+_all_components = [
+    "ChunkDoclingDocumentComponent",
+    "DoclingInlineComponent",
+    "DoclingRemoteComponent",
+    "ExportDoclingDocumentComponent",
+]
+
+_all_dynamic_imports = {
     "ChunkDoclingDocumentComponent": "chunk_docling_document",
     "DoclingInlineComponent": "docling_inline",
     "DoclingRemoteComponent": "docling_remote",
     "ExportDoclingDocumentComponent": "export_docling_document",
 }
 
-__all__ = [
+# Components that require local Docling/EasyOCR dependencies (disabled in cloud)
+_cloud_disabled_components = {
     "ChunkDoclingDocumentComponent",
     "DoclingInlineComponent",
-    "DoclingRemoteComponent",
     "ExportDoclingDocumentComponent",
-]
+}
+
+
+def _get_available_components() -> list[str]:
+    """Get list of available components, filtering out cloud-disabled ones."""
+    if is_astra_cloud_environment():
+        # Only show DoclingRemoteComponent (Docling Serve) in cloud
+        return [comp for comp in _all_components if comp not in _cloud_disabled_components]
+    return _all_components
+
+
+def _get_dynamic_imports() -> dict[str, str]:
+    """Get dynamic imports dict, filtering out cloud-disabled ones."""
+    if is_astra_cloud_environment():
+        # Only allow DoclingRemoteComponent (Docling Serve) in cloud
+        return {k: v for k, v in _all_dynamic_imports.items() if k not in _cloud_disabled_components}
+    return _all_dynamic_imports
+
+
+# Dynamically set __all__ and _dynamic_imports based on cloud environment
+__all__: list[str] = _get_available_components()  # noqa: PLE0605
+_dynamic_imports: dict[str, str] = _get_dynamic_imports()
 
 
 def __getattr__(attr_name: str) -> Any:
     """Lazily import docling components on attribute access."""
-    if attr_name not in _dynamic_imports:
+    # Check if component is available (not disabled in cloud)
+    if is_astra_cloud_environment() and attr_name in _cloud_disabled_components:
+        msg = f"module '{__name__}' has no attribute '{attr_name}'"
+        raise AttributeError(msg)
+
+    if attr_name not in _all_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)
+        result = import_mod(attr_name, _all_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
@@ -40,4 +74,4 @@ def __getattr__(attr_name: str) -> Any:
 
 
 def __dir__() -> list[str]:
-    return list(__all__)
+    return _get_available_components()

lfx/components/docling/chunk_docling_document.py

@@ -115,7 +115,9 @@ class ChunkDoclingDocumentComponent(Component):
         return [Data(text=doc.page_content, data=doc.metadata) for doc in docs]
 
     def chunk_documents(self) -> DataFrame:
-        documents = extract_docling_documents(self.data_inputs, self.doc_key)
+        documents, warning = extract_docling_documents(self.data_inputs, self.doc_key)
+        if warning:
+            self.status = warning
 
         chunker: BaseChunker
         if self.chunker == "HybridChunker":

lfx/components/docling/docling_inline.py

@@ -1,6 +1,6 @@
+import queue
+import threading
 import time
-from multiprocessing import Queue, get_context
-from queue import Empty
 
 from lfx.base.data import BaseFileComponent
 from lfx.base.data.docling_utils import _serialize_pydantic_model, docling_worker
@@ -92,60 +92,57 @@ class DoclingInlineComponent(BaseFileComponent):
         *BaseFileComponent.get_base_outputs(),
     ]
 
-    def _wait_for_result_with_process_monitoring(self, queue: Queue, proc, timeout: int = 300):
-        """Wait for result from queue while monitoring process health.
+    def _wait_for_result_with_thread_monitoring(
+        self, result_queue: queue.Queue, thread: threading.Thread, timeout: int = 300
+    ):
+        """Wait for result from queue while monitoring thread health.
 
-        Handles cases where process crashes without sending result.
+        Handles cases where thread crashes without sending result.
         """
         start_time = time.time()
 
         while time.time() - start_time < timeout:
-            # Check if process is still alive
-            if not proc.is_alive():
-                # Process died, try to get any result it might have sent
+            # Check if thread is still alive
+            if not thread.is_alive():
+                # Thread finished, try to get any result it might have sent
                 try:
-                    result = queue.get_nowait()
-                except Empty:
-                    # Process died without sending result
-                    msg = f"Worker process crashed unexpectedly without producing result. Exit code: {proc.exitcode}"
+                    result = result_queue.get_nowait()
+                except queue.Empty:
+                    # Thread finished without sending result
+                    msg = "Worker thread crashed unexpectedly without producing result."
                     raise RuntimeError(msg) from None
                 else:
-                    self.log("Process completed and result retrieved")
+                    self.log("Thread completed and result retrieved")
                     return result
 
             # Poll the queue instead of blocking
             try:
-                result = queue.get(timeout=1)
-            except Empty:
+                result = result_queue.get(timeout=1)
+            except queue.Empty:
                 # No result yet, continue monitoring
                 continue
             else:
-                self.log("Result received from worker process")
+                self.log("Result received from worker thread")
                 return result
 
         # Overall timeout reached
-        msg = f"Process timed out after {timeout} seconds"
+        msg = f"Thread timed out after {timeout} seconds"
         raise TimeoutError(msg)
 
-    def _terminate_process_gracefully(self, proc, timeout_terminate: int = 10, timeout_kill: int = 5):
-        """Terminate process gracefully with escalating signals.
+    def _stop_thread_gracefully(self, thread: threading.Thread, timeout: int = 10):
+        """Wait for thread to complete gracefully.
 
-        First tries SIGTERM, then SIGKILL if needed.
+        Note: Python threads cannot be forcefully killed, so we just wait.
+        The thread should respond to shutdown signals via the queue.
         """
-        if not proc.is_alive():
+        if not thread.is_alive():
             return
 
-        self.log("Attempting graceful process termination with SIGTERM")
-        proc.terminate()  # Send SIGTERM
-        proc.join(timeout=timeout_terminate)
+        self.log("Waiting for thread to complete gracefully")
+        thread.join(timeout=timeout)
 
-        if proc.is_alive():
-            self.log("Process didn't respond to SIGTERM, using SIGKILL")
-            proc.kill()  # Send SIGKILL
-            proc.join(timeout=timeout_kill)
-
-            if proc.is_alive():
-                self.log("Warning: Process still alive after SIGKILL")
+        if thread.is_alive():
+            self.log("Warning: Thread still alive after timeout")
 
     def process_files(self, file_list: list[BaseFileComponent.BaseFile]) -> list[BaseFileComponent.BaseFile]:
         try:
@@ -167,44 +164,37 @@ class DoclingInlineComponent(BaseFileComponent):
         if self.pic_desc_llm is not None:
             pic_desc_config = _serialize_pydantic_model(self.pic_desc_llm)
 
-        ctx = get_context("spawn")
-        queue: Queue = ctx.Queue()
-        proc = ctx.Process(
+        # Use threading instead of multiprocessing for memory sharing
+        # This enables the global DocumentConverter cache to work across runs
+        result_queue: queue.Queue = queue.Queue()
+        thread = threading.Thread(
             target=docling_worker,
             kwargs={
                 "file_paths": file_paths,
-                "queue": queue,
+                "queue": result_queue,
                 "pipeline": self.pipeline,
                 "ocr_engine": self.ocr_engine,
                 "do_picture_classification": self.do_picture_classification,
                 "pic_desc_config": pic_desc_config,
                 "pic_desc_prompt": self.pic_desc_prompt,
             },
+            daemon=False,  # Allow thread to complete even if main thread exits
         )
 
         result = None
-        proc.start()
+        thread.start()
 
         try:
-            result = self._wait_for_result_with_process_monitoring(queue, proc, timeout=300)
+            result = self._wait_for_result_with_thread_monitoring(result_queue, thread, timeout=300)
         except KeyboardInterrupt:
-            self.log("Docling process cancelled by user")
+            self.log("Docling thread cancelled by user")
             result = []
         except Exception as e:
             self.log(f"Error during processing: {e}")
             raise
         finally:
-            # Improved cleanup with graceful termination
-            try:
-                self._terminate_process_gracefully(proc)
-            finally:
-                # Always close and cleanup queue resources
-                try:
-                    queue.close()
-                    queue.join_thread()
-                except Exception as e:  # noqa: BLE001
-                    # Ignore cleanup errors, but log them
-                    self.log(f"Warning: Error during queue cleanup - {e}")
+            # Wait for thread to complete gracefully
+            self._stop_thread_gracefully(thread)
 
         # Enhanced error checking with dependency-specific handling
         if isinstance(result, dict) and "error" in result:

lfx/components/docling/export_docling_document.py

@@ -86,7 +86,9 @@ class ExportDoclingDocumentComponent(Component):
         return build_config
 
     def export_document(self) -> list[Data]:
-        documents = extract_docling_documents(self.data_inputs, self.doc_key)
+        documents, warning = extract_docling_documents(self.data_inputs, self.doc_key)
+        if warning:
+            self.status = warning
 
         results: list[Data] = []
         try: