Spaces:
Sleeping
Sleeping
| """Synchronous MCP client for Flask (stdio subprocess).""" | |
| from __future__ import annotations | |
| import asyncio | |
| import atexit | |
| import os | |
| import threading | |
| from typing import Any | |
| from backend.mcp_client import PaperMCPClient | |
| _client: PaperMCPClient | None = None | |
| _connect_lock = threading.Lock() | |
| _shutdown_registered = False | |
| _loop: asyncio.AbstractEventLoop | None = None | |
| _loop_thread: threading.Thread | None = None | |
| _loop_ready = threading.Event() | |
| def use_mcp() -> bool: | |
| return os.getenv("USE_MCP", "1").lower() in {"1", "true", "yes"} | |
| def _start_loop_thread() -> asyncio.AbstractEventLoop: | |
| global _loop, _loop_thread | |
| if _loop is not None and _loop.is_running(): | |
| return _loop | |
| def _runner() -> None: | |
| global _loop | |
| loop = asyncio.new_event_loop() | |
| asyncio.set_event_loop(loop) | |
| _loop = loop | |
| _loop_ready.set() | |
| loop.run_forever() | |
| _loop_ready.clear() | |
| _loop_thread = threading.Thread(target=_runner, daemon=True, name="mcp-async-loop") | |
| _loop_thread.start() | |
| _loop_ready.wait() | |
| if _loop is None: | |
| raise RuntimeError("MCP event loop failed to start.") | |
| return _loop | |
| def _run_async(coro, *, timeout: float = 600): | |
| loop = _start_loop_thread() | |
| future = asyncio.run_coroutine_threadsafe(coro, loop) | |
| return future.result(timeout=timeout) | |
| def ensure_mcp_connected() -> PaperMCPClient: | |
| global _client, _shutdown_registered | |
| if _client is not None and _client._session is not None: | |
| return _client | |
| with _connect_lock: | |
| if _client is not None and _client._session is not None: | |
| return _client | |
| client = PaperMCPClient() | |
| _run_async(client.connect()) | |
| _client = client | |
| if not _shutdown_registered: | |
| atexit.register(shutdown_mcp) | |
| _shutdown_registered = True | |
| return _client | |
| def shutdown_mcp() -> None: | |
| global _client, _loop | |
| if _client is None: | |
| return | |
| try: | |
| _run_async(_client.close(), timeout=30) | |
| except Exception: | |
| pass | |
| _client = None | |
| if _loop is not None and _loop.is_running(): | |
| _loop.call_soon_threadsafe(_loop.stop) | |
| def call_mcp_tool(name: str, arguments: dict[str, Any] | None = None) -> Any: | |
| client = ensure_mcp_connected() | |
| return _run_async(client.call_tool(name, arguments)) | |