fastmcp 2.2.2__tar.gz → 2.2.3__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fastmcp
-Version: 2.2.2
+Version: 2.2.3
 Summary: The fast, Pythonic way to build MCP servers.
 Project-URL: Homepage, https://gofastmcp.com
 Project-URL: Repository, https://github.com/jlowin/fastmcp
@@ -361,32 +361,32 @@ The `Context` object provides:
 
 ### Images
 
-Easily handle image input and output using the `fastmcp.Image` helper class.
+Easily handle image outputs using the `fastmcp.Image` helper class.
+
+<Tip>
+The below code requires the `pillow` library to be installed.
+</Tip>
 
 ```python
-from fastmcp import FastMCP, Image
-from PIL import Image as PILImage
-import io
+from mcp.server.fastmcp import FastMCP, Image
+from io import BytesIO
+try:
+    from PIL import Image as PILImage
+except ImportError:
+    raise ImportError("Please install the `pillow` library to run this example.")
 
-mcp = FastMCP("Image Demo")
+mcp = FastMCP("My App")
 
 @mcp.tool()
-def create_thumbnail(image_data: Image) -> Image:
-    """Creates a 100x100 thumbnail from the provided image."""
-    img = PILImage.open(io.BytesIO(image_data.data)) # Assumes image_data received as Image with bytes
-    img.thumbnail((100, 100))
-    buffer = io.BytesIO()
+def create_thumbnail(image_path: str) -> Image:
+    """Create a thumbnail from an image"""
+    img = PILImage.open(image_path)
+    img.thumbnail((100, 100))    
+    buffer = BytesIO()
     img.save(buffer, format="PNG")
-    # Return a new Image object with the thumbnail data
     return Image(data=buffer.getvalue(), format="png")
-
-@mcp.tool()
-def load_image_from_disk(path: str) -> Image:
-    """Loads an image from the specified path."""
-    # Handles reading file and detecting format based on extension
-    return Image(path=path)
 ```
-FastMCP handles the conversion to/from the base64-encoded format required by the MCP protocol.
+Return the `Image` helper class from your tool to send an image to the client. The `Image` helper class handles the conversion to/from the base64-encoded format required by the MCP protocol. It works with either a path to an image file, or a bytes object.
 
 
 ### MCP Clients

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

@@ -332,32 +332,32 @@ The `Context` object provides:
 
 ### Images
 
-Easily handle image input and output using the `fastmcp.Image` helper class.
+Easily handle image outputs using the `fastmcp.Image` helper class.
+
+<Tip>
+The below code requires the `pillow` library to be installed.
+</Tip>
 
 ```python
-from fastmcp import FastMCP, Image
-from PIL import Image as PILImage
-import io
+from mcp.server.fastmcp import FastMCP, Image
+from io import BytesIO
+try:
+    from PIL import Image as PILImage
+except ImportError:
+    raise ImportError("Please install the `pillow` library to run this example.")
 
-mcp = FastMCP("Image Demo")
+mcp = FastMCP("My App")
 
 @mcp.tool()
-def create_thumbnail(image_data: Image) -> Image:
-    """Creates a 100x100 thumbnail from the provided image."""
-    img = PILImage.open(io.BytesIO(image_data.data)) # Assumes image_data received as Image with bytes
-    img.thumbnail((100, 100))
-    buffer = io.BytesIO()
+def create_thumbnail(image_path: str) -> Image:
+    """Create a thumbnail from an image"""
+    img = PILImage.open(image_path)
+    img.thumbnail((100, 100))    
+    buffer = BytesIO()
     img.save(buffer, format="PNG")
-    # Return a new Image object with the thumbnail data
     return Image(data=buffer.getvalue(), format="png")
-
-@mcp.tool()
-def load_image_from_disk(path: str) -> Image:
-    """Loads an image from the specified path."""
-    # Handles reading file and detecting format based on extension
-    return Image(path=path)
 ```
