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

langflow/api/v1/voice_mode.py

@@ -33,11 +33,7 @@ from langflow.services.database.models.flow.model import Flow
 from langflow.services.database.models.message.model import MessageTable
 from langflow.services.database.models.user.model import User
 from langflow.services.deps import get_variable_service, session_scope
-from langflow.utils.voice_utils import (
-    BYTES_PER_24K_FRAME,
-    VAD_SAMPLE_RATE_16K,
-    resample_24k_to_16k,
-)
+from langflow.utils.voice_utils import BYTES_PER_24K_FRAME, VAD_SAMPLE_RATE_16K, resample_24k_to_16k
 
 router = APIRouter(prefix="/voice", tags=["Voice"])
 
@@ -121,8 +117,8 @@ async def authenticate_and_get_openai_key(session: DbSession, user: User, websoc
             )
             return None, None
     except Exception as e:  # noqa: BLE001
-        logger.error(f"Error with API key: {e}")
-        logger.error(traceback.format_exc())
+        await logger.aerror(f"Error with API key: {e}")
+        await logger.aerror(traceback.format_exc())
         return None, None
     return user, openai_key
 
@@ -185,13 +181,13 @@ class ElevenLabsClientManager:
                         session=session,
                     )
                 except (InvalidToken, ValueError) as e:
-                    logger.error(f"Error with ElevenLabs API key: {e}")
+                    await logger.aerror(f"Error with ElevenLabs API key: {e}")
                     cls._api_key = os.getenv("ELEVENLABS_API_KEY", "")
                     if not cls._api_key:
-                        logger.error("ElevenLabs API key not found")
+                        await logger.aerror("ElevenLabs API key not found")
                         return None
                 except (KeyError, AttributeError, sqlalchemy.exc.SQLAlchemyError) as e:
-                    logger.error(f"Exception getting ElevenLabs API key: {e}")
+                    await logger.aerror(f"Exception getting ElevenLabs API key: {e}")
                     return None
 
             if cls._api_key:
@@ -310,25 +306,25 @@ async def process_message_queue(queue_key, session):
 
             try:
                 await aadd_messagetables([message], session)
-                logger.debug(f"Added message to DB: {message.text[:30]}...")
+                await logger.adebug(f"Added message to DB: {message.text[:30]}...")
             except ValueError as e:
-                logger.error(f"Error saving message to database (ValueError): {e}")
-                logger.error(traceback.format_exc())
+                await logger.aerror(f"Error saving message to database (ValueError): {e}")
+                await logger.aerror(traceback.format_exc())
             except sqlalchemy.exc.SQLAlchemyError as e:
-                logger.error(f"Error saving message to database (SQLAlchemyError): {e}")
-                logger.error(traceback.format_exc())
+                await logger.aerror(f"Error saving message to database (SQLAlchemyError): {e}")
+                await logger.aerror(traceback.format_exc())
             except (KeyError, AttributeError, TypeError) as e:
                 # More specific exceptions instead of blind Exception
-                logger.error(f"Error saving message to database: {e}")
-                logger.error(traceback.format_exc())
+                await logger.aerror(f"Error saving message to database: {e}")
+                await logger.aerror(traceback.format_exc())
             finally:
                 message_queues[queue_key].task_done()
 
             if message_queues[queue_key].empty():
                 break
     except Exception as e:  # noqa: BLE001
-        logger.debug(f"Message queue processor for {queue_key} was cancelled: {e}")
-        logger.error(traceback.format_exc())
+        await logger.adebug(f"Message queue processor for {queue_key} was cancelled: {e}")
+        await logger.aerror(traceback.format_exc())
 
 
 class SendQueues:
@@ -369,7 +365,7 @@ class SendQueues:
                     logger.trace("OPENAI BLOCKING")
                 # log_event(msg, DIRECTION_TO_OPENAI)
         except Exception:  # noqa: BLE001
-            logger.error(traceback.format_exc())
+            await logger.aerror(traceback.format_exc())
 
     def client_send(self, payload):
         try:
@@ -387,7 +383,7 @@ class SendQueues:
                 self.log_event(msg, LF_TO_CLIENT)
                 await self.client_ws.send_text(json.dumps(msg))
         except Exception:  # noqa: BLE001
-            logger.error(traceback.format_exc())
+            await logger.aerror(traceback.format_exc())
 
     async def close(self):
         self.openai_send_q.put_nowait(None)
