fastmcp 2.2.3__tar.gz → 2.2.4__tar.gz

{fastmcp-2.2.3 → fastmcp-2.2.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fastmcp
-Version: 2.2.3
+Version: 2.2.4
 Summary: The fast, Pythonic way to build MCP servers.
 Project-URL: Homepage, https://gofastmcp.com
 Project-URL: Repository, https://github.com/jlowin/fastmcp
@@ -141,7 +141,7 @@ FastMCP aims to be:
 ### Servers
 - **Create** servers with minimal boilerplate using intuitive decorators
 - **Proxy** existing servers to modify configuration or transport
-- **Compose** servers by into complex applications
+- **Compose**  servers into complex applications
 - **Generate** servers from OpenAPI specs or FastAPI objects
 
 ### Clients

{fastmcp-2.2.3 → fastmcp-2.2.4}/README.md

@@ -112,7 +112,7 @@ FastMCP aims to be:
 ### Servers
 - **Create** servers with minimal boilerplate using intuitive decorators
 - **Proxy** existing servers to modify configuration or transport
-- **Compose** servers by into complex applications
+- **Compose**  servers into complex applications
 - **Generate** servers from OpenAPI specs or FastAPI objects
 
 ### Clients

{fastmcp-2.2.3 → fastmcp-2.2.4}/docs/servers/resources.mdx

@@ -251,13 +251,18 @@ With these two templates defined, clients can request a variety of resources:
 
 <VersionBadge version="2.2.3" />
 
+<Warning>
+Please note: the Model Context Protocol URI standard follows RFC 6570, which does not include support for wildcard parameters. FastMCP extends the template syntax to support wildcards (`{param*}`), and because template matching happens entirely in the FastMCP server, it is not expected that these wildcards will cause compatibility issues with other MCP implementations. However, this can not be guaranteed.
+</Warning>
+
 Resource templates support wildcard parameters that can match multiple path segments. While standard parameters (`{param}`) only match a single path segment and don't cross "/" boundaries, wildcard parameters (`{param*}`) can capture multiple segments including slashes. Wildcards capture all subsequent path segments *up until* the defined part of the URI template (whether literal or another parameter). This allows you to have multiple wildcard parameters in a single URI template.
 
-```python
+```python {15, 23}
 from fastmcp import FastMCP
 
 mcp = FastMCP(name="DataServer")
 
+
 # Standard parameter only matches one segment
 @mcp.resource("files://{filename}")
 def get_file(filename: str) -> str:
@@ -265,6 +270,7 @@ def get_file(filename: str) -> str:
     # Will only match files://<single-segment>
     return f"File content for: {filename}"
 
+
 # Wildcard parameter can match multiple segments
 @mcp.resource("path://{filepath*}")
 def get_path_content(filepath: str) -> str:
@@ -272,6 +278,7 @@ def get_path_content(filepath: str) -> str:
     # Can match path://docs/server/resources.mdx
     return f"Content at path: {filepath}"
 
+
 # Mixing standard and wildcard parameters
 @mcp.resource("repo://{owner}/{path*}/template.py")
 def get_template_file(owner: str, path: str) -> dict:

{fastmcp-2.2.3 → fastmcp-2.2.4}/src/fastmcp/cli/cli.py

@@ -223,6 +223,27 @@ def dev(
             help="Additional packages to install",
         ),
     ] = [],
+    inspector_version: Annotated[
+        str | None,
+        typer.Option(
+            "--inspector-version",
+            help="Version of the MCP Inspector to use",
+        ),
+    ] = None,
+    ui_port: Annotated[
+        int | None,
+        typer.Option(
+            "--ui-port",
+            help="Port for the MCP Inspector UI",
+        ),
+    ] = None,
+    server_port: Annotated[
+        int | None,
+        typer.Option(
+            "--server-port",
+            help="Port for the MCP Inspector Proxy server",
+        ),
+    ] = None,
 ) -> None:
     """Run a MCP server with the MCP Inspector."""
     file, server_object = _parse_file_path(file_spec)
@@ -234,6 +255,8 @@ def dev(
             "server_object": server_object,
             "with_editable": str(with_editable) if with_editable else None,
             "with_packages": with_packages,
+            "ui_port": ui_port,
+            "server_port": server_port,
         },
     )
 
