langflow-base-nightly 0.5.0.dev36__py3-none-any.whl → 0.5.0.dev38__py3-none-any.whl

langflow/base/data/docling_utils.py

@@ -1,4 +1,10 @@
+import signal
+import sys
+import traceback
+from contextlib import suppress
+
 from docling_core.types.doc import DoclingDocument
+from loguru import logger
 
 from langflow.schema.data import Data
 from langflow.schema.dataframe import DataFrame
@@ -49,3 +55,191 @@ def extract_docling_documents(data_inputs: Data | list[Data] | DataFrame, doc_ke
                 msg = f"Invalid input type in collection: {e}"
                 raise TypeError(msg) from e
     return documents
+
+
+def docling_worker(file_paths: list[str], queue, pipeline: str, ocr_engine: str):
+    """Worker function for processing files with Docling in a separate process."""
+    # Signal handling for graceful shutdown
+    shutdown_requested = False
+
+    def signal_handler(signum: int, frame) -> None:  # noqa: ARG001
+        """Handle shutdown signals gracefully."""
+        nonlocal shutdown_requested
+        signal_names: dict[int, str] = {signal.SIGTERM: "SIGTERM", signal.SIGINT: "SIGINT"}
+        signal_name = signal_names.get(signum, f"signal {signum}")
+
+        logger.debug(f"Docling worker received {signal_name}, initiating graceful shutdown...")
+        shutdown_requested = True
+
+        # Send shutdown notification to parent process
+        with suppress(Exception):
+            queue.put({"error": f"Worker interrupted by {signal_name}", "shutdown": True})
+
+        # Exit gracefully
+        sys.exit(0)
+
+    def check_shutdown() -> None:
+        """Check if shutdown was requested and exit if so."""
+        if shutdown_requested:
+            logger.info("Shutdown requested, exiting worker...")
+
+            with suppress(Exception):
+                queue.put({"error": "Worker shutdown requested", "shutdown": True})
+
+            sys.exit(0)
+
+    # Register signal handlers early
+    try:
+        signal.signal(signal.SIGTERM, signal_handler)
+        signal.signal(signal.SIGINT, signal_handler)
+        logger.debug("Signal handlers registered for graceful shutdown")
+    except (OSError, ValueError) as e:
+        # Some signals might not be available on all platforms
+        logger.warning(f"Warning: Could not register signal handlers: {e}")
+
+    # Check for shutdown before heavy imports
+    check_shutdown()
+
+    try:
+        from docling.datamodel.base_models import ConversionStatus, InputFormat
+        from docling.datamodel.pipeline_options import OcrOptions, PdfPipelineOptions, VlmPipelineOptions
+        from docling.document_converter import DocumentConverter, FormatOption, PdfFormatOption
+        from docling.models.factories import get_ocr_factory
+        from docling.pipeline.vlm_pipeline import VlmPipeline
+
+        # Check for shutdown after imports
+        check_shutdown()
+        logger.debug("Docling dependencies loaded successfully")
+
+    except ModuleNotFoundError:
+        msg = (
+            "Docling is an optional dependency of Langflow. "
+            "Install with `uv pip install 'langflow[docling]'` "
+            "or refer to the documentation"
+        )
+        queue.put({"error": msg})
+        return
+    except ImportError as e:
+        # A different import failed (e.g., a transitive dependency); preserve details.
+        queue.put({"error": f"Failed to import a Docling dependency: {e}"})
+        return
+    except KeyboardInterrupt:
+        logger.warning("KeyboardInterrupt during imports, exiting...")
+        queue.put({"error": "Worker interrupted during imports", "shutdown": True})
+        return
+
+    # Configure the standard PDF pipeline
+    def _get_standard_opts() -> PdfPipelineOptions:
+        check_shutdown()  # Check before heavy operations
+
+        pipeline_options = PdfPipelineOptions()
+        pipeline_options.do_ocr = ocr_engine != ""
+        if pipeline_options.do_ocr:
+            ocr_factory = get_ocr_factory(
+                allow_external_plugins=False,
+            )
+
+            ocr_options: OcrOptions = ocr_factory.create_options(
+                kind=ocr_engine,
+            )
+            pipeline_options.ocr_options = ocr_options
+        return pipeline_options
+
+    # Configure the VLM pipeline
+    def _get_vlm_opts() -> VlmPipelineOptions:
+        check_shutdown()  # Check before heavy operations
+        return VlmPipelineOptions()
+
+    # Configure the main format options and create the DocumentConverter()
+    def _get_converter() -> DocumentConverter:
+        check_shutdown()  # Check before heavy operations
+
+        if pipeline == "standard":
+            pdf_format_option = PdfFormatOption(
+                pipeline_options=_get_standard_opts(),
+            )
+        elif pipeline == "vlm":
+            pdf_format_option = PdfFormatOption(pipeline_cls=VlmPipeline, pipeline_options=_get_vlm_opts())
+        else:
+            msg = f"Unknown pipeline: {pipeline!r}"
+            raise ValueError(msg)
+
+        format_options: dict[InputFormat, FormatOption] = {
+            InputFormat.PDF: pdf_format_option,
+            InputFormat.IMAGE: pdf_format_option,
+        }
+
+        return DocumentConverter(format_options=format_options)
+
+    try:
+        # Check for shutdown before creating converter (can be slow)
+        check_shutdown()
+        logger.info(f"Initializing {pipeline} pipeline with OCR: {ocr_engine or 'disabled'}")
+
+        converter = _get_converter()
+
+        # Check for shutdown before processing files
+        check_shutdown()
+        logger.info(f"Starting to process {len(file_paths)} files...")
+
+        # Process files with periodic shutdown checks
+        results = []
+        for i, file_path in enumerate(file_paths):
+            # Check for shutdown before processing each file
+            check_shutdown()
+
+            logger.debug(f"Processing file {i + 1}/{len(file_paths)}: {file_path}")
+
+            try:
+                # Process single file (we can't easily interrupt convert_all)
+                single_result = converter.convert_all([file_path])
+                results.extend(single_result)
+
+                # Check for shutdown after each file
+                check_shutdown()
+
+            except (OSError, ValueError, RuntimeError, ImportError) as file_error:
+                # Handle specific file processing errors
+                logger.error(f"Error processing file {file_path}: {file_error}")
+                # Continue with other files, but check for shutdown
+                check_shutdown()
+            except Exception as file_error:  # noqa: BLE001
+                # Catch any other unexpected errors to prevent worker crash
+                logger.error(f"Unexpected error processing file {file_path}: {file_error}")
+                # Continue with other files, but check for shutdown
+                check_shutdown()
+
+        # Final shutdown check before sending results
+        check_shutdown()
+
+        # Process the results while maintaining the original structure
+        processed_data = [
+            {"document": res.document, "file_path": str(res.input.file), "status": res.status.name}
+            if res.status == ConversionStatus.SUCCESS
+            else None
+            for res in results
+        ]
+
+        logger.info(f"Successfully processed {len([d for d in processed_data if d])} files")
+        queue.put(processed_data)
+
+    except KeyboardInterrupt:
+        logger.warning("KeyboardInterrupt during processing, exiting gracefully...")
+        queue.put({"error": "Worker interrupted during processing", "shutdown": True})
+        return
+    except Exception as e:  # noqa: BLE001
+        if shutdown_requested:
+            logger.exception("Exception occurred during shutdown, exiting...")
+            return
+
+        # Send any processing error to the main process with traceback
+        error_info = {"error": str(e), "traceback": traceback.format_exc()}
+        logger.error(f"Error in worker: {error_info}")
+        queue.put(error_info)
+    finally:
+        logger.info("Docling worker finishing...")
+        # Ensure we don't leave any hanging processes
+        if shutdown_requested:
+            logger.debug("Worker shutdown completed")
+        else:
+            logger.debug("Worker completed normally")

langflow/base/data/kb_utils.py

@@ -1,5 +1,10 @@
 import math
 from collections import Counter
+from pathlib import Path
+from uuid import UUID
+
+from langflow.services.database.models.user.crud import get_user_by_id
+from langflow.services.deps import session_scope
 
 
 def compute_tfidf(documents: list[str], query_terms: list[str]) -> list[float]:
@@ -102,3 +107,31 @@ def compute_bm25(documents: list[str], query_terms: list[str], k1: float = 1.2,
         scores.append(doc_score)
 
     return scores
+
+
+async def get_knowledge_bases(kb_root: Path, user_id: UUID | str) -> list[str]:
+    """Retrieve a list of available knowledge bases.
+
+    Returns:
+        A list of knowledge base names.
+    """
+    if not kb_root.exists():
+        return []
+
+    # Get the current user
+    async with session_scope() as db:
+        if not user_id:
+            msg = "User ID is required for fetching knowledge bases."
+            raise ValueError(msg)
+        user_id = UUID(user_id) if isinstance(user_id, str) else user_id
+        current_user = await get_user_by_id(db, user_id)
+        if not current_user:
+            msg = f"User with ID {user_id} not found."
+            raise ValueError(msg)
+        kb_user = current_user.username
+    kb_path = kb_root / kb_user
+
+    if not kb_path.exists():
+        return []
+
+    return [str(d.name) for d in kb_path.iterdir() if not d.name.startswith(".") and d.is_dir()]

langflow/base/embeddings/aiml_embeddings.py

@@ -2,10 +2,10 @@ import concurrent.futures
 import json
 
 import httpx
-from loguru import logger
 from pydantic import BaseModel, SecretStr
 
 from langflow.field_typing import Embeddings
+from langflow.logging.logger import logger
 
 
 class AIMLEmbeddingsImpl(BaseModel, Embeddings):

langflow/base/flow_processing/utils.py

@@ -1,6 +1,5 @@
-from loguru import logger
-
 from langflow.graph.schema import ResultData, RunOutputs
+from langflow.logging.logger import logger
 from langflow.schema.data import Data
 from langflow.schema.message import Message
 

langflow/base/io/__init__.py

@@ -1 +0,0 @@
-# noqa: A005

langflow/base/langwatch/utils.py

@@ -2,7 +2,8 @@ from functools import lru_cache
 from typing import Any
 
 import httpx
-from loguru import logger
+
+from langflow.logging.logger import logger
 
 
 @lru_cache(maxsize=1)

langflow/base/mcp/util.py

@@ -15,12 +15,12 @@ import httpx
 from anyio import ClosedResourceError
 from httpx import codes as httpx_codes
 from langchain_core.tools import StructuredTool
-from loguru import logger
 from mcp import ClientSession
 from mcp.shared.exceptions import McpError
 from pydantic import BaseModel, Field, create_model
 from sqlmodel import select
 
+from langflow.logging.logger import logger
 from langflow.services.database.models.flow.model import Flow
 from langflow.services.deps import get_settings_service
 
@@ -214,7 +214,7 @@ def create_tool_coroutine(tool_name: str, arg_schema: type[BaseModel], client) -
         try:
             return await client.run_tool(tool_name, arguments=validated.model_dump())
         except Exception as e:
-            logger.error(f"Tool '{tool_name}' execution failed: {e}")
+            await logger.aerror(f"Tool '{tool_name}' execution failed: {e}")
             # Re-raise with more context
             msg = f"Tool '{tool_name}' execution failed: {e}"
             raise ValueError(msg) from e
@@ -264,7 +264,7 @@ def get_unique_name(base_name, max_length, existing_names):
         i += 1
 
 
-async def get_flow_snake_case(flow_name: str, user_id: str, session, is_action: bool | None = None) -> Flow | None:
+async def get_flow_snake_case(flow_name: str, user_id: str, session, *, is_action: bool | None = None) -> Flow | None:
     uuid_user_id = UUID(user_id) if isinstance(user_id, str) else user_id
     stmt = select(Flow).where(Flow.user_id == uuid_user_id).where(Flow.is_component == False)  # noqa: E712
     flows = (await session.exec(stmt)).all()
@@ -506,7 +506,7 @@ class MCPSessionManager:
                 break
             except (RuntimeError, KeyError, ClosedResourceError, ValueError, asyncio.TimeoutError) as e:
                 # Handle common recoverable errors without stopping the cleanup loop
-                logger.warning(f"Error in periodic cleanup: {e}")
+                await logger.awarning(f"Error in periodic cleanup: {e}")
 
     async def _cleanup_idle_sessions(self):
         """Clean up sessions that have been idle for too long."""
@@ -523,7 +523,7 @@ class MCPSessionManager:
 
             # Clean up idle sessions
             for session_id in sessions_to_remove:
-                logger.info(f"Cleaning up idle session {session_id} for server {server_key}")
+                await logger.ainfo(f"Cleaning up idle session {session_id} for server {server_key}")
                 await self._cleanup_session_by_id(server_key, session_id)
 
             # Remove server entry if no sessions left
@@ -561,7 +561,7 @@ class MCPSessionManager:
             # Use a shorter timeout for the connectivity test to fail fast
             response = await asyncio.wait_for(session.list_tools(), timeout=3.0)
         except (asyncio.TimeoutError, ConnectionError, OSError, ValueError) as e:
-            logger.debug(f"Session connectivity test failed (standard error): {e}")
+            await logger.adebug(f"Session connectivity test failed (standard error): {e}")
             return False
         except Exception as e:
             # Handle MCP-specific errors that might not be in the standard list
@@ -574,27 +574,27 @@ class MCPSessionManager:
                 or "Transport closed" in error_str
                 or "Stream closed" in error_str
             ):
-                logger.debug(f"Session connectivity test failed (MCP connection error): {e}")
+                await logger.adebug(f"Session connectivity test failed (MCP connection error): {e}")
                 return False
             # Re-raise unexpected errors
-            logger.warning(f"Unexpected error in connectivity test: {e}")
+            await logger.awarning(f"Unexpected error in connectivity test: {e}")
             raise
         else:
             # Validate that we got a meaningful response
             if response is None:
-                logger.debug("Session connectivity test failed: received None response")
+                await logger.adebug("Session connectivity test failed: received None response")
                 return False
             try:
                 # Check if we can access the tools list (even if empty)
                 tools = getattr(response, "tools", None)
                 if tools is None:
-                    logger.debug("Session connectivity test failed: no tools attribute in response")
+                    await logger.adebug("Session connectivity test failed: no tools attribute in response")
                     return False
             except (AttributeError, TypeError) as e:
-                logger.debug(f"Session connectivity test failed while validating response: {e}")
+                await logger.adebug(f"Session connectivity test failed while validating response: {e}")
                 return False
             else:
-                logger.debug(f"Session connectivity test passed: found {len(tools)} tools")
+                await logger.adebug(f"Session connectivity test passed: found {len(tools)} tools")
                 return True
 
     async def get_session(self, context_id: str, connection_params, transport_type: str):
@@ -625,32 +625,32 @@ class MCPSessionManager:
 
                 # Quick health check
                 if await self._validate_session_connectivity(session):
-                    logger.debug(f"Reusing existing session {session_id} for server {server_key}")
+                    await logger.adebug(f"Reusing existing session {session_id} for server {server_key}")
                     # record mapping & bump ref-count for backwards compatibility
                     self._context_to_session[context_id] = (server_key, session_id)
                     self._session_refcount[(server_key, session_id)] = (
                         self._session_refcount.get((server_key, session_id), 0) + 1
                     )
                     return session
-                logger.info(f"Session {session_id} for server {server_key} failed health check, cleaning up")
+                await logger.ainfo(f"Session {session_id} for server {server_key} failed health check, cleaning up")
                 await self._cleanup_session_by_id(server_key, session_id)
             else:
                 # Task is done, clean up
-                logger.info(f"Session {session_id} for server {server_key} task is done, cleaning up")
+                await logger.ainfo(f"Session {session_id} for server {server_key} task is done, cleaning up")
                 await self._cleanup_session_by_id(server_key, session_id)
 
         # Check if we've reached the maximum number of sessions for this server
         if len(sessions) >= MAX_SESSIONS_PER_SERVER:
             # Remove the oldest session
             oldest_session_id = min(sessions.keys(), key=lambda x: sessions[x]["last_used"])
-            logger.info(
+            await logger.ainfo(
                 f"Maximum sessions reached for server {server_key}, removing oldest session {oldest_session_id}"
             )
             await self._cleanup_session_by_id(server_key, oldest_session_id)
 
         # Create new session
         session_id = f"{server_key}_{len(sessions)}"
-        logger.info(f"Creating new session {session_id} for server {server_key}")
+        await logger.ainfo(f"Creating new session {session_id} for server {server_key}")
 
         if transport_type == "stdio":
             session, task = await self._create_stdio_session(session_id, connection_params)
@@ -700,7 +700,7 @@ class MCPSessionManager:
                         try:
                             await event.wait()
                         except asyncio.CancelledError:
-                            logger.info(f"Session {session_id} is shutting down")
+                            await logger.ainfo(f"Session {session_id} is shutting down")
             except Exception as e:  # noqa: BLE001
                 if not session_future.done():
                     session_future.set_exception(e)
@@ -723,7 +723,7 @@ class MCPSessionManager:
                     await task
             self._background_tasks.discard(task)
             msg = f"Timeout waiting for STDIO session {session_id} to initialize"
-            logger.error(msg)
+            await logger.aerror(msg)
             raise ValueError(msg) from timeout_err
 
         return session, task
@@ -759,7 +759,7 @@ class MCPSessionManager:
                         try:
                             await event.wait()
                         except asyncio.CancelledError:
-                            logger.info(f"Session {session_id} is shutting down")
+                            await logger.ainfo(f"Session {session_id} is shutting down")
             except Exception as e:  # noqa: BLE001
                 if not session_future.done():
                     session_future.set_exception(e)
@@ -782,7 +782,7 @@ class MCPSessionManager:
                     await task
             self._background_tasks.discard(task)
             msg = f"Timeout waiting for SSE session {session_id} to initialize"
-            logger.error(msg)
+            await logger.aerror(msg)
             raise ValueError(msg) from timeout_err
 
         return session, task
@@ -813,9 +813,9 @@ class MCPSessionManager:
                 if hasattr(session, "aclose"):
                     try:
                         await session.aclose()
-                        logger.debug("Successfully closed session %s using aclose()", session_id)
+                        await logger.adebug("Successfully closed session %s using aclose()", session_id)
                     except Exception as e:  # noqa: BLE001
-                        logger.debug("Error closing session %s with aclose(): %s", session_id, e)
+                        await logger.adebug("Error closing session %s with aclose(): %s", session_id, e)
 
                 # If no aclose, try regular close method
                 elif hasattr(session, "close"):
@@ -824,18 +824,20 @@ class MCPSessionManager:
                         if inspect.iscoroutinefunction(session.close):
                             # It's an async method
                             await session.close()
-                            logger.debug("Successfully closed session %s using async close()", session_id)
+                            await logger.adebug("Successfully closed session %s using async close()", session_id)
                         else:
                             # Try calling it and check if result is awaitable
                             close_result = session.close()
                             if inspect.isawaitable(close_result):
                                 await close_result
-                                logger.debug("Successfully closed session %s using awaitable close()", session_id)
+                                await logger.adebug(
+                                    "Successfully closed session %s using awaitable close()", session_id
+                                )
                             else:
                                 # It's a synchronous close
-                                logger.debug("Successfully closed session %s using sync close()", session_id)
+                                await logger.adebug("Successfully closed session %s using sync close()", session_id)
                     except Exception as e:  # noqa: BLE001
-                        logger.debug("Error closing session %s with close(): %s", session_id, e)
+                        await logger.adebug("Error closing session %s with close(): %s", session_id, e)
 
             # Cancel the background task which will properly close the session
             if "task" in session_info:
@@ -845,9 +847,9 @@ class MCPSessionManager:
                     try:
                         await task
                     except asyncio.CancelledError:
-                        logger.info(f"Cancelled task for session {session_id}")
+                        await logger.ainfo(f"Cancelled task for session {session_id}")
         except Exception as e:  # noqa: BLE001
-            logger.warning(f"Error cleaning up session {session_id}: {e}")
+            await logger.awarning(f"Error cleaning up session {session_id}: {e}")
         finally:
             # Remove from sessions dict
             del sessions[session_id]
@@ -900,7 +902,7 @@ class MCPSessionManager:
         """
         mapping = self._context_to_session.get(context_id)
         if not mapping:
-            logger.debug(f"No session mapping found for context_id {context_id}")
+            await logger.adebug(f"No session mapping found for context_id {context_id}")
             return
 
         server_key, session_id = mapping
@@ -1031,7 +1033,7 @@ class MCPStdioClient:
 
         for attempt in range(max_retries):
             try:
-                logger.debug(f"Attempting to run tool '{tool_name}' (attempt {attempt + 1}/{max_retries})")
+                await logger.adebug(f"Attempting to run tool '{tool_name}' (attempt {attempt + 1}/{max_retries})")
                 # Get or create persistent session
                 session = await self._get_or_create_session()
 
@@ -1041,7 +1043,7 @@ class MCPStdioClient:
                 )
             except Exception as e:
                 current_error_type = type(e).__name__
-                logger.warning(f"Tool '{tool_name}' failed on attempt {attempt + 1}: {current_error_type} - {e}")
+                await logger.awarning(f"Tool '{tool_name}' failed on attempt {attempt + 1}: {current_error_type} - {e}")
 
                 # Import specific MCP error types for detection
                 try:
@@ -1056,14 +1058,14 @@ class MCPStdioClient:
 
                 # If we're getting the same error type repeatedly, don't retry
                 if last_error_type == current_error_type and attempt > 0:
-                    logger.error(f"Repeated {current_error_type} error for tool '{tool_name}', not retrying")
+                    await logger.aerror(f"Repeated {current_error_type} error for tool '{tool_name}', not retrying")
                     break
 
                 last_error_type = current_error_type
 
                 # If it's a connection error (ClosedResourceError or MCP connection closed) and we have retries left
                 if (is_closed_resource_error or is_mcp_connection_error) and attempt < max_retries - 1:
-                    logger.warning(
+                    await logger.awarning(
                         f"MCP session connection issue for tool '{tool_name}', retrying with fresh session..."
                     )
                     # Clean up the dead session
@@ -1076,7 +1078,7 @@ class MCPStdioClient:
 
                 # If it's a timeout error and we have retries left, try once more
                 if is_timeout_error and attempt < max_retries - 1:
-                    logger.warning(f"Tool '{tool_name}' timed out, retrying...")
+                    await logger.awarning(f"Tool '{tool_name}' timed out, retrying...")
                     # Don't clean up session for timeouts, might just be a slow response
                     await asyncio.sleep(1.0)
                     continue
@@ -1089,7 +1091,7 @@ class MCPStdioClient:
                     or is_timeout_error
                 ):
                     msg = f"Failed to run tool '{tool_name}' after {attempt + 1} attempts: {e}"
-                    logger.error(msg)
+                    await logger.aerror(msg)
                     # Clean up failed session from cache
                     if self._session_context and self._component_cache:
                         cache_key = f"mcp_session_stdio_{self._session_context}"
@@ -1099,12 +1101,12 @@ class MCPStdioClient:
                 # Re-raise unexpected errors
                 raise
             else:
-                logger.debug(f"Tool '{tool_name}' completed successfully")
+                await logger.adebug(f"Tool '{tool_name}' completed successfully")
                 return result
 
         # This should never be reached due to the exception handling above
         msg = f"Failed to run tool '{tool_name}': Maximum retries exceeded with repeated {last_error_type} errors"
-        logger.error(msg)
+        await logger.aerror(msg)
         raise ValueError(msg)
 
     async def disconnect(self):
@@ -1213,7 +1215,7 @@ class MCPSseClient:
                     return response.headers.get("Location", url)
                 # Don't treat 404 as an error here - let the main connection handle it
         except (httpx.RequestError, httpx.HTTPError) as e:
-            logger.warning(f"Error checking redirects: {e}")
+            await logger.awarning(f"Error checking redirects: {e}")
         return url
 
     async def _connect_to_server(
@@ -1336,7 +1338,7 @@ class MCPSseClient:
 
         for attempt in range(max_retries):
             try:
-                logger.debug(f"Attempting to run tool '{tool_name}' (attempt {attempt + 1}/{max_retries})")
+                await logger.adebug(f"Attempting to run tool '{tool_name}' (attempt {attempt + 1}/{max_retries})")
                 # Get or create persistent session
                 session = await self._get_or_create_session()
 
@@ -1349,7 +1351,7 @@ class MCPSseClient:
                 )
             except Exception as e:
                 current_error_type = type(e).__name__
-                logger.warning(f"Tool '{tool_name}' failed on attempt {attempt + 1}: {current_error_type} - {e}")
+                await logger.awarning(f"Tool '{tool_name}' failed on attempt {attempt + 1}: {current_error_type} - {e}")
 
                 # Import specific MCP error types for detection
                 try:
@@ -1367,14 +1369,14 @@ class MCPSseClient:
 
                 # If we're getting the same error type repeatedly, don't retry
                 if last_error_type == current_error_type and attempt > 0:
-                    logger.error(f"Repeated {current_error_type} error for tool '{tool_name}', not retrying")
+                    await logger.aerror(f"Repeated {current_error_type} error for tool '{tool_name}', not retrying")
                     break
 
                 last_error_type = current_error_type
 
                 # If it's a connection error (ClosedResourceError or MCP connection closed) and we have retries left
                 if (is_closed_resource_error or is_mcp_connection_error) and attempt < max_retries - 1:
-                    logger.warning(
+                    await logger.awarning(
                         f"MCP session connection issue for tool '{tool_name}', retrying with fresh session..."
                     )
                     # Clean up the dead session
@@ -1387,7 +1389,7 @@ class MCPSseClient:
 
                 # If it's a timeout error and we have retries left, try once more
                 if is_timeout_error and attempt < max_retries - 1:
-                    logger.warning(f"Tool '{tool_name}' timed out, retrying...")
+                    await logger.awarning(f"Tool '{tool_name}' timed out, retrying...")
                     # Don't clean up session for timeouts, might just be a slow response
                     await asyncio.sleep(1.0)
                     continue
@@ -1400,7 +1402,7 @@ class MCPSseClient:
                     or is_timeout_error
                 ):
                     msg = f"Failed to run tool '{tool_name}' after {attempt + 1} attempts: {e}"
-                    logger.error(msg)
+                    await logger.aerror(msg)
                     # Clean up failed session from cache
                     if self._session_context and self._component_cache:
                         cache_key = f"mcp_session_sse_{self._session_context}"
@@ -1410,12 +1412,12 @@ class MCPSseClient:
                 # Re-raise unexpected errors
                 raise
             else:
-                logger.debug(f"Tool '{tool_name}' completed successfully")
+                await logger.adebug(f"Tool '{tool_name}' completed successfully")
                 return result
 
         # This should never be reached due to the exception handling above
         msg = f"Failed to run tool '{tool_name}': Maximum retries exceeded with repeated {last_error_type} errors"
-        logger.error(msg)
+        await logger.aerror(msg)
         raise ValueError(msg)
 
     async def disconnect(self):

langflow/base/models/model.py

@@ -252,7 +252,7 @@ class LCModelComponent(Component):
             if stream:
                 lf_message, result = await self._handle_stream(runnable, inputs)
             else:
-                message = runnable.invoke(inputs)
+                message = await runnable.ainvoke(inputs)
                 result = message.content if hasattr(message, "content") else message
             if isinstance(message, AIMessage):
                 status_message = self.build_status_message(message)
@@ -288,7 +288,7 @@ class LCModelComponent(Component):
             else:
                 session_id = None
             model_message = Message(
-                text=runnable.stream(inputs),
+                text=runnable.astream(inputs),
                 sender=MESSAGE_SENDER_AI,
                 sender_name="AI",
                 properties={"icon": self.icon, "state": "partial"},
@@ -298,7 +298,7 @@ class LCModelComponent(Component):
             lf_message = await self.send_message(model_message)
             result = lf_message.text
         else:
-            message = runnable.invoke(inputs)
+            message = await runnable.ainvoke(inputs)
             result = message.content if hasattr(message, "content") else message
         return lf_message, result