Skip to content

Agent Zero AI framework

mcp urls fixed

frdel8ecd46cb207e
diff --git a/python/helpers/mcp_server.py b/python/helpers/mcp_server.py
index 36985a8b1..e1d9ad2f1 100644
--- a/python/helpers/mcp_server.py
+++ b/python/helpers/mcp_server.py
@@ -4,15 +4,20 @@ from typing import Annotated, Literal, Union
from urllib.parse import urlparse
from openai import BaseModel
from pydantic import Field
-import uuid
-import asyncio
from fastmcp import FastMCP
from agent import AgentContext, AgentContextType, UserMessage
from python.helpers.persist_chat import save_tmp_chat, remove_chat
from initialize import initialize
from python.helpers.print_style import PrintStyle
-from python.helpers.task_scheduler import DeferredTask
+from python.helpers import settings
+from starlette.middleware import Middleware
+from starlette.middleware.base import BaseHTTPMiddleware
+from starlette.exceptions import HTTPException as StarletteHTTPException
+from starlette.types import ASGIApp, Receive, Scope, Send
+from fastmcp.server.http import create_sse_app
+from starlette.requests import Request
+import threading
_PRINTER = PrintStyle(italic=True, font_color="green", padding=False)
@@ -260,3 +265,65 @@ async def _run_chat(
_PRINTER.print(f"MCP Chat message failed: {e}")
raise RuntimeError(f"MCP Chat message failed: {e}") from e
+
+
+class DynamicMcpProxy:
+ _instance: "DynamicMcpProxy | None" = None
+
+ """A dynamic proxy that allows swapping the underlying MCP application on the fly."""
+
+ def __init__(self):
+ cfg = settings.get_settings()
+ self.app: ASGIApp | None = None
+ self._lock = threading.RLock() # Use RLock to avoid deadlocks
+ self.reconfigure(cfg["mcp_server_token"])
+
+ @staticmethod
+ def get_instance():
+ if DynamicMcpProxy._instance is None:
+ DynamicMcpProxy._instance = DynamicMcpProxy()
+ return DynamicMcpProxy._instance
+
+ def reconfigure(self, token: str):
+ self.token = token
+ sse_path = f"/t-{self.token}/sse"
+ message_path = f"/t-{self.token}/messages/"
+
+ # Update settings in the MCP server instance if provided
+ mcp_server.settings.message_path = message_path
+ mcp_server.settings.sse_path = sse_path
+
+ # Create a new MCP app with updated settings
+ with self._lock:
+ self.app = create_sse_app(
+ server=mcp_server,
+ message_path=mcp_server.settings.message_path,
+ sse_path=mcp_server.settings.sse_path,
+ auth_server_provider=mcp_server._auth_server_provider,
+ auth_settings=mcp_server.settings.auth,
+ debug=mcp_server.settings.debug,
+ routes=mcp_server._additional_http_routes,
+ middleware=[Middleware(BaseHTTPMiddleware, dispatch=mcp_middleware)],
+ )
+
+ async def __call__(self, scope: Scope, receive: Receive, send: Send) -> None:
+ """Forward the ASGI calls to the current app"""
+ with self._lock:
+ app = self.app
+ if app:
+ await app(scope, receive, send)
+ else:
+ raise RuntimeError("MCP app not initialized")
+
+
+async def mcp_middleware(request: Request, call_next):
+
+ # check if MCP server is enabled
+ cfg = settings.get_settings()
+ if not cfg["mcp_server_enabled"]:
+ PrintStyle.error("[MCP] Access denied: MCP server is disabled in settings.")
+ raise StarletteHTTPException(
+ status_code=403, detail="MCP server is disabled in settings."
+ )
+
+ return await call_next(request)
\ No newline at end of file
diff --git a/python/helpers/settings.py b/python/helpers/settings.py
index adc3de4ec..b5e224daa 100644
--- a/python/helpers/settings.py
+++ b/python/helpers/settings.py
@@ -860,7 +860,7 @@ def normalize_settings(settings: Settings) -> Settings:
copy[key] = value # make default instead
# mcp server token is set automatically
- copy["mcp_server_token"] = create_token()
+ copy["mcp_server_token"] = create_auth_token()
return copy
@@ -887,6 +887,7 @@ def _remove_sensitive_settings(settings: Settings):
settings["auth_password"] = ""
settings["rfc_password"] = ""
settings["root_password"] = ""
+ settings["mcp_server_token"] = ""
def _write_sensitive_settings(settings: Settings):
@@ -956,7 +957,7 @@ def get_default_settings() -> Settings:
mcp_client_init_timeout=5,
mcp_client_tool_timeout=120,
mcp_server_enabled=False,
- mcp_server_token=create_token(),
+ mcp_server_token=create_auth_token(),
)
@@ -1039,6 +1040,21 @@ def _apply_settings(previous: Settings | None):
update_mcp_settings, config.mcp_servers
) # TODO overkill, replace with background task
+ # update token in mcp server
+ current_token = create_auth_token() #TODO - ugly, token in settings is generated from dotenv and does not always correspond
+ if (
+ not previous
+ or current_token != previous["mcp_server_token"]
+ ):
+
+ async def update_mcp_token(token: str):
+ from python.helpers.mcp_server import DynamicMcpProxy
+ DynamicMcpProxy.get_instance().reconfigure(token=token)
+
+ task3 = defer.DeferredTask().start_task(
+ update_mcp_token, current_token
+ ) # TODO overkill, replace with background task
+
def _env_to_dict(data: str):
env_dict = {}
@@ -1095,7 +1111,7 @@ def get_runtime_config(set: Settings):
}
-def create_token() -> str:
+def create_auth_token() -> str:
username = dotenv.get_dotenv_value(dotenv.KEY_AUTH_LOGIN) or ""
password = dotenv.get_dotenv_value(dotenv.KEY_AUTH_PASSWORD) or ""
if not username or not password:
@@ -1103,5 +1119,5 @@ def create_token() -> str:
# use base64 encoding for a more compact token with alphanumeric chars
hash_bytes = hashlib.sha256(f"{username}:{password}".encode()).digest()
# encode as base64 and remove any non-alphanumeric chars (like +, /, =)
- b64_token = base64.urlsafe_b64encode(hash_bytes).decode().replace('=', '')
+ b64_token = base64.urlsafe_b64encode(hash_bytes).decode().replace("=", "")
return b64_token[:16]
diff --git a/run_ui.py b/run_ui.py
index a607ec163..ff19e1924 100644
--- a/run_ui.py
+++ b/run_ui.py
@@ -3,13 +3,12 @@ import sys
import time
import socket
import struct
-import asyncio
from functools import wraps
import threading
import signal
from flask import Flask, request, Response
from flask_basicauth import BasicAuth
-from python.helpers import errors, files, git, settings
+from python.helpers import errors, files, git, mcp_server
from python.helpers.files import get_abs_path
from python.helpers import persist_chat, runtime, dotenv, process
from python.helpers.cloudflare_tunnel import CloudflareTunnel
@@ -17,11 +16,7 @@ from python.helpers.extract_tools import load_classes_from_folder
from python.helpers.api import ApiHandler
from python.helpers.job_loop import run_loop
from python.helpers.print_style import PrintStyle
-from python.helpers.task_scheduler import TaskScheduler
from python.helpers.defer import DeferredTask
-from starlette.middleware import Middleware
-from starlette.middleware.base import BaseHTTPMiddleware
-from starlette.exceptions import HTTPException as StarletteHTTPException
# Set the new timezone to 'UTC'
@@ -160,6 +155,7 @@ def run():
job_loop = DeferredTask().start_task(run_loop)
PrintStyle().print("Starting server...")
+
class NoRequestLoggingWSGIRequestHandler(WSGIRequestHandler):
def log_request(self, code="-", size="-"):
pass # Override to suppress request logging
@@ -238,64 +234,13 @@ def run():
for handler in handlers:
register_api_handler(webapp, handler)
-
- # define a Starlette-compatible middleware handler
- from starlette.requests import Request
- import re
-
- async def mcp_middleware(request: Request, call_next):
-
- # check if MCP server is enabled
- cfg = settings.get_settings()
- if not cfg["mcp_server_enabled"]:
- PrintStyle.error("[MCP] Access denied: MCP server is disabled in settings.")
- raise StarletteHTTPException(status_code=403,
- detail="MCP server is disabled in settings.")
-
- # get auth token from path
- full_path = request.url.path
- if not full_path.startswith("/mcp/t-"):
- raise StarletteHTTPException(status_code=401,
- detail="Missing token.")
- pattern = r'^/mcp/t-([^/]+)/(.+)$'
- match = re.match(pattern, full_path)
- if not match:
- raise StarletteHTTPException(status_code=401,
- detail="Missing token.")
- token = match.group(1)
- remainder = match.group(2)
-
- # validate token
- if token != cfg["mcp_server_token"]:
- raise StarletteHTTPException(status_code=401,
- detail="Invalid token.")
-
- # rewrite path to standard MCP path and continue
- new_path = f"/mcp/{remainder}"
- request.scope["path"] = new_path
- request.scope["raw_path"] = new_path.encode()
- # request.state.token = token
-
- return await call_next(request)
-
-
- mcp_middlewares = [Middleware(BaseHTTPMiddleware, dispatch=mcp_middleware)]
-
- mcp_app = create_sse_app(
- server=mcp_server_instance,
- message_path=mcp_server_instance.settings.message_path,
- sse_path=mcp_server_instance.settings.sse_path,
- auth_server_provider=mcp_server_instance._auth_server_provider,
- auth_settings=mcp_server_instance.settings.auth,
- debug=mcp_server_instance.settings.debug,
- routes=mcp_server_instance._additional_http_routes,
- middleware=mcp_middlewares
- )
-
# add the webapp and mcp to the app
- app = DispatcherMiddleware(webapp, {
- "/mcp": ASGIMiddleware(app=mcp_app), # type: ignore
- }) # type: ignore
+ app = DispatcherMiddleware(
+ webapp,
+ {
+ "/mcp": ASGIMiddleware(app=mcp_server.DynamicMcpProxy.get_instance()), # type: ignore
+ },
+ )
PrintStyle().debug("Registered middleware for MCP and MCP token")
try:
@@ -329,21 +274,24 @@ def run():
process.set_server(server)
server.log_startup()
-
+
# Start init_a0 in a background thread when server starts
import threading
+
threading.Thread(target=init_a0, daemon=True).start()
-
+
server.serve_forever()
finally:
# Clean up tunnel if it was started
if tunnel:
tunnel.stop()
+
def init_a0():
# initialize contexts from persisted chats
persist_chat.load_tmp_chats()
+
# run the internal server
if __name__ == "__main__":
runtime.initialize()