@@ -243,7 +266,11 @@ def dev(
         if hasattr(server, "dependencies"):
             with_packages = list(set(with_packages + server.dependencies))
 
-        uv_cmd = _build_uv_command(file_spec, with_editable, with_packages)
+        env_vars = {}
+        if ui_port:
+            env_vars["CLIENT_PORT"] = str(ui_port)
+        if server_port:
+            env_vars["SERVER_PORT"] = str(server_port)
 
         # Get the correct npx command
         npx_cmd = _get_npx_command()
@@ -254,13 +281,19 @@ def dev(
             )
             sys.exit(1)
 
+        inspector_cmd = "@modelcontextprotocol/inspector"
+        if inspector_version:
+            inspector_cmd += f"@{inspector_version}"
+
+        uv_cmd = _build_uv_command(file_spec, with_editable, with_packages)
+
         # Run the MCP Inspector command with shell=True on Windows
         shell = sys.platform == "win32"
         process = subprocess.run(
-            [npx_cmd, "@modelcontextprotocol/inspector"] + uv_cmd,
+            [npx_cmd, inspector_cmd] + uv_cmd,
             check=True,
             shell=shell,
-            env=dict(os.environ.items()),  # Convert to list of tuples for env update
+            env=dict(os.environ.items()) | env_vars,
         )
         sys.exit(process.returncode)
     except subprocess.CalledProcessError as e:

{fastmcp-2.2.3 → fastmcp-2.2.4}/src/fastmcp/resources/template.py

@@ -95,7 +95,7 @@ class ResourceTemplate(BaseModel):
             raise ValueError("You must provide a name for lambda functions")
 
         # Validate that URI params match function params
-        uri_params = set(re.findall(r"{(\w+)}", uri_template))
+        uri_params = set(re.findall(r"{(\w+)(?:\*)?}", uri_template))
         if not uri_params:
             raise ValueError("URI template must contain at least one parameter")
 

{fastmcp-2.2.3 → fastmcp-2.2.4}/src/fastmcp/server/openapi.py

@@ -257,7 +257,7 @@ class OpenAPIResource(Resource):
         self._client = client
         self._route = route
 
-    async def read(self) -> str:
+    async def read(self) -> str | bytes:
         """Fetch the resource data by making an HTTP request."""
         try:
             # Extract path parameters from the URI if present
@@ -297,15 +297,16 @@ class OpenAPIResource(Resource):
             # Raise for 4xx/5xx responses
             response.raise_for_status()
 
-            # Return response content based on mime type
-            if self.mime_type == "application/json":
-                try:
-                    return response.json()
-                except (json.JSONDecodeError, ValueError):
-                    # Fallback to returning the text
-                    return response.text
-            else:
+            # Determine content type and return appropriate format
+            content_type = response.headers.get("content-type", "").lower()
+
+            if "application/json" in content_type:
+                result = response.json()
+                return json.dumps(result)
+            elif any(ct in content_type for ct in ["text/", "application/xml"]):
                 return response.text
+            else:
+                return response.content
 
         except httpx.HTTPStatusError as e:
             # Handle HTTP errors (4xx, 5xx)
@@ -343,59 +344,13 @@ class OpenAPIResourceTemplate(ResourceTemplate):
             uri_template=uri_template,
             name=name,
             description=description,
-            fn=self._create_resource_fn,
+            fn=lambda **kwargs: None,
             parameters=parameters,
             tags=tags,
         )
         self._client = client
         self._route = route
 
-    async def _create_resource_fn(self, **kwargs):
-        """Create a resource with parameters."""
-        # Prepare the path with parameters
-        path = self._route.path
-        for param_name, param_value in kwargs.items():
-            path = path.replace(f"{{{param_name}}}", str(param_value))
-
-        try:
-            response = await self._client.request(
-                method=self._route.method,
-                url=path,
-                timeout=30.0,  # Default timeout
-            )
-
-            # Raise for 4xx/5xx responses
-            response.raise_for_status()
-
-            # Determine the mime type from the response
-            content_type = response.headers.get("content-type", "application/json")
-            mime_type = content_type.split(";")[0].strip()
-
-            # Return the appropriate data
-            if mime_type == "application/json":
-                try:
-                    return response.json()
-                except (json.JSONDecodeError, ValueError):
-                    return response.text
-            else:
-                return response.text
-
-        except httpx.HTTPStatusError as e:
-            error_message = (
-                f"HTTP error {e.response.status_code}: {e.response.reason_phrase}"
-            )
-            try:
-                error_data = e.response.json()
-                error_message += f" - {error_data}"
-            except (json.JSONDecodeError, ValueError):
-                if e.response.text:
-                    error_message += f" - {e.response.text}"
-
-            raise ValueError(error_message)
-
-        except httpx.RequestError as e:
-            raise ValueError(f"Request error: {str(e)}")
-
     async def create_resource(self, uri: str, params: dict[str, Any]) -> Resource:
         """Create a resource with the given parameters."""
         # Generate a URI for this resource instance
@@ -409,9 +364,8 @@ class OpenAPIResourceTemplate(ResourceTemplate):
             route=self._route,
             uri=uri,
             name=f"{self.name}-{'-'.join(uri_parts)}",
-            description=self.description
-            or f"Resource for {self._route.path}",  # Provide default if None
-            mime_type="application/json",  # Default, will be updated when read
+            description=self.description or f"Resource for {self._route.path}",
+            mime_type="application/json",
             tags=set(self._route.tags or []),
         )
 

