langflow-base-nightly 0.5.0.dev28__py3-none-any.whl → 0.5.0.dev30__py3-none-any.whl

langflow/base/mcp/util.py

@@ -1,4 +1,6 @@
 import asyncio
+import contextlib
+import inspect
 import os
 import platform
 import re
@@ -30,6 +32,13 @@ HTTP_NOT_FOUND = 404
 HTTP_BAD_REQUEST = 400
 HTTP_INTERNAL_SERVER_ERROR = 500
 
+# MCP Session Manager constants
+settings = get_settings_service().settings
+MAX_SESSIONS_PER_SERVER = (
+    settings.mcp_max_sessions_per_server
+)  # Maximum number of sessions per server to prevent resource exhaustion
+SESSION_IDLE_TIMEOUT = settings.mcp_session_idle_timeout  # 5 minutes idle timeout for sessions
+SESSION_CLEANUP_INTERVAL = settings.mcp_session_cleanup_interval  # Cleanup interval in seconds
 # RFC 7230 compliant header name pattern: token = 1*tchar
 # tchar = "!" / "#" / "$" / "%" / "&" / "'" / "*" / "+" / "-" / "." /
 #         "^" / "_" / "`" / "|" / "~" / DIGIT / ALPHA
@@ -460,12 +469,90 @@ async def _validate_connection_params(mode: str, command: str | None = None, url
 
 
 class MCPSessionManager:
-    """Manages persistent MCP sessions with proper context manager lifecycle."""
+    """Manages persistent MCP sessions with proper context manager lifecycle.
+
+    Fixed version that addresses the memory leak issue by:
+    1. Session reuse based on server identity rather than unique context IDs
+    2. Maximum session limits per server to prevent resource exhaustion
+    3. Idle timeout for automatic session cleanup
+    4. Periodic cleanup of stale sessions
+    """
 
     def __init__(self):
-        self.sessions = {}  # context_id -> session_info
+        # Structure: server_key -> {"sessions": {session_id: session_info}, "last_cleanup": timestamp}
+        self.sessions_by_server = {}
         self._background_tasks = set()  # Keep references to background tasks
-        self._last_server_by_session = {}  # context_id -> server_name for tracking switches
+        # Backwards-compatibility maps: which context_id uses which (server_key, session_id)
+        self._context_to_session: dict[str, tuple[str, str]] = {}
+        # Reference count for each active (server_key, session_id)
+        self._session_refcount: dict[tuple[str, str], int] = {}
+        self._cleanup_task = None
+        self._start_cleanup_task()
+
+    def _start_cleanup_task(self):
+        """Start the periodic cleanup task."""
+        if self._cleanup_task is None or self._cleanup_task.done():
+            self._cleanup_task = asyncio.create_task(self._periodic_cleanup())
+            self._background_tasks.add(self._cleanup_task)
+            self._cleanup_task.add_done_callback(self._background_tasks.discard)
+
+    async def _periodic_cleanup(self):
+        """Periodically clean up idle sessions."""
+        while True:
+            try:
+                await asyncio.sleep(SESSION_CLEANUP_INTERVAL)
+                await self._cleanup_idle_sessions()
+            except asyncio.CancelledError:
+                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}")
+
+    async def _cleanup_idle_sessions(self):
+        """Clean up sessions that have been idle for too long."""
+        current_time = asyncio.get_event_loop().time()
+        servers_to_remove = []
+
+        for server_key, server_data in self.sessions_by_server.items():
+            sessions = server_data.get("sessions", {})
+            sessions_to_remove = []
+
+            for session_id, session_info in sessions.items():
+                if current_time - session_info["last_used"] > SESSION_IDLE_TIMEOUT:
+                    sessions_to_remove.append(session_id)
+
+            # 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 self._cleanup_session_by_id(server_key, session_id)
+
+            # Remove server entry if no sessions left
+            if not sessions:
+                servers_to_remove.append(server_key)
+
+        # Clean up empty server entries
+        for server_key in servers_to_remove:
+            del self.sessions_by_server[server_key]
+
+    def _get_server_key(self, connection_params, transport_type: str) -> str:
+        """Generate a consistent server key based on connection parameters."""
+        if transport_type == "stdio":
+            if hasattr(connection_params, "command"):
+                # Include command, args, and environment for uniqueness
+                command_str = f"{connection_params.command} {' '.join(connection_params.args or [])}"
+                env_str = str(sorted((connection_params.env or {}).items()))
+                key_input = f"{command_str}|{env_str}"
+                return f"stdio_{hash(key_input)}"
+        elif transport_type == "sse" and (isinstance(connection_params, dict) and "url" in connection_params):
+            # Include URL and headers for uniqueness
+            url = connection_params["url"]
+            headers = str(sorted((connection_params.get("headers", {})).items()))
+            key_input = f"{url}|{headers}"
+            return f"sse_{hash(key_input)}"
+
+        # Fallback to a generic key
+        # TODO: add option for streamable HTTP in future.
+        return f"{transport_type}_{hash(str(connection_params))}"
 
     async def _validate_session_connectivity(self, session) -> bool:
         """Validate that the session is actually usable by testing a simple operation."""
