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

langflow/api/v1/mcp_projects.py

@@ -1,6 +1,5 @@
 import asyncio
 import json
-import logging
 import os
 import platform
 from asyncio.subprocess import create_subprocess_exec
@@ -29,19 +28,12 @@ from langflow.api.v1.mcp_utils import (
     handle_mcp_errors,
     handle_read_resource,
 )
-from langflow.api.v1.schemas import (
-    MCPInstallRequest,
-    MCPProjectResponse,
-    MCPProjectUpdateRequest,
-    MCPSettings,
-)
+from langflow.api.v1.schemas import MCPInstallRequest, MCPProjectResponse, MCPProjectUpdateRequest, MCPSettings
 from langflow.base.mcp.constants import MAX_MCP_SERVER_NAME_LENGTH
 from langflow.base.mcp.util import sanitize_mcp_name
+from langflow.logging import logger
 from langflow.services.database.models import Flow, Folder
 from langflow.services.deps import get_settings_service, session_scope
-from langflow.services.settings.feature_flags import FEATURE_FLAGS
-
-logger = logging.getLogger(__name__)
 
 router = APIRouter(prefix="/mcp/project", tags=["mcp_projects"])
 
@@ -117,7 +109,7 @@ async def list_project_tools(
                     tools.append(tool)
                 except Exception as e:  # noqa: BLE001
                     msg = f"Error in listing project tools: {e!s} from flow: {name}"
-                    logger.warning(msg)
+                    await logger.awarning(msg)
                     continue
 
             # Get project-level auth settings
@@ -129,14 +121,14 @@ async def list_project_tools(
 
     except Exception as e:
         msg = f"Error listing project tools: {e!s}"
-        logger.exception(msg)
+        await logger.aexception(msg)
         raise HTTPException(status_code=500, detail=str(e)) from e
 
     return MCPProjectResponse(tools=tools, auth_settings=auth_settings)
 
 
 @router.head("/{project_id}/sse", response_class=HTMLResponse, include_in_schema=False)
-async def im_alive():
+async def im_alive(project_id: str):  # noqa: ARG001
     return Response()
 
 
@@ -159,7 +151,7 @@ async def handle_project_sse(
     # Get project-specific SSE transport and MCP server
     sse = get_project_sse(project_id)
     project_server = get_project_mcp_server(project_id)
-    logger.debug("Project MCP server name: %s", project_server.server.name)
+    await logger.adebug("Project MCP server name: %s", project_server.server.name)
 
     # Set context variables
     user_token = current_user_ctx.set(current_user)
@@ -168,7 +160,7 @@ async def handle_project_sse(
     try:
         async with sse.connect_sse(request.scope, request.receive, request._send) as streams:
             try:
-                logger.debug("Starting SSE connection for project %s", project_id)
+                await logger.adebug("Starting SSE connection for project %s", project_id)
 
                 notification_options = NotificationOptions(
                     prompts_changed=True, resources_changed=True, tools_changed=True
@@ -177,15 +169,15 @@ async def handle_project_sse(
 
                 try:
                     await project_server.server.run(streams[0], streams[1], init_options)
-                except Exception:
-                    logger.exception("Error in project MCP")
+                except Exception:  # noqa: BLE001
+                    await logger.aexception("Error in project MCP")
             except BrokenResourceError:
-                logger.info("Client disconnected from project SSE connection")
+                await logger.ainfo("Client disconnected from project SSE connection")
             except asyncio.CancelledError:
-                logger.info("Project SSE connection was cancelled")
+                await logger.ainfo("Project SSE connection was cancelled")
                 raise
             except Exception:
-                logger.exception("Error in project MCP")
+                await logger.aexception("Error in project MCP")
                 raise
     finally:
         current_user_ctx.reset(user_token)
@@ -214,7 +206,7 @@ async def handle_project_messages(project_id: UUID, request: Request, current_us
         sse = get_project_sse(project_id)
         await sse.handle_post_message(request.scope, request.receive, request._send)
     except BrokenResourceError as e:
-        logger.info("Project MCP Server disconnected for project %s", project_id)
+        await logger.ainfo("Project MCP Server disconnected for project %s", project_id)
         raise HTTPException(status_code=404, detail=f"Project MCP Server disconnected, error: {e}") from e
     finally:
         current_user_ctx.reset(user_token)
@@ -280,7 +272,7 @@ async def update_project_mcp_settings(
 
     except Exception as e:
         msg = f"Error updating project MCP settings: {e!s}"
-        logger.exception(msg)
+        await logger.aexception(msg)
         raise HTTPException(status_code=500, detail=str(e)) from e
 
 
@@ -368,13 +360,12 @@ async def install_mcp_config(
         # Determine command and args based on operating system
         os_type = platform.system()
         command = "uvx"
-        mcp_tool = "mcp-composer" if FEATURE_FLAGS.mcp_composer else "mcp-proxy"
 
         # Check if running on WSL (will appear as Linux but with Microsoft in release info)
         is_wsl = os_type == "Linux" and "microsoft" in platform.uname().release.lower()
 
         if is_wsl:
-            logger.debug("WSL detected, using Windows-specific configuration")
+            await logger.adebug("WSL detected, using Windows-specific configuration")
 
             # If we're in WSL and the host is localhost, we might need to adjust the URL
             # so Windows applications can reach the WSL service
@@ -393,43 +384,18 @@ async def install_mcp_config(
 
                     if proc.returncode == 0 and stdout.strip():
                         wsl_ip = stdout.decode().strip().split()[0]  # Get first IP address
-                        logger.debug("Using WSL IP for external access: %s", wsl_ip)
+                        await logger.adebug("Using WSL IP for external access: %s", wsl_ip)
                         # Replace the localhost with the WSL IP in the URL
                         sse_url = sse_url.replace(f"http://{host}:{port}", f"http://{wsl_ip}:{port}")
                 except OSError as e:
-                    logger.warning("Failed to get WSL IP address: %s. Using default URL.", str(e))
-
-        # Configure args based on the MCP tool
-        oauth_env = None
-        if FEATURE_FLAGS.mcp_composer:
-            args = [mcp_tool, "--sse-url", sse_url]
-
-            # Check for auth settings and add auth parameters
-            if project.auth_settings:
-                from langflow.api.v1.schemas import AuthSettings
-
-                auth_settings = AuthSettings(**project.auth_settings)
-                args.extend(["--auth_type", auth_settings.auth_type])
-
-                oauth_env = {
-                    "OAUTH_HOST": auth_settings.oauth_host,
-                    "OAUTH_PORT": auth_settings.oauth_port,
-                    "OAUTH_SERVER_URL": auth_settings.oauth_server_url,
-                    "OAUTH_CALLBACK_PATH": auth_settings.oauth_callback_path,
-                    "OAUTH_CLIENT_ID": auth_settings.oauth_client_id,
-                    "OAUTH_CLIENT_SECRET": auth_settings.oauth_client_secret,
-                    "OAUTH_AUTH_URL": auth_settings.oauth_auth_url,
-                    "OAUTH_TOKEN_URL": auth_settings.oauth_token_url,
-                    "OAUTH_MCP_SCOPE": auth_settings.oauth_mcp_scope,
-                    "OAUTH_PROVIDER_SCOPE": auth_settings.oauth_provider_scope,
-                }
+                    await logger.awarning("Failed to get WSL IP address: %s. Using default URL.", str(e))
         else:
-            args = [mcp_tool, sse_url]
+            args = ["mcp-proxy", sse_url]
 
         if os_type == "Windows":
             command = "cmd"
             args = ["/c", "uvx", *args]
-            logger.debug("Windows detected, using cmd command")
+            await logger.adebug("Windows detected, using cmd command")
 
         name = project.name
 
@@ -439,16 +405,12 @@ async def install_mcp_config(
             "args": args,
         }
 
-        # Add environment variables if mcp-composer feature flag is enabled and auth settings exist
-        if FEATURE_FLAGS.mcp_composer and oauth_env is not None:
-            server_config["env"] = oauth_env  # type: ignore[assignment]
-
         mcp_config = {
             "mcpServers": {f"lf-{sanitize_mcp_name(name)[: (MAX_MCP_SERVER_NAME_LENGTH - 4)]}": server_config}
         }
 
         server_name = f"lf-{sanitize_mcp_name(name)[: (MAX_MCP_SERVER_NAME_LENGTH - 4)]}"
-        logger.debug("Installing MCP config for project: %s (server name: %s)", project.name, server_name)
+        await logger.adebug("Installing MCP config for project: %s (server name: %s)", project.name, server_name)
 
         # Determine the config file path based on the client and OS
         if body.client.lower() == "cursor":
@@ -500,7 +462,7 @@ async def install_mcp_config(
                                     status_code=400, detail="Windows C: drive not mounted at /mnt/c in WSL"
                                 )
                     except (OSError, CalledProcessError) as e:
-                        logger.warning("Failed to determine Windows user path in WSL: %s", str(e))
+                        await logger.awarning("Failed to determine Windows user path in WSL: %s", str(e))
                         raise HTTPException(
                             status_code=400, detail=f"Could not determine Windows Claude config path in WSL: {e!s}"
                         ) from e
@@ -536,11 +498,11 @@ async def install_mcp_config(
 
     except Exception as e:
         msg = f"Error installing MCP configuration: {e!s}"
-        logger.exception(msg)
+        await logger.aexception(msg)
         raise HTTPException(status_code=500, detail=str(e)) from e
     else:
         message = f"Successfully installed MCP configuration for {body.client}"
-        logger.info(message)
+        await logger.ainfo(message)
         return {"message": message}
 
 
@@ -564,7 +526,7 @@ async def check_installed_mcp_servers(
         name = project.name
         project_server_name = f"lf-{sanitize_mcp_name(name)[: (MAX_MCP_SERVER_NAME_LENGTH - 4)]}"
 
-        logger.debug(
+        await logger.adebug(
             "Checking for installed MCP servers for project: %s (server name: %s)", project.name, project_server_name
         )
 
@@ -573,26 +535,28 @@ async def check_installed_mcp_servers(
 
         # Check Cursor configuration
         cursor_config_path = Path.home() / ".cursor" / "mcp.json"
-        logger.debug("Checking Cursor config at: %s (exists: %s)", cursor_config_path, cursor_config_path.exists())
+        await logger.adebug(
+            "Checking Cursor config at: %s (exists: %s)", cursor_config_path, cursor_config_path.exists()
+        )
         if cursor_config_path.exists():
             try:
                 with cursor_config_path.open("r") as f:
                     cursor_config = json.load(f)
                     if "mcpServers" in cursor_config and project_server_name in cursor_config["mcpServers"]:
-                        logger.debug("Found Cursor config for project server: %s", project_server_name)
+                        await logger.adebug("Found Cursor config for project server: %s", project_server_name)
                         results.append("cursor")
                     else:
-                        logger.debug(
+                        await logger.adebug(
                             "Cursor config exists but no entry for server: %s (available servers: %s)",
                             project_server_name,
                             list(cursor_config.get("mcpServers", {}).keys()),
                         )
             except json.JSONDecodeError:
-                logger.warning("Failed to parse Cursor config JSON at: %s", cursor_config_path)
+                await logger.awarning("Failed to parse Cursor config JSON at: %s", cursor_config_path)
 
         # Check Windsurf configuration
         windsurf_config_path = Path.home() / ".codeium" / "windsurf" / "mcp_config.json"
-        logger.debug(
+        await logger.adebug(
             "Checking Windsurf config at: %s (exists: %s)", windsurf_config_path, windsurf_config_path.exists()
         )
         if windsurf_config_path.exists():
@@ -600,16 +564,16 @@ async def check_installed_mcp_servers(
                 with windsurf_config_path.open("r") as f:
                     windsurf_config = json.load(f)
                     if "mcpServers" in windsurf_config and project_server_name in windsurf_config["mcpServers"]:
-                        logger.debug("Found Windsurf config for project server: %s", project_server_name)
+                        await logger.adebug("Found Windsurf config for project server: %s", project_server_name)
                         results.append("windsurf")
                     else:
-                        logger.debug(
+                        await logger.adebug(
                             "Windsurf config exists but no entry for server: %s (available servers: %s)",
                             project_server_name,
                             list(windsurf_config.get("mcpServers", {}).keys()),
                         )
             except json.JSONDecodeError:
-                logger.warning("Failed to parse Windsurf config JSON at: %s", windsurf_config_path)
+                await logger.awarning("Failed to parse Windsurf config JSON at: %s", windsurf_config_path)
 
         # Check Claude configuration
         claude_config_path = None
@@ -654,7 +618,7 @@ async def check_installed_mcp_servers(
                                     user_dirs[0] / "AppData" / "Roaming" / "Claude" / "claude_desktop_config.json"
                                 )
                 except (OSError, CalledProcessError) as e:
-                    logger.warning(
+                    await logger.awarning(
                         "Failed to determine Windows user path in WSL for checking Claude config: %s", str(e)
                     )
                     # Don't set claude_config_path, so it will be skipped
@@ -663,27 +627,27 @@ async def check_installed_mcp_servers(
                 claude_config_path = Path(os.environ["APPDATA"]) / "Claude" / "claude_desktop_config.json"
 
         if claude_config_path and claude_config_path.exists():
-            logger.debug("Checking Claude config at: %s", claude_config_path)
+            await logger.adebug("Checking Claude config at: %s", claude_config_path)
             try:
                 with claude_config_path.open("r") as f:
                     claude_config = json.load(f)
                     if "mcpServers" in claude_config and project_server_name in claude_config["mcpServers"]:
-                        logger.debug("Found Claude config for project server: %s", project_server_name)
+                        await logger.adebug("Found Claude config for project server: %s", project_server_name)
                         results.append("claude")
                     else:
-                        logger.debug(
+                        await logger.adebug(
                             "Claude config exists but no entry for server: %s (available servers: %s)",
                             project_server_name,
                             list(claude_config.get("mcpServers", {}).keys()),
                         )
             except json.JSONDecodeError:
-                logger.warning("Failed to parse Claude config JSON at: %s", claude_config_path)
+                await logger.awarning("Failed to parse Claude config JSON at: %s", claude_config_path)
         else:
-            logger.debug("Claude config path not found or doesn't exist: %s", claude_config_path)
+            await logger.adebug("Claude config path not found or doesn't exist: %s", claude_config_path)
 
     except Exception as e:
         msg = f"Error checking MCP configuration: {e!s}"
-        logger.exception(msg)
+        await logger.aexception(msg)
         raise HTTPException(status_code=500, detail=str(e)) from e
     return results
 
@@ -750,11 +714,11 @@ async def init_mcp_servers():
                 try:
                     get_project_sse(project.id)
                     get_project_mcp_server(project.id)
-                except Exception as e:
+                except Exception as e:  # noqa: BLE001
                     msg = f"Failed to initialize MCP server for project {project.id}: {e}"
-                    logger.exception(msg)
+                    await logger.aexception(msg)
                     # Continue to next project even if this one fails
 
-    except Exception as e:
+    except Exception as e:  # noqa: BLE001
         msg = f"Failed to initialize MCP servers: {e}"
-        logger.exception(msg)
+        await logger.aexception(msg)

langflow/api/v1/mcp_utils.py

@@ -12,7 +12,6 @@ from typing import Any, ParamSpec, TypeVar
 from urllib.parse import quote, unquote, urlparse
 from uuid import uuid4
 
-from loguru import logger
 from mcp import types
 from sqlmodel import select
 
@@ -21,6 +20,7 @@ from langflow.api.v1.schemas import SimplifiedAPIRequest
 from langflow.base.mcp.constants import MAX_MCP_TOOL_NAME_LENGTH
 from langflow.base.mcp.util import get_flow_snake_case, get_unique_name, sanitize_mcp_name
 from langflow.helpers.flow import json_schema_from_flow
+from langflow.logging.logger import logger
 from langflow.schema.message import Message
 from langflow.services.database.models import Flow
 from langflow.services.database.models.user.model import User
@@ -43,7 +43,7 @@ def handle_mcp_errors(func: Callable[P, Awaitable[T]]) -> Callable[P, Awaitable[
             return await func(*args, **kwargs)
         except Exception as e:
             msg = f"Error in {func.__name__}: {e!s}"
-            logger.exception(msg)
+            await logger.aexception(msg)
             raise
 
     return wrapper
@@ -108,11 +108,11 @@ async def handle_list_resources(project_id=None):
                             resources.append(resource)
                     except FileNotFoundError as e:
                         msg = f"Error listing files for flow {flow.id}: {e}"
-                        logger.debug(msg)
+                        await logger.adebug(msg)
                         continue
     except Exception as e:
         msg = f"Error in listing resources: {e!s}"
-        logger.exception(msg)
+        await logger.aexception(msg)
         raise
     return resources
 
@@ -150,7 +150,7 @@ async def handle_read_resource(uri: str) -> bytes:
         return base64.b64encode(content)
     except Exception as e:
         msg = f"Error reading resource {uri}: {e!s}"
-        logger.exception(msg)
+        await logger.aexception(msg)
         raise
 
 
@@ -271,7 +271,7 @@ async def handle_call_tool(
         return await with_db_session(execute_tool)
     except Exception as e:
         msg = f"Error executing tool {name}: {e!s}"
-        logger.exception(msg)
+        await logger.aexception(msg)
         raise
 
 
@@ -339,10 +339,10 @@ async def handle_list_tools(project_id=None, *, mcp_enabled_only=False):
                     existing_names.add(name)
                 except Exception as e:  # noqa: BLE001
                     msg = f"Error in listing tools: {e!s} from flow: {base_name}"
-                    logger.warning(msg)
+                    await logger.awarning(msg)
                     continue
     except Exception as e:
         msg = f"Error in listing tools: {e!s}"
-        logger.exception(msg)
+        await logger.aexception(msg)
         raise
     return tools

langflow/api/v1/schemas.py

@@ -444,12 +444,8 @@ class CancelFlowResponse(BaseModel):
 class AuthSettings(BaseModel):
     """Model representing authentication settings for MCP."""
 
-    auth_type: Literal["none", "apikey", "basic", "bearer", "iam", "oauth"] = "none"
+    auth_type: Literal["none", "apikey", "oauth"] = "none"
     api_key: SecretStr | None = None
-    username: str | None = None
-    password: SecretStr | None = None
-    bearer_token: SecretStr | None = None
-    iam_endpoint: str | None = None
     oauth_host: str | None = None
     oauth_port: str | None = None
     oauth_server_url: str | None = None

langflow/api/v1/store.py

@@ -2,9 +2,9 @@ from typing import Annotated
 from uuid import UUID
 
 from fastapi import APIRouter, Depends, HTTPException, Query
-from loguru import logger
 
 from langflow.api.utils import CurrentActiveUser, check_langflow_version
+from langflow.logging.logger import logger
 from langflow.services.auth import utils as auth_utils
 from langflow.services.deps import get_settings_service, get_store_service
 from langflow.services.store.exceptions import CustomError

langflow/api/v1/validate.py

@@ -1,9 +1,9 @@
 from fastapi import APIRouter, HTTPException
-from loguru import logger
 
 from langflow.api.utils import CurrentActiveUser
 from langflow.api.v1.base import Code, CodeValidationResponse, PromptValidationResponse, ValidatePromptRequest
 from langflow.base.prompts.api_utils import process_prompt_template
+from langflow.logging.logger import logger
 from langflow.utils.validate import validate_code
 
 # build router
@@ -19,7 +19,7 @@ async def post_validate_code(code: Code, _current_user: CurrentActiveUser) -> Co
             function=errors.get("function", {}),
         )
     except Exception as e:
-        logger.opt(exception=True).debug("Error validating code")
+        logger.debug("Error validating code", exc_info=True)
         raise HTTPException(status_code=500, detail=str(e)) from e