{fastmcp-2.2.3 → fastmcp-2.2.4}/src/fastmcp/utilities/func_metadata.py

@@ -7,7 +7,15 @@ from typing import (
     ForwardRef,
 )
 
-from pydantic import BaseModel, ConfigDict, Field, WithJsonSchema, create_model
+from pydantic import (
+    BaseModel,
+    ConfigDict,
+    Field,
+    TypeAdapter,
+    ValidationError,
+    WithJsonSchema,
+    create_model,
+)
 from pydantic._internal._typing_extra import eval_type_backport
 from pydantic.fields import FieldInfo
 from pydantic_core import PydanticUndefined
@@ -80,14 +88,18 @@ class FuncMetadata(BaseModel):
         dicts (JSON objects) as JSON strings, which can be pre-parsed here.
         """
         new_data = data.copy()  # Shallow copy
-        for field_name, _field_info in self.arg_model.model_fields.items():
+        for field_name, field_info in self.arg_model.model_fields.items():
             if field_name not in data.keys():
                 continue
             if isinstance(data[field_name], str):
                 try:
                     pre_parsed = json.loads(data[field_name])
-                except json.JSONDecodeError:
-                    continue  # Not JSON - skip
+
+                    # Check if the pre_parsed value is valid for the field
+                    validator = TypeAdapter(field_info.annotation)
+                    validator.validate_python(pre_parsed)
+                except (json.JSONDecodeError, ValidationError):
+                    continue  # Not JSON or invalid for the field
                 if isinstance(pre_parsed, str | int | float):
                     # This is likely that the raw value is e.g. `"hello"` which we
                     # Should really be parsed as '"hello"' in Python - but if we parse

{fastmcp-2.2.3 → fastmcp-2.2.4}/tests/resources/test_resource_template.py

@@ -297,6 +297,66 @@ class TestResourceTemplate:
         content = await resource.read()
         assert content == "hello"
 
+    async def test_wildcard_param_can_create_resource(self):
+        """Test that wildcard parameters are valid."""
+
+        def identity(path: str) -> str:
+            return path
+
+        template = ResourceTemplate.from_function(
+            fn=identity,
+            uri_template="test://{path*}.py",
+            name="test",
+        )
+
+        assert await template.create_resource(
+            "test://path/to/test.py",
+            {"path": "path/to/test.py"},
+        )
+
+    async def test_wildcard_param_matches(self):
+        def identify(path: str) -> str:
+            return path
+
+        template = ResourceTemplate.from_function(
+            fn=identify,
+            uri_template="test://src/{path*}.py",
+            name="test",
+        )
+        # Valid match
+        params = template.matches("test://src/path/to/test.py")
+        assert params == {"path": "path/to/test"}
+
+    async def test_multiple_wildcard_params(self):
+        """Test that multiple wildcard parameters are valid."""
+
+        def identity(path: str, path2: str) -> str:
+            return f"{path}/{path2}"
+
+        template = ResourceTemplate.from_function(
+            fn=identity,
+            uri_template="test://{path*}/xyz/{path2*}",
+            name="test",
+        )
+
+        params = template.matches("test://path/to/xyz/abc")
+        assert params == {"path": "path/to", "path2": "abc"}
+
+    async def test_wildcard_param_with_regular_param(self):
+        """Test that a wildcard parameter can be used with a regular parameter."""
+
+        def identity(prefix: str, path: str) -> str:
+            return f"{prefix}/{path}"
+
+        template = ResourceTemplate.from_function(
+            fn=identity,
+            uri_template="test://{prefix}/{path*}",
+            name="test",
+        )
+
+        params = template.matches("test://src/path/to/test.py")
+        assert params == {"prefix": "src", "path": "path/to/test.py"}
+
 
 class TestMatchUriTemplate:
     """Test match_uri_template function."""
@@ -443,3 +503,20 @@ class TestMatchUriTemplate:
         uri_template = "test://a/{x}{y}"
         result = match_uri_template(uri=uri, uri_template=uri_template)
         assert result is None
+
+    @pytest.mark.parametrize(
+        "uri, expected_params",
+        [
+            ("file://abc/xyz.py", {"path": "xyz"}),
+            ("file://abc/x/y/z.py", {"path": "x/y/z"}),
+            ("file://abc/x/y/z/.py", {"path": "x/y/z/"}),
+            ("file://abc/x/y/z.md", None),
+            ("file://x/y/z.txt", None),
+        ],
+    )
+    def test_match_uri_template_with_non_slash_suffix(
+        self, uri: str, expected_params: dict[str, str]
+    ):
+        uri_template = "file://abc/{path*}.py"
+        result = match_uri_template(uri=uri, uri_template=uri_template)
+        assert result == expected_params