@@ -483,6 +570,7 @@ class MCPSessionManager:
                 "ClosedResourceError" in str(type(e))
                 or "Connection closed" in error_str
                 or "Connection lost" in error_str
+                or "Connection failed" in error_str
                 or "Transport closed" in error_str
                 or "Stream closed" in error_str
             ):
@@ -510,117 +598,83 @@ class MCPSessionManager:
                 return True
 
     async def get_session(self, context_id: str, connection_params, transport_type: str):
-        """Get or create a persistent session."""
-        # Extract server identifier from connection params for tracking
-        server_identifier = None
-        if transport_type == "stdio" and hasattr(connection_params, "command"):
-            server_identifier = f"stdio_{connection_params.command}"
-        elif transport_type == "sse" and isinstance(connection_params, dict) and "url" in connection_params:
-            server_identifier = f"sse_{connection_params['url']}"
-
-        # Check if we're switching servers for this context
-        server_switched = False
-        if context_id in self._last_server_by_session:
-            last_server = self._last_server_by_session[context_id]
-            if last_server != server_identifier:
-                server_switched = True
-                logger.info(f"Detected server switch for context {context_id}: {last_server} -> {server_identifier}")
-
-        # Update server tracking
-        if server_identifier:
-            self._last_server_by_session[context_id] = server_identifier
-
-        if context_id in self.sessions:
-            session_info = self.sessions[context_id]
-            # Check if session and background task are still alive
-            try:
-                session = session_info["session"]
-                task = session_info["task"]
+        """Get or create a session with improved reuse strategy.
 
-                # Break down the health check to understand why cleanup is triggered
-                task_not_done = not task.done()
+        The key insight is that we should reuse sessions based on the server
+        identity (command + args for stdio, URL for SSE) rather than the context_id.
+        This prevents creating a new subprocess for each unique context.
+        """
+        server_key = self._get_server_key(connection_params, transport_type)
 
