more clean up

Author: patrickkang

examples/example-fastmcp-mcp/src/auth0/__init__.py

@@ -6,6 +6,7 @@
 """
 
 from mcp.server.auth.routes import create_protected_resource_routes
+from mcp.server.fastmcp import FastMCP
 from starlette.middleware import Middleware
 from starlette.routing import Route, Router
 
@@ -19,6 +20,15 @@ def __init__(self, name: str, audience: str, domain: str):
         self.domain = domain
         if not self.audience or not self.domain:
             raise RuntimeError("audience and domain must be provided")
+        self.mcp = FastMCP(
+            name="Auth0 Protected MCP Server",
+            stateless_http=True,
+        )
+        self._scopes_supported = {
+            "openid",
+            "profile",
+            "email"
+        }
 
     def auth_metadata_router(self) -> Router:
         """
@@ -28,15 +38,21 @@ def auth_metadata_router(self) -> Router:
         routes: list[Route] = create_protected_resource_routes(
             resource_url=self.audience,
             authorization_servers=[f"https://{self.domain}"],
-            scopes_supported=[
-                "openid",
-                "profile",
-                "email",
-            ],
+            scopes_supported=list(self._scopes_supported),
             resource_name=self.name,
         )
 
         return Router(routes=routes)
 
     def auth_middleware(self) -> list[Middleware]:
         return [Middleware(Auth0Middleware, domain=self.domain, audience=self.audience)]
+
+    def register_scopes(self, scopes: list[str]) -> None:
+        """
+        Register scopes that tools require.
+
+        Args:
+            scopes: List of scopes to register (e.g., ["tool:greet", "tool:whoami"])
+        """
+        if scopes:
+            self._scopes_supported.update(scopes)

examples/example-fastmcp-mcp/src/auth0/tools.py

@@ -10,7 +10,7 @@
 from mcp.server.fastmcp import Context
 
 
-def create_scoped_tool_decorator(mcp_server):
+def create_scoped_tool_decorator(auth0Mcp):
     """Factory function to create a scoped_tool decorator bound to a MCP server instance."""
 
     def scoped_tool(
@@ -29,6 +29,11 @@ def scoped_tool(
             def sensitive_tool(data: str, ctx: Context) -> str:
                 return f"Processing: {data}"
         """
+
+        if required_scopes:
+            # register scopes for PRM
+            auth0Mcp.register_scopes(required_scopes)
+
         def decorator(func: Callable) -> Callable:
             @wraps(func)
             async def scope_checked_wrapper(*args, **kwargs):
@@ -76,7 +81,7 @@ async def scope_checked_wrapper(*args, **kwargs):
                     return func(*args, **kwargs)
 
             # Register the wrapped function as an MCP tool
-            mcp_server.add_tool(
+            auth0Mcp.mcp.add_tool(
                 scope_checked_wrapper,
                 **tool_kwargs
             )

examples/example-fastmcp-mcp/src/mcp.py

@@ -9,7 +9,7 @@
 from starlette.routing import Mount
 
 from .auth0 import Auth0Mcp
-from .mcp import mcp
+from .tools import register_tools
 
 load_dotenv()
 
@@ -22,14 +22,12 @@
     audience=os.getenv("AUTH0_AUDIENCE"),
     domain=os.getenv("AUTH0_DOMAIN")
 )
+register_tools(auth0_mcp)
 
 @contextlib.asynccontextmanager
 async def lifespan(app: Starlette) -> AsyncIterator[None]:
     async with contextlib.AsyncExitStack() as stack:
-        await stack.enter_async_context(mcp.session_manager.run())
-
-        # Import tools here to ensure tools are loaded after mcp is initialized
-        from . import tools  # noqa: F401, I001
+        await stack.enter_async_context(auth0_mcp.mcp.session_manager.run())
         yield
 
 starlette_app = Starlette(
@@ -41,7 +39,7 @@ async def lifespan(app: Starlette) -> AsyncIterator[None]:
         # Main MCP app route with authentication middleware
         Mount(
             "/",
-            app=mcp.streamable_http_app(),
+            app=auth0_mcp.mcp.streamable_http_app(),
             middleware=auth0_mcp.auth_middleware()
         ),
     ],

examples/example-fastmcp-mcp/src/server.py

@@ -3,46 +3,50 @@
 from mcp.server.fastmcp import Context
 
 from .auth0.tools import create_scoped_tool_decorator, get_auth_info
-from .mcp import mcp
 
-# Create a scoped_tool decorator bound to the mcp instance
-scoped_tool = create_scoped_tool_decorator(mcp)
+def register_tools(auth0Mcp):
+    """
+    Register all tools with the MCP server.
+    """
+    mcp = auth0Mcp.mcp
+    # Create a scoped_tool decorator bound to the mcp instance
+    scoped_tool = create_scoped_tool_decorator(auth0Mcp)
 
-# Tool without required scopes
-@mcp.tool()
-def echo(text: str) -> str:
-    """Echoes the input text"""
-    return text
+    # Tool without required scopes
+    @mcp.tool()
+    def echo(text: str) -> str:
+        """Echoes the input text"""
+        return text
 
-# A MCP tool with required scopes
-@scoped_tool(
-    required_scopes=["tool:greet"],
-    name="greet",
-    title="Greet Tool",
-    description="Greets a user",
-    annotations={"readOnlyHint": True}
-)
-def greet(name: str, ctx: Context) -> str:
-    name = (name or "").strip() or "world"
-    request = ctx.request_context.request
-    auth_info = get_auth_info(request)
-    user_id = auth_info.get("extra", {}).get("sub")
-    return f"Hello, {name}! You are authenticated as {user_id}"
+    # A MCP tool with required scopes
+    @scoped_tool(
+        required_scopes=["tool:greet"],
+        name="greet",
+        title="Greet Tool",
+        description="Greets a user",
+        annotations={"readOnlyHint": True}
+    )
+    def greet(name: str, ctx: Context) -> str:
+        name = (name or "").strip() or "world"
+        request = ctx.request_context.request
+        auth_info = get_auth_info(request)
+        user_id = auth_info.get("extra", {}).get("sub")
+        return f"Hello, {name}! You are authenticated as {user_id}"
 
-# A MCP tool with required scopes
-@scoped_tool(
-    required_scopes=["tool:whoami"],
-    name="whoami",
-    title="Who Am I Tool",
-    description="Returns information about the authenticated user",
-    annotations={"readOnlyHint": True}
-)
-def whoami(ctx: Context) -> str:
-    request = ctx.request_context.request
-    auth_info = get_auth_info(request)
+    # A MCP tool with required scopes
+    @scoped_tool(
+        required_scopes=["tool:whoami"],
+        name="whoami",
+        title="Who Am I Tool",
+        description="Returns information about the authenticated user",
+        annotations={"readOnlyHint": True}
+    )
+    def whoami(ctx: Context) -> str:
+        request = ctx.request_context.request
+        auth_info = get_auth_info(request)
 
-    response_data = {
-        "user": auth_info.get("extra", {}),
-        "scopes": auth_info.get("scopes", []),
-    }
-    return jsonDumps(response_data, indent=2)
+        response_data = {
+            "user": auth_info.get("extra", {}),
+            "scopes": auth_info.get("scopes", []),
+        }
+        return jsonDumps(response_data, indent=2)