@@ -462,7 +458,7 @@ async def handle_function_call(
         create_response()
     except json.JSONDecodeError as e:
         trace = traceback.format_exc()
-        logger.error(f"JSON decode error: {e!s}\ntrace: {trace}")
+        await logger.aerror(f"JSON decode error: {e!s}\ntrace: {trace}")
         function_output = {
             "type": "conversation.item.create",
             "item": {
@@ -474,7 +470,7 @@ async def handle_function_call(
         msg_handler.openai_send(function_output)
     except ValueError as e:
         trace = traceback.format_exc()
-        logger.error(f"Value error: {e!s}\ntrace: {trace}")
+        await logger.aerror(f"Value error: {e!s}\ntrace: {trace}")
         function_output = {
             "type": "conversation.item.create",
             "item": {
@@ -486,7 +482,7 @@ async def handle_function_call(
         msg_handler.openai_send(function_output)
     except (ConnectionError, websockets.exceptions.WebSocketException) as e:
         trace = traceback.format_exc()
-        logger.error(f"Connection error: {e!s}\ntrace: {trace}")
+        await logger.aerror(f"Connection error: {e!s}\ntrace: {trace}")
         function_output = {
             "type": "conversation.item.create",
             "item": {
@@ -497,8 +493,8 @@ async def handle_function_call(
         }
         msg_handler.openai_send(function_output)
     except (KeyError, AttributeError, TypeError) as e:
-        logger.error(f"Error executing flow: {e}")
-        logger.error(traceback.format_exc())
+        await logger.aerror(f"Error executing flow: {e}")
+        await logger.aerror(traceback.format_exc())
         function_output = {
             "type": "conversation.item.create",
             "item": {
@@ -751,7 +747,7 @@ async def flow_as_tool_websocket(
         except Exception as e:  # noqa: BLE001
             err_msg = {"error": f"Failed to load flow: {e!s}"}
             await client_websocket.send_json(err_msg)
-            logger.error(f"Failed to load flow: {e}")
+            await logger.aerror(f"Failed to load flow: {e}")
             return
 
         url = "wss://api.openai.com/v1/realtime?model=gpt-4o-mini-realtime-preview"
@@ -800,7 +796,7 @@ async def flow_as_tool_websocket(
                                     msg_handler.openai_send({"type": "response.cancel"})
                                     bot_speaking_flag[0] = False
                         except Exception as e:  # noqa: BLE001
-                            logger.error(f"[ERROR] VAD processing failed (ValueError): {e}")
+                            await logger.aerror(f"[ERROR] VAD processing failed (ValueError): {e}")
                             continue
                     if has_speech:
                         last_speech_time = datetime.now(tz=timezone.utc)
@@ -856,7 +852,7 @@ async def flow_as_tool_websocket(
                 return new_session
 
             class Response:
-                def __init__(self, response_id: str, use_elevenlabs: bool | None = None):
+                def __init__(self, response_id: str, *, use_elevenlabs: bool | None = None):
                     if use_elevenlabs is None:
                         use_elevenlabs = False
                     self.response_id = response_id
@@ -925,7 +921,7 @@ async def flow_as_tool_websocket(
                     # client_send_event_from_thread(event, main_loop)
                     msg_handler.client_send(event)
                 except Exception:  # noqa: BLE001
-                    logger.error(traceback.format_exc())
+                    await logger.aerror(traceback.format_exc())
 
             async def forward_to_openai() -> None:
                 nonlocal openai_realtime_session
@@ -954,10 +950,10 @@ async def flow_as_tool_websocket(
                                 msg_handler.openai_send(msg)
                                 num_audio_samples = 0
                         elif msg.get("type") == "langflow.voice_mode.config":
-                            logger.info(f"langflow.voice_mode.config {msg}")
+                            await logger.ainfo(f"langflow.voice_mode.config {msg}")
                             voice_config.progress_enabled = msg.get("progress_enabled", True)
                         elif msg.get("type") == "langflow.elevenlabs.config":
-                            logger.info(f"langflow.elevenlabs.config {msg}")
+                            await logger.ainfo(f"langflow.elevenlabs.config {msg}")
                             voice_config.use_elevenlabs = msg["enabled"]
                             voice_config.elevenlabs_voice = msg.get("voice_id", voice_config.elevenlabs_voice)
 
@@ -997,7 +993,7 @@ async def flow_as_tool_websocket(
                         if do_forward:
                             msg_handler.client_send(event)
                         if event_type == "response.created":
-                            responses[response_id] = Response(response_id, voice_config.use_elevenlabs)
+                            responses[response_id] = Response(response_id, use_elevenlabs=voice_config.use_elevenlabs)
                             if function_call:
                                 if function_call.is_prog_enabled and not function_call.prog_rsp_id:
                                     function_call.prog_rsp_id = response_id
@@ -1021,12 +1017,12 @@ async def flow_as_tool_websocket(
                                     message_text = event.get("text", "")
                                     await add_message_to_db(message_text, session, flow_id, session_id, "Machine", "AI")
                                 except ValueError as err:
-                                    logger.error(f"Error saving message to database (ValueError): {err}")
-                                    logger.error(traceback.format_exc())
+                                    await logger.aerror(f"Error saving message to database (ValueError): {err}")
+                                    await logger.aerror(traceback.format_exc())
                                 except (KeyError, AttributeError, TypeError) as err:
                                     # Replace blind Exception with specific exceptions
-                                    logger.error(f"Error saving message to database: {err}")
-                                    logger.error(traceback.format_exc())
+                                    await logger.aerror(f"Error saving message to database: {err}")
+                                    await logger.aerror(traceback.format_exc())
 
                         elif event_type == "response.output_item.added":
                             bot_speaking_flag[0] = True
@@ -1050,12 +1046,12 @@ async def flow_as_tool_websocket(
                                 if transcript and transcript.strip():
                                     await add_message_to_db(transcript, session, flow_id, session_id, "Machine", "AI")
                             except ValueError as err:
-                                logger.error(f"Error saving message to database (ValueError): {err}")
-                                logger.error(traceback.format_exc())
+                                await logger.aerror(f"Error saving message to database (ValueError): {err}")
+                                await logger.aerror(traceback.format_exc())
                             except (KeyError, AttributeError, TypeError) as err:
                                 # Replace blind Exception with specific exceptions
-                                logger.error(f"Error saving message to database: {err}")
-                                logger.error(traceback.format_exc())
+                                await logger.aerror(f"Error saving message to database: {err}")
+                                await logger.aerror(traceback.format_exc())
                             bot_speaking_flag[0] = False
                         elif event_type == "response.done":
                             msg_handler.openai_unblock()
@@ -1080,12 +1076,12 @@ async def flow_as_tool_websocket(
                                 if message_text and message_text.strip():
                                     await add_message_to_db(message_text, session, flow_id, session_id, "User", "User")
                             except ValueError as e:
-                                logger.error(f"Error saving message to database (ValueError): {e}")
-                                logger.error(traceback.format_exc())
+                                await logger.aerror(f"Error saving message to database (ValueError): {e}")
+                                await logger.aerror(traceback.format_exc())
                             except (KeyError, AttributeError, TypeError) as e:
                                 # Replace blind Exception with specific exceptions
-                                logger.error(f"Error saving message to database: {e}")
-                                logger.error(traceback.format_exc())
+                                await logger.aerror(f"Error saving message to database: {e}")
+                                await logger.aerror(traceback.format_exc())
                         elif event_type == "error":
                             pass
 
@@ -1104,12 +1100,12 @@ async def flow_as_tool_websocket(
                 # Check for exceptions in results
                 for result in results:
                     if isinstance(result, Exception):
-                        logger.error("WS loop failed:", exc_info=result)
-                        logger.error(traceback.format_exc())
+                        await logger.aerror("WS loop failed:", exc_info=result)
+                        await logger.aerror(traceback.format_exc())
             except Exception as e:  # noqa: BLE001
                 # Handle any other exceptions
-                logger.error(f"WS loop failed: {e}")
-                logger.error(traceback.format_exc())
+                await logger.aerror(f"WS loop failed: {e}")
+                await logger.aerror(traceback.format_exc())
             finally:
                 # shared cleanup for writers & sockets
                 async def close():
@@ -1119,8 +1115,8 @@ async def flow_as_tool_websocket(
 
                 await close()
     except Exception as e:  # noqa: BLE001
-        logger.error(f"Unexpected error: {e}")
-        logger.error(traceback.format_exc())
+        await logger.aerror(f"Unexpected error: {e}")
+        await logger.aerror(traceback.format_exc())
     finally:
         # Make sure to clean up the task
         if vad_task and not vad_task.done():
@@ -1232,16 +1228,16 @@ async def flow_tts_websocket(
                         elif event.get("type") == "input_audio_buffer.commit":
                             openai_send(event)
                         elif event.get("type") == "langflow.elevenlabs.config":
-                            logger.info(f"langflow.elevenlabs.config {event}")
+                            await logger.ainfo(f"langflow.elevenlabs.config {event}")
                             tts_config.use_elevenlabs = event["enabled"]
                             tts_config.elevenlabs_voice = event.get("voice_id", tts_config.elevenlabs_voice)
                         elif event.get("type") == "voice.settings":
                             # Store the voice setting
                             if event.get("voice"):
                                 tts_config.openai_voice = event.get("voice")
-                                logger.info(f"Updated OpenAI voice to: {tts_config.openai_voice}")
+                                await logger.ainfo(f"Updated OpenAI voice to: {tts_config.openai_voice}")
                 except Exception as e:  # noqa: BLE001
-                    logger.error(f"Error in WebSocket communication: {e}")
+                    await logger.aerror(f"Error in WebSocket communication: {e}")
 
             async def forward_to_client() -> None:
                 try:
@@ -1312,7 +1308,7 @@ async def flow_tts_websocket(
                                         audio_event = {"type": "response.audio.delta", "delta": base64_audio}
                                         client_send(audio_event)
                 except Exception as e:  # noqa: BLE001
-                    logger.error(f"Error in WebSocket communication: {e}")
+                    await logger.aerror(f"Error in WebSocket communication: {e}")
 
             try:
                 # Create tasks and gather them for concurrent execution
@@ -1321,13 +1317,13 @@ async def flow_tts_websocket(
                 await asyncio.gather(task1, task2)
             except Exception as exc:  # noqa: BLE001
                 # handle any exceptions from any task
-                logger.error("WS loop failed:", exc_info=exc)
+                await logger.aerror("WS loop failed:", exc_info=exc)
             finally:
                 # shared cleanup for writers & sockets
                 await close()
     except Exception as e:  # noqa: BLE001
-        logger.error(f"Unexpected error: {e}")
-        logger.error(traceback.format_exc())
+        await logger.aerror(f"Unexpected error: {e}")
+        await logger.aerror(traceback.format_exc())
 
 
 def extract_transcript(json_data):
@@ -1367,13 +1363,13 @@ async def get_elevenlabs_voice_ids(
             for voice in voices
         ]
     except ValueError as e:
-        logger.error(f"Error fetching ElevenLabs voices (ValueError): {e}")
+        await logger.aerror(f"Error fetching ElevenLabs voices (ValueError): {e}")
         return {"error": str(e)}
     except requests.RequestException as e:
-        logger.error(f"Error fetching ElevenLabs voices (RequestException): {e}")
+        await logger.aerror(f"Error fetching ElevenLabs voices (RequestException): {e}")
         return {"error": str(e)}
     except (KeyError, AttributeError, TypeError) as e:
         # More specific exceptions instead of blind Exception
-        logger.error(f"Error fetching ElevenLabs voices: {e}")
-        logger.error(traceback.format_exc())
+        await logger.aerror(f"Error fetching ElevenLabs voices: {e}")
+        await logger.aerror(traceback.format_exc())
         return {"error": str(e)}

langflow/api/v2/files.py

@@ -11,11 +11,11 @@ from zoneinfo import ZoneInfo
 
 from fastapi import APIRouter, Depends, File, HTTPException, UploadFile
 from fastapi.responses import StreamingResponse
-from loguru import logger
 from sqlmodel import col, select
 
 from langflow.api.schemas import UploadFileResponse
 from langflow.api.utils import CurrentActiveUser, DbSession
+from langflow.logging.logger import logger
 from langflow.services.database.models.file.model import File as UserFile
 from langflow.services.deps import get_settings_service, get_storage_service
 from langflow.services.storage.service import StorageService
@@ -488,7 +488,7 @@ async def delete_file(
         raise
     except Exception as e:
         # Log and return a generic server error
-        logger.error("Error deleting file %s: %s", file_id, e)
+        await logger.aerror("Error deleting file %s: %s", file_id, e)
         raise HTTPException(status_code=500, detail=f"Error deleting file: {e}") from e
     return {"detail": f"File {file_to_delete.name} deleted successfully"}
 

langflow/api/v2/mcp.py

@@ -115,6 +115,7 @@ async def get_servers(
     session: DbSession,
     storage_service=Depends(get_storage_service),
     settings_service=Depends(get_settings_service),
+    *,
     action_count: bool | None = None,
 ):
     """Get the list of available servers."""
@@ -140,27 +141,27 @@ async def get_servers(
                 server_info["error"] = "No tools found"
         except ValueError as e:
             # Configuration validation errors, invalid URLs, etc.
-            logger.error(f"Configuration error for server {server_name}: {e}")
+            await logger.aerror(f"Configuration error for server {server_name}: {e}")
             server_info["error"] = f"Configuration error: {e}"
         except ConnectionError as e:
             # Network connection and timeout issues
-            logger.error(f"Connection error for server {server_name}: {e}")
+            await logger.aerror(f"Connection error for server {server_name}: {e}")
             server_info["error"] = f"Connection failed: {e}"
         except (TimeoutError, asyncio.TimeoutError) as e:
             # Timeout errors
-            logger.error(f"Timeout error for server {server_name}: {e}")
+            await logger.aerror(f"Timeout error for server {server_name}: {e}")
             server_info["error"] = "Timeout when checking server tools"
         except OSError as e:
             # System-level errors (process execution, file access)
-            logger.error(f"System error for server {server_name}: {e}")
+            await logger.aerror(f"System error for server {server_name}: {e}")
             server_info["error"] = f"System error: {e}"
         except (KeyError, TypeError) as e:
             # Data parsing and access errors
-            logger.error(f"Data error for server {server_name}: {e}")
+            await logger.aerror(f"Data error for server {server_name}: {e}")
             server_info["error"] = f"Configuration data error: {e}"
         except (RuntimeError, ProcessLookupError, PermissionError) as e:
             # Runtime and process-related errors
-            logger.error(f"Runtime error for server {server_name}: {e}")
+            await logger.aerror(f"Runtime error for server {server_name}: {e}")
             server_info["error"] = f"Runtime error: {e}"
         except Exception as e:  # noqa: BLE001
             # Generic catch-all for other exceptions (including ExceptionGroup)
@@ -168,15 +169,15 @@ async def get_servers(
                 # Extract the first underlying exception for a more meaningful error message
                 underlying_error = e.exceptions[0]
                 if hasattr(underlying_error, "exceptions"):
-                    logger.error(
+                    await logger.aerror(
                         f"Error checking server {server_name}: {underlying_error}, {underlying_error.exceptions}"
                     )
                     underlying_error = underlying_error.exceptions[0]
                 else:
-                    logger.exception(f"Error checking server {server_name}: {underlying_error}")
+                    await logger.aexception(f"Error checking server {server_name}: {underlying_error}")
                 server_info["error"] = f"Error loading server: {underlying_error}"
             else:
-                logger.exception(f"Error checking server {server_name}: {e}")
+                await logger.aexception(f"Error checking server {server_name}: {e}")
                 server_info["error"] = f"Error loading server: {e}"
         return server_info
 

langflow/base/composio/composio_base.py

@@ -135,7 +135,15 @@ class ComposioBaseComponent(Component):
 
         if isinstance(result, dict):
             result = [result]
-        return DataFrame(result)
+        # Build DataFrame and avoid exposing a 'data' attribute via column access,
+        result_dataframe = DataFrame(result)
+        if hasattr(result_dataframe, "columns"):
+            try:
+                if "data" in result_dataframe.columns:
+                    result_dataframe = result_dataframe.rename(columns={"data": "_data"})
+            except (AttributeError, TypeError, ValueError, KeyError) as e:
+                logger.debug(f"Failed to rename 'data' column: {e}")
+        return result_dataframe
 
     def as_data(self) -> Data:
         result = self.execute_action()
@@ -379,6 +387,8 @@ class ComposioBaseComponent(Component):
                             # Handle conflicting field names - rename user_id to avoid conflicts with entity_id
                             if clean_field == "user_id":
                                 clean_field = f"{self.app_name}_user_id"
+                            elif clean_field == "status":
+                                clean_field = f"{self.app_name}_status"
 
                             action_fields.append(clean_field)
 
@@ -526,11 +536,18 @@ class ComposioBaseComponent(Component):
                 # Handle conflicting field names - rename user_id to avoid conflicts with entity_id
                 if clean_field_name == "user_id":
                     clean_field_name = f"{self.app_name}_user_id"
-                    # Update the field schema description to reflect the name change
+                    # Update
                     field_schema_copy = field_schema.copy()
                     field_schema_copy["description"] = (
                         f"User ID for {self.app_name.title()}: " + field_schema["description"]
                     )
+                elif clean_field_name == "status":
+                    clean_field_name = f"{self.app_name}_status"
+                    # Update
+                    field_schema_copy = field_schema.copy()
+                    field_schema_copy["description"] = (
+                        f"Status for {self.app_name.title()}: " + field_schema["description"]
+                    )
                 else:
                     # Use the original field schema for all other fields
                     field_schema_copy = field_schema
@@ -1240,6 +1257,8 @@ class ComposioBaseComponent(Component):
                 final_field_name = field
                 if field.endswith("_user_id") and field.startswith(self.app_name):
                     final_field_name = "user_id"
+                elif field.endswith("_status") and field.startswith(self.app_name):
+                    final_field_name = "status"
 
                 arguments[final_field_name] = value