-                # Additional check for stream health
-                stream_is_healthy = True
-                try:
-                    # Check if the session's write stream is still open
-                    if hasattr(session, "_write_stream"):
-                        write_stream = session._write_stream
-
-                        # Check for explicit closed state
-                        if hasattr(write_stream, "_closed") and write_stream._closed:
-                            stream_is_healthy = False
-                        # Check anyio stream state for send channels
-                        elif hasattr(write_stream, "_state") and hasattr(write_stream._state, "open_send_channels"):
-                            # Stream is healthy if there are open send channels
-                            stream_is_healthy = write_stream._state.open_send_channels > 0
-                        # Check for other stream closed indicators
-                        elif hasattr(write_stream, "is_closing") and callable(write_stream.is_closing):
-                            stream_is_healthy = not write_stream.is_closing()
-                        # If we can't determine state definitively, try a simple write test
-                        else:
-                            # For streams we can't easily check, assume healthy unless proven otherwise
-                            # The actual tool call will reveal if the stream is truly dead
-                            stream_is_healthy = True
-
-                except (AttributeError, TypeError) as e:
-                    # If we can't check stream health due to missing attributes,
-                    # assume it's healthy and let the tool call fail if it's not
-                    logger.debug(f"Could not check stream health for context_id {context_id}: {e}")
-                    stream_is_healthy = True
-
-                logger.debug(f"Session health check for context_id {context_id}:")
-                logger.debug(f"  - task_not_done: {task_not_done}")
-                logger.debug(f"  - stream_is_healthy: {stream_is_healthy}")
-
-                # For MCP ClientSession, we need both task and stream to be healthy
-                session_is_healthy = task_not_done and stream_is_healthy
-
-                logger.debug(f"  - session_is_healthy: {session_is_healthy}")
-
-                # If we switched servers, always recreate the session to avoid cross-server contamination
-                if server_switched:
-                    logger.info(f"Server switch detected for context_id {context_id}, forcing session recreation")
-                    session_is_healthy = False
-
-                # Always run connectivity test for sessions to ensure they're truly responsive
-                # This is especially important when switching between servers
-                elif session_is_healthy:
-                    logger.debug(f"Running connectivity test for context_id {context_id}")
-                    connectivity_ok = await self._validate_session_connectivity(session)
-                    logger.debug(f"  - connectivity_ok: {connectivity_ok}")
-                    if not connectivity_ok:
-                        session_is_healthy = False
-                        logger.info(
-                            f"Session for context_id {context_id} failed connectivity test, marking as unhealthy"
-                        )
-
-                if session_is_healthy:
-                    logger.debug(f"Session for context_id {context_id} is healthy and responsive, reusing")
-                    return session
+        # Ensure server entry exists
+        if server_key not in self.sessions_by_server:
+            self.sessions_by_server[server_key] = {"sessions": {}, "last_cleanup": asyncio.get_event_loop().time()}
 
-                if not task_not_done:
-                    msg = f"Session for context_id {context_id} failed health check: background task is done"
-                    logger.info(msg)
-                elif not stream_is_healthy:
-                    msg = f"Session for context_id {context_id} failed health check: stream is closed"
-                    logger.info(msg)
+        server_data = self.sessions_by_server[server_key]
+        sessions = server_data["sessions"]
 