-FastMCP handles the conversion to/from the base64-encoded format required by the MCP protocol.
+Return the `Image` helper class from your tool to send an image to the client. The `Image` helper class handles the conversion to/from the base64-encoded format required by the MCP protocol. It works with either a path to an image file, or a bytes object.
 
 
 ### MCP Clients

{fastmcp-2.2.2 → fastmcp-2.2.3}/docs/clients/transports.mdx

@@ -5,6 +5,10 @@ description: Understand the different ways FastMCP Clients can connect to server
 icon: link
 ---
 
+import { VersionBadge } from "/snippets/version-badge.mdx"
+
+<VersionBadge version="2.0.0" />
+
 The FastMCP `Client` relies on a `ClientTransport` object to handle the specifics of connecting to and communicating with an MCP server. FastMCP provides several built-in transport implementations for common connection methods.
 
 While the `Client` often infers the correct transport automatically (see [Client Overview](/clients/client#transport-inference)), you can also instantiate transports explicitly for more control.

{fastmcp-2.2.2 → fastmcp-2.2.3}/docs/patterns/contrib.mdx

@@ -4,6 +4,9 @@ description: "Community-contributed modules extending FastMCP"
 icon: "cubes"
 ---
 
+import { VersionBadge } from "/snippets/version-badge.mdx"
+
+<VersionBadge version="2.2.1" />
 
 FastMCP includes a `contrib` package that holds community-contributed modules. These modules extend FastMCP's functionality but aren't officially maintained by the core team.
 

{fastmcp-2.2.2 → fastmcp-2.2.3}/docs/patterns/proxy.mdx

@@ -14,18 +14,20 @@ FastMCP provides a powerful proxying capability that allows one FastMCP server i
 
 Proxying means setting up a FastMCP server that doesn't implement its own tools or resources directly. Instead, when it receives a request (like `tools/call` or `resources/read`), it forwards that request to a *backend* MCP server, receives the response, and then relays that response back to the original client.
 
+
 ```mermaid
 sequenceDiagram
-    participant Client
-    participant ProxyServer as FastMCP Proxy Server
-    participant BackendServer as Backend MCP Server
-
-    Client->>ProxyServer: Request (e.g., stdio)
-    ProxyServer->>BackendServer: Request (e.g., sse)
-    BackendServer-->>ProxyServer: Response (e.g., sse)
-    ProxyServer-->>Client: Response (e.g., stdio)
+    participant ClientApp as Your Client (e.g., Claude Desktop)
+    participant FastMCPProxy as FastMCP Proxy Server
+    participant BackendServer as Backend MCP Server (e.g., remote SSE)
+
+    ClientApp->>FastMCPProxy: MCP Request (e.g. stdio)
+    Note over FastMCPProxy, BackendServer: Proxy forwards the request
+    FastMCPProxy->>BackendServer: MCP Request (e.g. sse)
+    BackendServer-->>FastMCPProxy: MCP Response (e.g. sse)
+    Note over ClientApp, FastMCPProxy: Proxy relays the response
+    FastMCPProxy-->>ClientApp: MCP Response (e.g. stdio)
 ```
-
 ### Use Cases
 
 -   **Transport Bridging**: Expose a server running on one transport (e.g., a remote SSE server) via a different transport (e.g., local Stdio for Claude Desktop).

{fastmcp-2.2.2 → fastmcp-2.2.3}/docs/servers/fastmcp.mdx

@@ -5,6 +5,8 @@ description: Learn about the core FastMCP server class and how to run it.
 icon: server
 ---
 
+import { VersionBadge } from "/snippets/version-badge.mdx"
+
 The central piece of a FastMCP application is the `FastMCP` server class. This class acts as the main container for your application's tools, resources, and prompts, and manages communication with MCP clients.
 
 ## Creating a Server
@@ -225,6 +227,8 @@ The CLI can dynamically find and run FastMCP server objects in your files, but i
 
 ## Composing Servers
 
+<VersionBadge version="2.2.0" />
+
 FastMCP supports composing multiple servers together using `import_server` (static copy) and `mount` (live link). This allows you to organize large applications into modular components or reuse existing servers.
 
 See the [Server Composition](/patterns/composition) guide for full details, best practices, and examples.
@@ -246,6 +250,8 @@ main.mount("sub", sub)
 
 ## Proxying Servers
 
+<VersionBadge version="2.0.0" />
+
 FastMCP can act as a proxy for any MCP server (local or remote) using `FastMCP.from_client`, letting you bridge transports or add a frontend to existing servers. For example, you can expose a remote SSE server locally via stdio, or vice versa.
 
 See the [Proxying Servers](/patterns/proxy) guide for details and advanced usage.

{fastmcp-2.2.2 → fastmcp-2.2.3}/docs/servers/prompts.mdx

@@ -5,6 +5,8 @@ description: Create reusable, parameterized prompt templates for MCP clients.
 icon: message-lines
 ---
 
+import { VersionBadge } from "/snippets/version-badge.mdx"
+
 Prompts are reusable message templates that help LLMs generate structured, purposeful responses. FastMCP simplifies defining these templates, primarily using the `@mcp.prompt` decorator.
 
 ## What Are Prompts?
@@ -201,6 +203,8 @@ Refer to the [Context documentation](/servers/context) for more details on these
 
 ### Duplicate Prompts
 
+<VersionBadge version="2.1.0" />
+
 You can configure how the FastMCP server handles attempts to register multiple prompts with the same name. Use the `on_duplicate_prompts` setting during `FastMCP` initialization.
 
 ```python

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

@@ -5,6 +5,8 @@ description: Expose data sources and dynamic content generators to your MCP clie
 icon: database
 ---
 
+import { VersionBadge } from "/snippets/version-badge.mdx"
+
 Resources represent data or files that an MCP client can read, and resource templates extend this concept by allowing clients to request dynamically generated resources based on parameters passed in the URI.
 
 FastMCP simplifies defining both static and dynamic resources, primarily using the `@mcp.resource` decorator.
@@ -183,6 +185,8 @@ Use these when the content is static or sourced directly from a file/URL, bypass
 
 #### Custom Resource Keys
 
+<VersionBadge version="2.2.0" />
+
 When adding resources directly with `mcp.add_resource()`, you can optionally provide a custom storage key:
 
 ```python
@@ -201,6 +205,10 @@ Note that this parameter is only available when using `add_resource()` directly
 
 Resource Templates allow clients to request resources whose content depends on parameters embedded in the URI. Define a template using the **same `@mcp.resource` decorator**, but include `{parameter_name}` placeholders in the URI string and add corresponding arguments to your function signature.
 
+Resource templates generate a new resource for each unique set of parameters, which means that resources can be dynamically created on-demand. For example, if the resource template `"user://profile/{name}"` is registered, MCP clients could request `"user://profile/ford"` or `"user://profile/marvin"` to retrieve either of those two user profiles as resources, without having to register each resource individually.
+
+Here is a complete example that shows how to define two resource templates:
+
 ```python
 from fastmcp import FastMCP
 
@@ -233,11 +241,61 @@ def get_repo_info(owner: str, repo: str) -> dict:
     }
 ```
 
-With these templates defined, clients can request:
+With these two templates defined, clients can request a variety of resources:
 - `weather://london/current` → Returns weather for London
-- `repos://fastmcp/docs/info` → Returns info about the fastmcp/docs repository
+- `weather://paris/current` → Returns weather for Paris
+- `repos://jlowin/fastmcp/info` → Returns info about the jlowin/fastmcp repository
+- `repos://prefecthq/prefect/info` → Returns info about the prefecthq/prefect repository
+
+### Wildcard Parameters
+
+<VersionBadge version="2.2.3" />
 
-### Parameters and Default Values
+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
+from fastmcp import FastMCP
+
+mcp = FastMCP(name="DataServer")
+
+# Standard parameter only matches one segment
+@mcp.resource("files://{filename}")
+def get_file(filename: str) -> str:
+    """Retrieves a file by name."""
+    # 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:
+    """Retrieves content at a specific path."""
+    # 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:
+    """Retrieves a file from a specific repository and path, but 
+    only if the resource ends with `template.py`"""
+    # Can match repo://jlowin/fastmcp/src/resources/template.py
+    return {
+        "owner": owner,
+        "path": path + "/template.py",
+        "content": f"File at {path}/template.py in {owner}'s repository"
+    }
+```
+
+Wildcard parameters are useful when:
+
+- Working with file paths or hierarchical data
+- Creating APIs that need to capture variable-length path segments
+- Building URL-like patterns similar to REST APIs
+
+Note that like regular parameters, each wildcard parameter must still be a named parameter in your function signature, and all required function parameters must appear in the URI template.
+
+### Default Values
+
+<VersionBadge version="2.2.0" />
 
 When creating resource templates, FastMCP enforces two rules for the relationship between URI template parameters and function parameters:
 
@@ -315,6 +373,8 @@ Templates provide a powerful way to expose parameterized data access points foll
 
 ### Custom Template Keys
 
+<VersionBadge version="2.2.0" />
+
 Similar to resources, you can provide custom keys when directly adding templates:
 
 ```python
@@ -337,6 +397,8 @@ This allows accessing the same template implementation through different URI pat
 
 ### Duplicate Resources
 
+<VersionBadge version="2.1.0" />
+
 You can configure how the FastMCP server handles attempts to register multiple resources or templates with the same URI. Use the `on_duplicate_resources` setting during `FastMCP` initialization.
 
 ```python

{fastmcp-2.2.2 → fastmcp-2.2.3}/docs/servers/tools.mdx

@@ -209,13 +209,18 @@ FastMCP automatically converts the value returned by your function into the appr
 - **`str`**: Sent as `TextContent`.
 - **`dict`, `list`, Pydantic `BaseModel`**: Serialized to a JSON string and sent as `TextContent`.
 - **`bytes`**: Base64 encoded and sent as `BlobResourceContents` (often within an `EmbeddedResource`).
-- **`fastmcp.utilities.types.Image`**: A helper class to easily return image data. Sent as `ImageContent`.
+- **`fastmcp.Image`**: A helper class for easily returning image data. Sent as `ImageContent`.
 - **`None`**: Results in an empty response (no content is sent back to the client).
 
 ```python
-from fastmcp.utilities.types import Image
-from PIL import Image as PILImage
+from fastmcp import FastMCP, Image
 import io
+try:
+    from PIL import Image as PILImage
+except ImportError:
+    raise ImportError("Please install the `pillow` library to run this example.")
+
+mcp = FastMCP("Image Demo")
 
 @mcp.tool()
 def generate_image(width: int, height: int, color: str) -> Image:
@@ -306,6 +311,8 @@ For full documentation on the Context object and all its capabilities, see the [
 
 ### Duplicate Tools
 
+<VersionBadge version="2.1.0" />
+
 You can control how the FastMCP server behaves if you try to register multiple tools with the same name. This is configured using the `on_duplicate_tools` argument when creating the `FastMCP` instance.
 
 ```python

fastmcp-2.2.3/docs/snippets/version-badge.mdx

@@ -0,0 +1,13 @@
+export const VersionBadge = ({ version }) => {
+    return (
+        <code className="version-badge-container">
+            <div className="version-badge">
+                <span className="version-badge-label">New in version:</span>&nbsp;
+                <span className="version-badge-version">{version}</span>
+            </div>
+        </code>
+
+
+
+    );
+};

{fastmcp-2.2.2 → fastmcp-2.2.3}/docs/style.css

@@ -14,16 +14,18 @@ h6 code:not(pre code) {
 
 /* Version badge -- display a badge with the current version of the documentation */
 .version-badge {
-  display: inline-flex;
+  display: inline-block;
   align-items: center;
   gap: 0.3em;
-  padding: 0.32em 1em;
-  font-size: 0.92em;
-  font-weight: 600;
-  letter-spacing: 0.01em;
-  color: #7417e5;
-  background: #f3e8ff;
-  border: 1.5px solid #c084fc;
+  padding: 0.2em 0.8em;
+  font-size: 1.1em;
+  font-weight: 400;
+
+  font-family: "Inter", sans-serif;
+  letter-spacing: 0.025em;
+  color: #ff5400;
+  background: #ffeee6;
+  border: 1px solid rgb(255, 84, 0, 0.5);
   border-radius: 6px;
   box-shadow: none;
   vertical-align: middle;
@@ -31,6 +33,11 @@ h6 code:not(pre code) {
   transition: box-shadow 0.2s, transform 0.15s;
 }
 
+.version-badge-container {
+  margin: 0;
+  padding: 0;
+}
+
 .version-badge:hover {
   box-shadow: 0 2px 8px 0 rgba(160, 132, 252, 0.1);
   transform: translateY(-1px) scale(1.03);
@@ -41,13 +48,3 @@ h6 code:not(pre code) {
   background: #312e81;
   border: 1.5px solid #a78bfa;
 }
-
-.badge-emoji {
-  font-size: 1.15em;
-  line-height: 1;
-  text-shadow: 0 1px 2px #fff, 0 0px 2px #c084fc;
-}
-
-.dark .badge-emoji {
-  text-shadow: 0 1px 2px #312e81, 0 0px 2px #a78bfa;
-}

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

@@ -24,13 +24,16 @@ from fastmcp.utilities.types import _convert_set_defaults
 
 
 def build_regex(template: str) -> re.Pattern:
-    # Escape all non-brace characters, then restore {var} placeholders
     parts = re.split(r"(\{[^}]+\})", template)
     pattern = ""
     for part in parts:
         if part.startswith("{") and part.endswith("}"):
             name = part[1:-1]
-            pattern += f"(?P<{name}>[^/]+)"
+            if name.endswith("*"):
+                name = name[:-1]
+                pattern += f"(?P<{name}>.+)"
+            else:
+                pattern += f"(?P<{name}>[^/]+)"
         else:
             pattern += re.escape(part)
     return re.compile(f"^{pattern}$")

{fastmcp-2.2.2 → fastmcp-2.2.3}/src/fastmcp/tools/tool.py

@@ -76,7 +76,12 @@ class Tool(BaseModel):
             fn_callable,
             skip_names=[context_kwarg] if context_kwarg is not None else [],
         )
-        parameters = func_arg_metadata.arg_model.model_json_schema()
+        try:
+            parameters = func_arg_metadata.arg_model.model_json_schema()
+        except Exception as e:
+            raise TypeError(
+                f'Unable to parse parameters for function "{fn.__name__}": {e}'
+            ) from e
 
         return cls(
             fn=fn_callable,

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

@@ -301,6 +301,23 @@ class TestResourceTemplate:
 class TestMatchUriTemplate:
     """Test match_uri_template function."""
 
+    @pytest.mark.parametrize(
+        "uri, expected_params",
+        [
+            ("test://a/b", None),
+            ("test://a/b/c", None),
+            ("test://a/x/b", {"x": "x"}),
+            ("test://a/x/y/b", None),
+        ],
+    )
+    def test_match_uri_template_single_param(
+        self, uri: str, expected_params: dict[str, str]
+    ):
+        """Test that match_uri_template uses the slash delimiter."""
+        uri_template = "test://a/{x}/b"
+        result = match_uri_template(uri=uri, uri_template=uri_template)
+        assert result == expected_params
+
     @pytest.mark.parametrize(
         "uri, expected_params",
         [
@@ -361,7 +378,7 @@ class TestMatchUriTemplate:
             ("other+prefix+test://foo/test/123", None),
         ],
     )
-    def test_match_prefixed_uri_template(
+    def test_match_uri_template_with_prefix(
         self, uri: str, expected_params: dict[str, str] | None
     ):
         """Test matching URIs against a template with a prefix."""
@@ -369,10 +386,60 @@ class TestMatchUriTemplate:
         result = match_uri_template(uri=uri, uri_template=uri_template)
         assert result == expected_params
 
-    def test_quoted_params(self):
+    def test_match_uri_template_quoted_params(self):
         uri_template = "user://{name}/{email}"
         quoted_name = quote("John Doe", safe="")
         quoted_email = quote("john@example.com", safe="")
         uri = f"user://{quoted_name}/{quoted_email}"
         result = match_uri_template(uri=uri, uri_template=uri_template)
         assert result == {"name": "John Doe", "email": "john@example.com"}
+
+    @pytest.mark.parametrize(
+        "uri, expected_params",
+        [
+            ("test://a/b", None),
+            ("test://a/b/c", None),
+            ("test://a/x/b", {"x": "x"}),
+            ("test://a/x/y/b", {"x": "x/y"}),
+            ("bad-prefix://a/x/y/b", None),
+            ("test://a/x/y/z", None),
+        ],
+    )
+    def test_match_uri_template_wildcard_param(
+        self, uri: str, expected_params: dict[str, str]
+    ):
+        """Test that match_uri_template uses the slash delimiter."""
+        uri_template = "test://a/{x*}/b"
+        result = match_uri_template(uri=uri, uri_template=uri_template)
+        assert result == expected_params
+
+    @pytest.mark.parametrize(
+        "uri, expected_params",
+        [
+            ("test://a/x/y/b/c/d", {"x": "x/y", "y": "c/d"}),
+            ("bad-prefix://a/x/y/b/c/d", None),
+            ("test://a/x/y/c/d", None),
+            ("test://a/x/b/y", {"x": "x", "y": "y"}),
+        ],
+    )
+    def test_match_uri_template_multiple_wildcard_params(
+        self, uri: str, expected_params: dict[str, str]
+    ):
+        """Test that match_uri_template uses the slash delimiter."""
+        uri_template = "test://a/{x*}/b/{y*}"
+        result = match_uri_template(uri=uri, uri_template=uri_template)
+        assert result == expected_params
+
+    def test_match_uri_template_wildcard_and_literal_param(self):
+        """Test that match_uri_template uses the slash delimiter."""
+        uri = "test://a/x/y/b"
+        uri_template = "test://a/{x*}/{y}"
+        result = match_uri_template(uri=uri, uri_template=uri_template)
+        assert result == {"x": "x/y", "y": "b"}
+
+    def test_match_consecutive_params(self):
+        """Test that consecutive parameters without a / are not matched."""
+        uri = "test://a/x/y"
+        uri_template = "test://a/{x}{y}"
+        result = match_uri_template(uri=uri, uri_template=uri_template)
+        assert result is None

{fastmcp-2.2.2 → fastmcp-2.2.3}/tests/tools/test_tool_manager.py

@@ -2,8 +2,10 @@ import json
 import logging
 
 import pytest
+from mcp.types import ImageContent, TextContent
 from pydantic import BaseModel
 
+from fastmcp import Context, FastMCP, Image
 from fastmcp.exceptions import NotFoundError, ToolError
 from fastmcp.tools import ToolManager
 from fastmcp.tools.tool import Tool
@@ -68,6 +70,18 @@ class TestAddTools:
         assert "age" in tool.parameters["$defs"]["UserInput"]["properties"]
         assert "flag" in tool.parameters["properties"]
 
+    async def test_tool_with_image_return(self):
+        def image_tool(data: bytes) -> Image:
+            return Image(data=data)
+
+        manager = ToolManager()
+        manager.add_tool_from_fn(image_tool)
+
+        tool = manager.get_tool("image_tool")
+        result = await tool.run({"data": "test.png"})
+        assert tool.parameters["properties"]["data"]["type"] == "string"
+        assert isinstance(result[0], ImageContent)
+
     def test_add_invalid_tool(self):
         manager = ToolManager()
         with pytest.raises(AttributeError):
@@ -263,7 +277,6 @@ class TestCallTools:
         result = await manager.call_tool("double", {"n": 5})
         assert isinstance(result, list)
         assert len(result) == 1
-        from mcp.types import TextContent
 
         assert isinstance(result[0], TextContent)
         assert result[0].text == "10"
@@ -279,7 +292,6 @@ class TestCallTools:
         result = await manager.call_tool("add", {"a": 1})
         assert isinstance(result, list)
         assert len(result) == 1
-        from mcp.types import TextContent
 
         assert isinstance(result[0], TextContent)
         assert result[0].text == "2"
@@ -307,7 +319,6 @@ class TestCallTools:
         manager = ToolManager()
         manager.add_tool_from_fn(sum_vals)
         # Try both with plain list and with JSON list
-        from mcp.types import TextContent
 
         result = await manager.call_tool("sum_vals", {"vals": "[1, 2, 3]"})
         assert isinstance(result, list)
@@ -329,7 +340,6 @@ class TestCallTools:
 
         manager = ToolManager()
         manager.add_tool_from_fn(concat_strs)
-        from mcp.types import TextContent
 
         # Try both with plain python object and with JSON list
         result = await manager.call_tool("concat_strs", {"vals": ["a", "b", "c"]})
@@ -357,10 +367,6 @@ class TestCallTools:
         assert result[0].text == '"a"'
 
     async def test_call_tool_with_complex_model(self):
-        from mcp.types import TextContent
-
-        from fastmcp import Context
-
         class MyShrimpTank(BaseModel):
             class Shrimp(BaseModel):
                 name: str
@@ -397,8 +403,6 @@ class TestCallTools:
 
 class TestToolSchema:
     async def test_context_arg_excluded_from_schema(self):
-        from fastmcp import Context
-
         def something(a: int, ctx: Context) -> int:
             return a
 
@@ -415,7 +419,6 @@ class TestContextHandling:
     def test_context_parameter_detection(self):
         """Test that context parameters are properly detected in
         Tool.from_function()."""
-        from fastmcp import Context
 
         def tool_with_context(x: int, ctx: Context) -> str:
             return str(x)
@@ -432,9 +435,6 @@ class TestContextHandling:
 
     async def test_context_injection(self):
         """Test that context is properly injected during tool execution."""
-        from mcp.types import TextContent
-
-        from fastmcp import Context, FastMCP
 
         def tool_with_context(x: int, ctx: Context) -> str:
             assert isinstance(ctx, Context)
@@ -453,9 +453,6 @@ class TestContextHandling:
 
     async def test_context_injection_async(self):
         """Test that context is properly injected in async tools."""
-        from mcp.types import TextContent
-
-        from fastmcp import Context, FastMCP
 
         async def async_tool(x: int, ctx: Context) -> str:
             assert isinstance(ctx, Context)
@@ -476,8 +473,6 @@ class TestContextHandling:
         """Test that context is optional when calling tools."""
         from mcp.types import TextContent
 
-        from fastmcp import Context
-
         def tool_with_context(x: int, ctx: Context | None = None) -> str:
             return str(x)
 
@@ -492,7 +487,6 @@ class TestContextHandling:
 
     async def test_context_error_handling(self):
         """Test error handling when context injection fails."""
-        from fastmcp import Context, FastMCP
 
         def tool_with_context(x: int, ctx: Context) -> str:
             raise ValueError("Test error")

fastmcp-2.2.2/docs/snippets/version-badge.mdx

@@ -1,8 +0,0 @@
-export const VersionBadge = ({ version }) => {
-    return (
-        <span className="version-badge">
-            <span className="badge-emoji" aria-hidden="true" style={{ marginRight: '0.3em', verticalAlign: 'middle' }}>✨</span>
-            New in version {version}
-        </span>
-    );
-};