-            except Exception as e:  # noqa: BLE001
-                msg = f"Session for context_id {context_id} is dead due to exception: {e}"
-                logger.info(msg)
-            # Session is dead, clean it up
-            await self._cleanup_session(context_id)
+        # Try to find a healthy existing session
+        for session_id, session_info in sessions.items():
+            session = session_info["session"]
+            task = session_info["task"]
+
+            # Check if session is still alive
+            if not task.done():
+                # Update last used time
+                session_info["last_used"] = asyncio.get_event_loop().time()
+
+                # Quick health check
+                if await self._validate_session_connectivity(session):
+                    logger.debug(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 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 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(
+                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}")
+
         if transport_type == "stdio":
-            return await self._create_stdio_session(context_id, connection_params)
-        if transport_type == "sse":
-            return await self._create_sse_session(context_id, connection_params)
-        msg = f"Unknown transport type: {transport_type}"
-        raise ValueError(msg)
+            session, task = await self._create_stdio_session(session_id, connection_params)
+        elif transport_type == "sse":
+            session, task = await self._create_sse_session(session_id, connection_params)
+        else:
+            msg = f"Unknown transport type: {transport_type}"
+            raise ValueError(msg)
 
-    async def _create_stdio_session(self, context_id: str, connection_params):
+        # Store session info
+        sessions[session_id] = {
+            "session": session,
+            "task": task,
+            "type": transport_type,
+            "last_used": asyncio.get_event_loop().time(),
+        }
+
+        # register mapping & initial ref-count for the new session
+        self._context_to_session[context_id] = (server_key, session_id)
+        self._session_refcount[(server_key, session_id)] = 1
+
+        return session
+
+    async def _create_stdio_session(self, session_id: str, connection_params):
         """Create a new stdio session as a background task to avoid context issues."""
         import asyncio
 
@@ -646,9 +700,7 @@ class MCPSessionManager:
                         try:
                             await event.wait()
                         except asyncio.CancelledError:
-                            # Session is being shut down
-                            msg = "Message is shutting down"
-                            logger.info(msg)
+                            logger.info(f"Session {session_id} is shutting down")
             except Exception as e:  # noqa: BLE001
                 if not session_future.done():
                     session_future.set_exception(e)
@@ -660,7 +712,7 @@ class MCPSessionManager:
 
         # Wait for session to be ready
         try:
-            session = await asyncio.wait_for(session_future, timeout=10.0)  # 10 second timeout for session creation
+            session = await asyncio.wait_for(session_future, timeout=10.0)
         except asyncio.TimeoutError as timeout_err:
             # Clean up the failed task
             if not task.done():
@@ -670,15 +722,13 @@ class MCPSessionManager:
                 with contextlib.suppress(asyncio.CancelledError):
                     await task
             self._background_tasks.discard(task)
-            msg = f"Timeout waiting for STDIO session to initialize for context {context_id}"
+            msg = f"Timeout waiting for STDIO session {session_id} to initialize"
             logger.error(msg)
             raise ValueError(msg) from timeout_err
-        else:
-            # Store session info
-            self.sessions[context_id] = {"session": session, "task": task, "type": "stdio"}
-            return session
 
-    async def _create_sse_session(self, context_id: str, connection_params):
+        return session, task
+
+    async def _create_sse_session(self, session_id: str, connection_params):
         """Create a new SSE session as a background task to avoid context issues."""
         import asyncio
 
@@ -709,9 +759,7 @@ class MCPSessionManager:
                         try:
                             await event.wait()
                         except asyncio.CancelledError:
-                            # Session is being shut down
-                            msg = "Message is shutting down"
-                            logger.info(msg)
+                            logger.info(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 +771,7 @@ class MCPSessionManager:
 
         # Wait for session to be ready
         try:
-            session = await asyncio.wait_for(session_future, timeout=10.0)  # 10 second timeout for session creation
+            session = await asyncio.wait_for(session_future, timeout=10.0)
         except asyncio.TimeoutError as timeout_err:
             # Clean up the failed task
             if not task.done():
@@ -733,21 +781,62 @@ class MCPSessionManager:
                 with contextlib.suppress(asyncio.CancelledError):
                     await task
             self._background_tasks.discard(task)
-            msg = f"Timeout waiting for SSE session to initialize for context {context_id}"
+            msg = f"Timeout waiting for SSE session {session_id} to initialize"
             logger.error(msg)
             raise ValueError(msg) from timeout_err
+
+        return session, task
+
+    async def _cleanup_session_by_id(self, server_key: str, session_id: str):
+        """Clean up a specific session by server key and session ID."""
+        if server_key not in self.sessions_by_server:
+            return
+
+        server_data = self.sessions_by_server[server_key]
+        # Handle both old and new session structure
+        if isinstance(server_data, dict) and "sessions" in server_data:
+            sessions = server_data["sessions"]
         else:
-            # Store session info
-            self.sessions[context_id] = {"session": session, "task": task, "type": "sse"}
-            return session
+            # Handle old structure where sessions were stored directly
+            sessions = server_data
 
-    async def _cleanup_session(self, context_id: str):
-        """Clean up a session by cancelling its background task."""
-        if context_id not in self.sessions:
+        if session_id not in sessions:
             return
 
-        session_info = self.sessions[context_id]
+        session_info = sessions[session_id]
         try:
+            # First try to properly close the session if it exists
+            if "session" in session_info:
+                session = session_info["session"]
+
+                # Try async close first (aclose method)
+                if hasattr(session, "aclose"):
+                    try:
+                        await session.aclose()
+                        logger.debug("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)
+
+                # If no aclose, try regular close method
+                elif hasattr(session, "close"):
+                    try:
+                        # Check if close() is awaitable using inspection
+                        if inspect.iscoroutinefunction(session.close):
+                            # It's an async method
+                            await session.close()
+                            logger.debug("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)
+                            else:
+                                # It's a synchronous close
+                                logger.debug("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)
+
             # Cancel the background task which will properly close the session
             if "task" in session_info:
                 task = session_info["task"]
@@ -756,19 +845,76 @@ class MCPSessionManager:
                     try:
                         await task
                     except asyncio.CancelledError:
-                        logger.info(f"Issue cancelling task for context_id {context_id}")
+                        logger.info(f"Cancelled task for session {session_id}")
         except Exception as e:  # noqa: BLE001
-            logger.info(f"issue cleaning up mcp session: {e}")
+            logger.warning(f"Error cleaning up session {session_id}: {e}")
         finally:
-            del self.sessions[context_id]
-            # Also clean up server tracking
-            if context_id in self._last_server_by_session:
-                del self._last_server_by_session[context_id]
+            # Remove from sessions dict
+            del sessions[session_id]
 
     async def cleanup_all(self):
         """Clean up all sessions."""
-        for context_id in list(self.sessions.keys()):
-            await self._cleanup_session(context_id)
+        # Cancel periodic cleanup task
+        if self._cleanup_task and not self._cleanup_task.done():
+            self._cleanup_task.cancel()
+            with contextlib.suppress(asyncio.CancelledError):
+                await self._cleanup_task
+
+        # Clean up all sessions
+        for server_key in list(self.sessions_by_server.keys()):
+            server_data = self.sessions_by_server[server_key]
+            # Handle both old and new session structure
+            if isinstance(server_data, dict) and "sessions" in server_data:
+                sessions = server_data["sessions"]
+            else:
+                # Handle old structure where sessions were stored directly
+                sessions = server_data
+
+            for session_id in list(sessions.keys()):
+                await self._cleanup_session_by_id(server_key, session_id)
+
+        # Clear the sessions_by_server structure completely
+        self.sessions_by_server.clear()
+
+        # Clear compatibility maps
+        self._context_to_session.clear()
+        self._session_refcount.clear()
+
+        # Clear all background tasks
+        for task in list(self._background_tasks):
+            if not task.done():
+                task.cancel()
+                with contextlib.suppress(asyncio.CancelledError):
+                    await task
+
+        # Give a bit more time for subprocess transports to clean up
+        # This helps prevent the BaseSubprocessTransport.__del__ warnings
+        await asyncio.sleep(0.5)
+
+    async def _cleanup_session(self, context_id: str):
+        """Backward-compat cleanup by context_id.
+
+        Decrements the ref-count for the session used by *context_id* and only
+        tears the session down when the last context that references it goes
+        away.
+        """
+        mapping = self._context_to_session.get(context_id)
+        if not mapping:
+            logger.debug(f"No session mapping found for context_id {context_id}")
+            return
+
+        server_key, session_id = mapping
+        ref_key = (server_key, session_id)
+        remaining = self._session_refcount.get(ref_key, 1) - 1
+
+        if remaining <= 0:
+            await self._cleanup_session_by_id(server_key, session_id)
+            self._session_refcount.pop(ref_key, None)
+        else:
+            self._session_refcount[ref_key] = remaining
+
+        # Remove the mapping for this context
+        self._context_to_session.pop(context_id, None)
 
 
 class MCPStdioClient:
@@ -963,11 +1109,15 @@ class MCPStdioClient:
 
     async def disconnect(self):
         """Properly close the connection and clean up resources."""
-        # Clean up session using session manager
+        # For stdio transport, there is no remote session to terminate explicitly
+        # The session cleanup happens when the background task is cancelled
+
+        # Clean up local session using the session manager
         if self._session_context:
             session_manager = self._get_session_manager()
             await session_manager._cleanup_session(self._session_context)
 
+        # Reset local state
         self.session = None
         self._connection_params = None
         self._connected = False
@@ -1127,19 +1277,34 @@ class MCPSseClient:
 
         # Use cached session manager to get/create persistent session
         session_manager = self._get_session_manager()
-        return await session_manager.get_session(self._session_context, self._connection_params, "sse")
+        # Cache session so we can access server-assigned session_id later for DELETE
+        self.session = await session_manager.get_session(self._session_context, self._connection_params, "sse")
+        return self.session
+
+    async def _terminate_remote_session(self) -> None:
+        """Attempt to explicitly terminate the remote MCP session via HTTP DELETE (best-effort)."""
+        # Only relevant for SSE transport
+        if not self._connection_params or "url" not in self._connection_params:
+            return
 
-    async def disconnect(self):
-        """Properly close the connection and clean up resources."""
-        # Clean up session using session manager
-        if self._session_context:
-            session_manager = self._get_session_manager()
-            await session_manager._cleanup_session(self._session_context)
+        url: str = self._connection_params["url"]
 
-        self.session = None
-        self._connection_params = None
-        self._connected = False
-        self._session_context = None
+        # Retrieve session id from the underlying SDK if exposed
+        session_id = None
+        if getattr(self, "session", None) is not None:
+            # Common attributes in MCP python SDK: `session_id` or `id`
+            session_id = getattr(self.session, "session_id", None) or getattr(self.session, "id", None)
+
+        headers: dict[str, str] = dict(self._connection_params.get("headers", {}))
+        if session_id:
+            headers["Mcp-Session-Id"] = str(session_id)
+
+        try:
+            async with httpx.AsyncClient(timeout=5.0) as client:
+                await client.delete(url, headers=headers)
+        except Exception as e:  # noqa: BLE001
+            # DELETE is advisory—log and continue
+            logger.debug(f"Unable to send session DELETE to '{url}': {e}")
 
     async def run_tool(self, tool_name: str, arguments: dict[str, Any]) -> Any:
         """Run a tool with the given arguments using context-specific session.
@@ -1253,6 +1418,22 @@ class MCPSseClient:
         logger.error(msg)
         raise ValueError(msg)
 
+    async def disconnect(self):
+        """Properly close the connection and clean up resources."""
+        # Attempt best-effort remote session termination first
+        await self._terminate_remote_session()
+
+        # Clean up local session using the session manager
+        if self._session_context:
+            session_manager = self._get_session_manager()
+            await session_manager._cleanup_session(self._session_context)
+
+        # Reset local state
+        self.session = None
+        self._connection_params = None
+        self._connected = False
+        self._session_context = None
+
     async def __aenter__(self):
         return self
 

langflow/base/models/openai_constants.py

@@ -2,6 +2,35 @@ from .model_metadata import create_model_metadata
 
 # Unified model metadata - single source of truth
 OPENAI_MODELS_DETAILED = [
+    # GPT-5 Series
+    create_model_metadata(
+        provider="OpenAI",
+        name="gpt-5",
+        icon="OpenAI",
+        tool_calling=True,
+        reasoning=True,
+    ),
+    create_model_metadata(
+        provider="OpenAI",
+        name="gpt-5-mini",
+        icon="OpenAI",
+        tool_calling=True,
+        reasoning=True,
+    ),
+    create_model_metadata(
+        provider="OpenAI",
+        name="gpt-5-nano",
+        icon="OpenAI",
+        tool_calling=True,
+        reasoning=True,
+    ),
+    create_model_metadata(
+        provider="OpenAI",
+        name="gpt-5-chat-latest",
+        icon="OpenAI",
+        tool_calling=False,
+        reasoning=True,
+    ),
     # Regular OpenAI Models
     create_model_metadata(provider="OpenAI", name="gpt-4o-mini", icon="OpenAI", tool_calling=True),
     create_model_metadata(provider="OpenAI", name="gpt-4o", icon="OpenAI", tool_calling=True),

langflow/services/settings/base.py

@@ -96,6 +96,22 @@ class Settings(BaseSettings):
     """The number of seconds to wait before giving up on a lock to released or establishing a connection to the
     database."""
 
+    # ---------------------------------------------------------------------
+    # MCP Session-manager tuning
+    # ---------------------------------------------------------------------
+    mcp_max_sessions_per_server: int = 10
+    """Maximum number of MCP sessions to keep per unique server (command/url).
+    Mirrors the default constant MAX_SESSIONS_PER_SERVER in util.py. Adjust to
+    control resource usage or concurrency per server."""
+
+    mcp_session_idle_timeout: int = 400  # seconds
+    """How long (in seconds) an MCP session can stay idle before the background
+    cleanup task disposes of it. Defaults to 5 minutes."""
+
+    mcp_session_cleanup_interval: int = 120  # seconds
+    """Frequency (in seconds) at which the background cleanup task wakes up to
+    reap idle sessions."""
+
     # sqlite configuration
     sqlite_pragmas: dict | None = {"synchronous": "NORMAL", "journal_mode": "WAL"}
     """SQLite pragmas to use when connecting to the database."""

{langflow_base_nightly-0.5.0.dev28.dist-info → langflow_base_nightly-0.5.0.dev30.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: langflow-base-nightly
-Version: 0.5.0.dev28
+Version: 0.5.0.dev30
 Summary: A Python package with a built-in web application
 Project-URL: Repository, https://github.com/langflow-ai/langflow
 Project-URL: Documentation, https://docs.langflow.org

{langflow_base_nightly-0.5.0.dev28.dist-info → langflow_base_nightly-0.5.0.dev30.dist-info}/RECORD

@@ -140,7 +140,7 @@ langflow/base/langwatch/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG
 langflow/base/langwatch/utils.py,sha256=wTNQtyItWdl8_cILV6iFkpM0dTHJU5WdXyfccV26scM,448
 langflow/base/mcp/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 langflow/base/mcp/constants.py,sha256=-1XnJxejlqm9zs1R91qGtOeX-_F1ZpdHVzCIqUCvhgE,62
-langflow/base/mcp/util.py,sha256=ntc_dA6aIG_R8xV7q4JzJwngxfJia_yP1vbtLm6IPMk,56580
+langflow/base/mcp/util.py,sha256=JOml0fB7Iyls1odCPc1xqp42SdKhLrZWYAh4hseqmsc,64044
 langflow/base/memory/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 langflow/base/memory/memory.py,sha256=Y0FKZBLvFpQo7CmPO1t2dyJprZcVpWkyJGk0YRd5H2E,1850
 langflow/base/memory/model.py,sha256=iCO45tdH_Pz9txI7044KB1c9y5M6nSLjIeIu0_YeSpA,1350
@@ -157,7 +157,7 @@ langflow/base/models/model_metadata.py,sha256=tNFPiRqBJ0WPKdNEqBxuoKk0n8H_h0J--b
 langflow/base/models/model_utils.py,sha256=RwXUSIw5gdRakQ-VGbLI1iT0CeeWrVSNTgUQIrrc6uE,474
 langflow/base/models/novita_constants.py,sha256=_mgBYGwpddUw4CLhLKJl-psOUzA_SQGHrfZJUNes6aI,1247
 langflow/base/models/ollama_constants.py,sha256=FM0BPEtuEmIoH2K1t6tTh5h_H2bK7-YSXe0x4-F4Mik,973
-langflow/base/models/openai_constants.py,sha256=Cd7VzE5pDp2_ZAyUzs5g-DJzC5ykg82mOHb_6fZ-kio,4083
+langflow/base/models/openai_constants.py,sha256=xtsyWzClkJwlIBZm-3Jt3x-XWfu2-nPp67faNCWQwdk,4753
 langflow/base/models/sambanova_constants.py,sha256=mYPF7vUbMow9l4jQ2OJrIkAJhGs3fGWTCVNfG3oQZTc,519
 langflow/base/processing/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 langflow/base/prompts/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -1011,7 +1011,7 @@ langflow/services/session/service.py,sha256=KR82A1sycF2gmb7zeqxn4EZ0_NxZcQN1ggRs
 langflow/services/session/utils.py,sha256=YkInqhL019XrgIyovOtkLqFF3jJmlQBSPbKiKOuWGiM,516
 langflow/services/settings/__init__.py,sha256=UISBvOQIqoA3a8opwJrTQp4PSTqpReY6GQ_7O6WuqJQ,65
 langflow/services/settings/auth.py,sha256=jpVRROmFtNp1rqoHYFINzsdnQ_QrglyLgB_uVHhpNVI,4562
-langflow/services/settings/base.py,sha256=rKu4YYcpx9LVOymMJeWaSHT_y15DDc_HxWw2RGbg1hs,23450
+langflow/services/settings/base.py,sha256=ALzdNsYhEAyMd14WDWbvbnUZ6xVsUofpO1oq7ZhVIgs,24246
 langflow/services/settings/constants.py,sha256=Uf8HrGOpRE-55IZ7aopsZsEnzBb9rRPi--PFvJfUGqw,878
 langflow/services/settings/factory.py,sha256=Jf0leRvzUBlxZ6BsoCJEDKdH2kWR9Tiv-Dk8Y7cbqUE,595
 langflow/services/settings/feature_flags.py,sha256=6uR8hwQwdUsveBW7-im2qgxwd8pT-hqf8rz53_zDtQI,236
@@ -1105,7 +1105,7 @@ langflow/utils/util_strings.py,sha256=Blz5lwvE7lml7nKCG9vVJ6me5VNmVtYzFXDVPHPK7v
 langflow/utils/validate.py,sha256=8RnY61LZFCBU1HIlPDCMI3vsXOmK_IFAYBGZIfZJcsU,16362
 langflow/utils/version.py,sha256=OjSj0smls9XnPd4-LpTH9AWyUO_NAn5mncqKkkXl_fw,2840
 langflow/utils/voice_utils.py,sha256=pzU6uuseI2_5mi-yXzFIjMavVRFyuVrpLmR6LqbF7mE,3346
-langflow_base_nightly-0.5.0.dev28.dist-info/METADATA,sha256=ZULLdWeEBwdZpY7ESP5KUVu-GdiZhRTW92Pp4q01NnU,4173
-langflow_base_nightly-0.5.0.dev28.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-langflow_base_nightly-0.5.0.dev28.dist-info/entry_points.txt,sha256=JvuLdXSrkeDmDdpb8M-VvFIzb84n4HmqUcIP10_EIF8,57
-langflow_base_nightly-0.5.0.dev28.dist-info/RECORD,,
+langflow_base_nightly-0.5.0.dev30.dist-info/METADATA,sha256=kFgHD6t-C99NX4tCoSrxW1wTbfbFCFr3mcVdEipr_IQ,4173
+langflow_base_nightly-0.5.0.dev30.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+langflow_base_nightly-0.5.0.dev30.dist-info/entry_points.txt,sha256=JvuLdXSrkeDmDdpb8M-VvFIzb84n4HmqUcIP10_EIF8,57
+langflow_base_nightly-0.5.0.dev30.dist-info/RECORD,,