fastmcp 0.1.0__tar.gz → 0.2.0__tar.gz

{fastmcp-0.1.0/src/fastmcp.egg-info → fastmcp-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: fastmcp
-Version: 0.1.0
+Version: 0.2.0
 Summary: A more ergonomic interface for MCP servers
 Author: Jeremiah Lowin
 License: Apache-2.0
@@ -95,15 +95,37 @@ def calculate(x: int, y: int) -> int:
 FastMCP includes a development server with the MCP Inspector for testing your server:
 
 ```bash
+# Basic usage
 fastmcp dev your_server.py
+
+# Install package in editable mode from current directory
+fastmcp dev your_server.py --with-editable .
+
+# Install additional packages
+fastmcp dev your_server.py --with pandas --with numpy
+
+# Combine both
+fastmcp dev your_server.py --with-editable . --with pandas --with numpy
 ```
 
+The `--with` flag automatically includes `fastmcp` and any additional packages you specify. The `--with-editable` flag installs the package from the specified directory in editable mode, which is useful during development.
+
 ### Installing in Claude
 
 To use your server with Claude Desktop:
 
 ```bash
+# Basic usage
 fastmcp install your_server.py --name "My Server"
+
+# Install package in editable mode
+fastmcp install your_server.py --with-editable .
+
+# Install additional packages
+fastmcp install your_server.py --with pandas --with numpy
+
+# Combine options
+fastmcp install your_server.py --with-editable . --with pandas --with numpy
 ```
 
 

{fastmcp-0.1.0 → fastmcp-0.2.0}/README.md

@@ -81,15 +81,37 @@ def calculate(x: int, y: int) -> int:
 FastMCP includes a development server with the MCP Inspector for testing your server:
 
 ```bash
+# Basic usage
 fastmcp dev your_server.py
+
+# Install package in editable mode from current directory
+fastmcp dev your_server.py --with-editable .
+
+# Install additional packages
+fastmcp dev your_server.py --with pandas --with numpy
+
+# Combine both
+fastmcp dev your_server.py --with-editable . --with pandas --with numpy
 ```
 
+The `--with` flag automatically includes `fastmcp` and any additional packages you specify. The `--with-editable` flag installs the package from the specified directory in editable mode, which is useful during development.
+
 ### Installing in Claude
 
 To use your server with Claude Desktop:
 
 ```bash
+# Basic usage
 fastmcp install your_server.py --name "My Server"
+
+# Install package in editable mode
+fastmcp install your_server.py --with-editable .
+
+# Install additional packages
+fastmcp install your_server.py --with pandas --with numpy
+
+# Combine options
+fastmcp install your_server.py --with-editable . --with pandas --with numpy
 ```
 
 

fastmcp-0.2.0/examples/screenshot.py

@@ -0,0 +1,32 @@
+# /// script
+# dependencies = ["fastmcp", "pyautogui", "Pillow"]
+# ///
+
+"""
+FastMCP Screenshot Example
+
+Give Claude a tool to capture and view screenshots.
+"""
+
+import io
+
+from fastmcp import FastMCP, Image
+
+# Create server
+mcp = FastMCP("Screenshot Demo")
+
+
+@mcp.tool()
+def take_screenshot() -> Image:
+    """Take a screenshot of the user's screen and return it as an image"""
+    import pyautogui
+
+    screenshot = pyautogui.screenshot()
+    buffer = io.BytesIO()
+    # if the file exceeds ~1MB, it will be rejected by Claude
+    screenshot.convert("RGB").save(buffer, format="JPEG", quality=60, optimize=True)
+    return Image(data=buffer.getvalue(), format="jpeg")
+
+
+if __name__ == "__main__":
+    mcp.run()

fastmcp-0.2.0/src/fastmcp/__init__.py

@@ -0,0 +1,2 @@
+from .server import FastMCP
+from .tools import Image

{fastmcp-0.1.0 → fastmcp-0.2.0}/src/fastmcp/_version.py

@@ -12,5 +12,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '0.1.0'
-__version_tuple__ = version_tuple = (0, 1, 0)
+__version__ = version = '0.2.0'
+__version_tuple__ = version_tuple = (0, 2, 0)

{fastmcp-0.1.0 → fastmcp-0.2.0}/src/fastmcp/cli/claude.py

@@ -28,7 +28,9 @@ def update_claude_config(
     file: Path,
     server_name: Optional[str] = None,
     *,
-    uv_directory: Optional[Path] = None,
+    with_editable: Optional[Path] = None,
+    with_packages: Optional[list[str]] = None,
+    force: bool = False,
 ) -> bool:
     """Add the MCP server to Claude's configuration.
 
@@ -36,7 +38,9 @@ def update_claude_config(
         file: Path to the server file
         server_name: Optional custom name for the server. If not provided,
                     defaults to the file stem
-        uv_directory: Optional directory containing pyproject.toml
+        with_editable: Optional directory to install in editable mode
+        with_packages: Optional list of additional packages to install
+        force: If True, replace existing server with same name
     """
     config_dir = get_claude_config_path()
     if not config_dir:
@@ -54,17 +58,34 @@ def update_claude_config(
         # Use provided server_name or fall back to file stem
         name = server_name or file.stem
         if name in config["mcpServers"]:
-            logger.warning(
-                f"Server '{name}' already exists in Claude config",
+            if not force:
+                logger.warning(
+                    f"Server '{name}' already exists in Claude config. "
+                    "Use `--force` to replace.",
+                    extra={"config_file": str(config_file)},
+                )
+                return False
+            logger.info(
+                f"Replacing existing server '{name}' in Claude config",
                 extra={"config_file": str(config_file)},
             )
-            return False
 
         # Build uv run command
-        args = []
-        if uv_directory:
-            args.extend(["--directory", str(uv_directory)])
-        args.extend(["run", str(file)])
+        args = ["run"]
+
+        if with_editable:
+            args.extend(["--with-editable", str(with_editable)])
+
+        # Always include fastmcp
+        args.extend(["--with", "fastmcp"])
+
+        # Add additional packages
+        if with_packages:
+            for pkg in with_packages:
+                if pkg:
+                    args.extend(["--with", pkg])
+
+        args.append(str(file))
 
         config["mcpServers"][name] = {
             "command": "uv",

{fastmcp-0.1.0 → fastmcp-0.2.0}/src/fastmcp/cli/cli.py

@@ -25,15 +25,23 @@ app = typer.Typer(
 
 def _build_uv_command(
     file: Path,
-    uv_directory: Optional[Path] = None,
+    with_editable: Optional[Path] = None,
+    with_packages: Optional[list[str]] = None,
 ) -> list[str]:
     """Build the uv run command."""
     cmd = ["uv"]
 
-    if uv_directory:
-        cmd.extend(["--directory", str(uv_directory)])
+    cmd.extend(["run", "--with", "fastmcp"])
 
-    cmd.extend(["run", str(file)])
+    if with_editable:
+        cmd.extend(["--with-editable", str(with_editable)])
+
+    if with_packages:
+        for pkg in with_packages:
+            if pkg:
+                cmd.extend(["--with", pkg])
+
+    cmd.append(str(file))
     return cmd
 
 
@@ -137,17 +145,24 @@ def dev(
         ...,
         help="Python file to run, optionally with :object suffix",
     ),
-    uv_directory: Annotated[
+    with_editable: Annotated[
         Optional[Path],
         typer.Option(
-            "--uv-directory",
-            "-d",
-            help="Directory containing pyproject.toml (defaults to current directory)",
+            "--with-editable",
+            "-e",
+            help="Directory containing pyproject.toml to install in editable mode",
             exists=True,
             file_okay=False,
             resolve_path=True,
         ),
     ] = None,
+    with_packages: Annotated[
+        list[str],
+        typer.Option(
+            "--with",
+            help="Additional packages to install",
+        ),
+    ] = [],
 ) -> None:
     """Run a FastMCP server with the MCP Inspector."""
     file, server_object = _parse_file_path(file_spec)
@@ -157,12 +172,13 @@ def dev(
         extra={
             "file": str(file),
             "server_object": server_object,
-            "uv_directory": str(uv_directory) if uv_directory else None,
+            "with_editable": str(with_editable) if with_editable else None,
+            "with_packages": with_packages,
         },
     )
 
     try:
-        uv_cmd = _build_uv_command(file, uv_directory)
+        uv_cmd = _build_uv_command(file, with_editable, with_packages)
         # Run the MCP Inspector command
         process = subprocess.run(
             ["npx", "@modelcontextprotocol/inspector"] + uv_cmd,
@@ -201,12 +217,12 @@ def run(
             help="Transport protocol to use (stdio or sse)",
         ),
     ] = None,
-    uv_directory: Annotated[
+    with_editable: Annotated[
         Optional[Path],
         typer.Option(
-            "--uv-directory",
-            "-d",
-            help="Directory containing pyproject.toml (defaults to current directory)",
+            "--with-editable",
+            "-e",
+            help="Directory containing pyproject.toml to install in editable mode",
             exists=True,
             file_okay=False,
             resolve_path=True,
@@ -222,13 +238,11 @@ def run(
             "file": str(file),
             "server_object": server_object,
             "transport": transport,
-            "uv_directory": str(uv_directory) if uv_directory else None,
+            "with_editable": str(with_editable) if with_editable else None,
         },
     )
 
     try:
-        uv_cmd = _build_uv_command(file, uv_directory)
-
         # Import and get server object
         server = _import_server(file, server_object)
 
@@ -261,20 +275,35 @@ def install(
         typer.Option(
             "--name",
             "-n",
-            help="Custom name for the server (defaults to file name)",
+            help="Custom name for the server (defaults to server's name attribute or file name)",
         ),
     ] = None,
-    uv_directory: Annotated[
+    with_editable: Annotated[
         Optional[Path],
         typer.Option(
-            "--uv-directory",
-            "-d",
-            help="Directory containing pyproject.toml (defaults to current directory)",
+            "--with-editable",
+            "-e",
+            help="Directory containing pyproject.toml to install in editable mode",
             exists=True,
             file_okay=False,
             resolve_path=True,
         ),
     ] = None,
+    with_packages: Annotated[
+        list[str],
+        typer.Option(
+            "--with",
+            help="Additional packages to install",
+        ),
+    ] = [],
+    force: Annotated[
+        bool,
+        typer.Option(
+            "--force",
+            "-f",
+            help="Replace existing server if one exists with the same name",
+        ),
+    ] = False,
 ) -> None:
     """Install a FastMCP server in the Claude desktop app."""
     file, server_object = _parse_file_path(file_spec)
@@ -285,7 +314,9 @@ def install(
             "file": str(file),
             "server_name": server_name,
             "server_object": server_object,
-            "uv_directory": str(uv_directory) if uv_directory else None,
+            "with_editable": str(with_editable) if with_editable else None,
+            "with_packages": with_packages,
+            "force": force,
         },
     )
 
@@ -293,11 +324,28 @@ def install(
         logger.error("Claude app not found")
         sys.exit(1)
 
-    if claude.update_claude_config(file, server_name, uv_directory=uv_directory):
-        name = server_name or file.stem
+    # Try to import server to get its name, but fall back to file name if dependencies missing
+    name = server_name
+    if not name:
+        try:
+            server = _import_server(file, server_object)
+            name = server.name
+        except (ImportError, ModuleNotFoundError) as e:
+            logger.debug(
+                "Could not import server (likely missing dependencies), using file name",
+                extra={"error": str(e)},
+            )
+            name = file.stem
+
+    if claude.update_claude_config(
+        file,
+        name,
+        with_editable=with_editable,
+        with_packages=with_packages,
+        force=force,
+    ):
         print(f"Successfully installed {name} in Claude app")
     else:
-        name = server_name or file.stem
         print(f"Failed to install {name} in Claude app")
         sys.exit(1)
 

{fastmcp-0.1.0 → fastmcp-0.2.0}/src/fastmcp/resources.py

@@ -16,12 +16,18 @@ logger = get_logger(__name__)
 
 
 class Resource(BaseModel):
-    """Base class for all resources."""
+    """Base class for all resources.
+
+    Resources can contain either text (UTF-8 encoded) or binary data.
+    Text resources are suitable for source code, logs, JSON, etc.
+    Binary resources are suitable for images, PDFs, audio, etc.
+    """
 
     uri: _BaseUrl
     name: str
     description: Optional[str] = None
-    mime_type: str = "text/plain"
+    mime_type: Optional[str] = None
+    is_binary: bool = False
 
     @field_validator("name", mode="before")
     @classmethod
@@ -36,15 +42,20 @@ class Resource(BaseModel):
         raise ValueError("Either name or uri must be provided")
 
     @abc.abstractmethod
-    async def read(self) -> str:
-        """Read the resource content."""
+    async def read(self) -> Union[str, bytes]:
+        """Read the resource content.
+
+        Returns:
+            Union[str, bytes]: Text content as str for text resources,
+                             binary content as bytes for binary resources
+        """
         return ""
 
 
 class FunctionResource(Resource):
     """A resource that is generated by a function call.
 
-    The function can be sync or async and must return a string
+    The function can be sync or async and must return a string, bytes,
     or another Resource.
     """
 
@@ -55,7 +66,7 @@ class FunctionResource(Resource):
         super().__init__(**data)
         self.is_async = asyncio.iscoroutinefunction(self.func)
 
-    async def read(self) -> str:
+    async def read(self) -> Union[str, bytes]:
         """Read the resource content by calling the function."""
         try:
             result = (
@@ -67,7 +78,7 @@ class FunctionResource(Resource):
             if isinstance(result, Resource):
                 return await result.read()
             if isinstance(result, bytes):
-                return result.decode()
+                return result
             if not isinstance(result, str):
                 try:
                     return json.dumps(result, default=pydantic.json.pydantic_encoder)
@@ -91,9 +102,11 @@ class FileResource(Resource):
             raise ValueError(f"Path must be absolute: {path}")
         return path
 
-    async def read(self) -> str:
+    async def read(self) -> Union[str, bytes]:
         """Read the file content."""
         try:
+            if self.is_binary:
+                return await asyncio.to_thread(self.path.read_bytes)
             return await asyncio.to_thread(self.path.read_text)
         except FileNotFoundError:
             raise FileNotFoundError(f"File not found: {self.path}")
@@ -109,13 +122,13 @@ class HttpResource(Resource):
     url: str
     headers: Optional[Dict[str, str]] = None
 
-    async def read(self) -> str:
+    async def read(self) -> Union[str, bytes]:
         """Read the HTTP resource content."""
         try:
             async with httpx.AsyncClient() as client:
                 response = await client.get(self.url, headers=self.headers)
                 response.raise_for_status()
-                return response.text
+                return response.content if self.is_binary else response.text
         except httpx.HTTPStatusError as e:
             raise ValueError(f"HTTP error {e.response.status_code}: {e}")
         except httpx.RequestError as e:
@@ -128,7 +141,7 @@ class DirectoryResource(Resource):
     path: Path
     recursive: bool = False
     pattern: Optional[str] = None
-    mime_type: str = "application/json"
+    mime_type: Optional[str] = "application/json"
 
     @field_validator("path")
     @classmethod
@@ -160,7 +173,7 @@ class DirectoryResource(Resource):
         except Exception as e:
             raise ValueError(f"Error listing directory {self.path}: {e}")
 
-    async def read(self) -> str:
+    async def read(self) -> str:  # Always returns JSON string
         """Read the directory listing."""
         try:
             files = await asyncio.to_thread(self.list_files)

{fastmcp-0.1.0 → fastmcp-0.2.0}/src/fastmcp/server.py

@@ -1,22 +1,27 @@
 """FastMCP - A more ergonomic interface for MCP servers."""
 
 import asyncio
-import base64
 import functools
 import json
+import logging
 from typing import Any, Callable, Optional, Sequence, Union, Literal
 
+import pydantic.json
 from mcp.server import Server as MCPServer
 from mcp.server.stdio import stdio_server
 from mcp.server.sse import SseServerTransport
-from mcp.types import Resource as MCPResource
-from mcp.types import Tool, TextContent, ImageContent, EmbeddedResource
-from pydantic import BaseModel
+from mcp.types import (
+    Resource as MCPResource,
+    Tool,
+    TextContent,
+    ImageContent,
+)
 from pydantic_settings import BaseSettings
 from pydantic.networks import _BaseUrl
+
 from .exceptions import ResourceError
 from .resources import Resource, FunctionResource, ResourceManager
-from .tools import ToolManager
+from .tools import ToolManager, Image
 from .utilities.logging import get_logger, configure_logging
 
 logger = get_logger(__name__)
@@ -33,7 +38,9 @@ class Settings(BaseSettings):
 
     # Server settings
     debug: bool = False
-    log_level: Literal["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"] = "INFO"
+    log_level: Literal[
+        logging.DEBUG, logging.INFO, logging.WARNING, logging.ERROR, logging.CRITICAL
+    ] = logging.INFO
 
     # HTTP settings
     host: str = "0.0.0.0"
@@ -73,12 +80,14 @@ class FastMCP:
         Args:
             transport: Transport protocol to use ("stdio" or "sse")
         """
+        TRANSPORTS = Literal["stdio", "sse"]
+        if transport not in TRANSPORTS.__args__:  # type: ignore
+            raise ValueError(f"Unknown transport: {transport}")
+
         if transport == "stdio":
             asyncio.run(self.run_stdio_async())
-        elif transport == "sse":
+        else:  # transport == "sse"
             asyncio.run(self.run_sse_async())
-        else:
-            raise ValueError(f"Unknown transport: {transport}")
 
     def _setup_handlers(self) -> None:
         """Set up core MCP protocol handlers."""
@@ -101,13 +110,24 @@ class FastMCP:
 
     async def call_tool(
         self, name: str, arguments: dict
-    ) -> Sequence[Union[TextContent, ImageContent, EmbeddedResource]]:
+    ) -> Sequence[Union[TextContent, ImageContent]]:
         """Call a tool by name with arguments."""
-        result = await self._tool_manager.call_tool(name, arguments)
-        return [self._convert_to_content(result)]
+        try:
+            result = await self._tool_manager.call_tool(name, arguments)
+            return self._convert_to_content(result)
+        except Exception as e:
+            logger.error(f"Error calling tool {name}: {e}")
+            return [
+                TextContent(
+                    type="text",
+                    text=str(e),
+                    is_error=True,
+                )
+            ]
 
     async def list_resources(self) -> list[MCPResource]:
         """List all available resources."""
+
         resources = self._resource_manager.list_resources()
         return [
             MCPResource(
@@ -133,21 +153,48 @@ class FastMCP:
 
     def _convert_to_content(
         self, value: Any
-    ) -> Union[TextContent, ImageContent, EmbeddedResource]:
-        """Convert Python values to MCP content types."""
-        if isinstance(value, (dict, list)):
-            return TextContent(type="text", text=json.dumps(value, indent=2))
-        if isinstance(value, str):
-            return TextContent(type="text", text=value)
-        if isinstance(value, bytes):
-            return ImageContent(
-                type="image",
-                data=base64.b64encode(value).decode(),
-                mimeType="application/octet-stream",
+    ) -> Sequence[Union[TextContent, ImageContent]]:
+        """Convert a tool result to MCP content types."""
+
+        # Already a sequence of valid content types
+        if isinstance(value, (list, tuple)):
+            if all(isinstance(x, (TextContent, ImageContent)) for x in value):
+                return value
+            # Handle mixed content including Image objects
+            result = []
+            for item in value:
+                if isinstance(item, (TextContent, ImageContent)):
+                    result.append(item)
+                elif isinstance(item, Image):
+                    result.append(item.to_image_content())
+                else:
+                    result.append(
+                        TextContent(
+                            type="text",
+                            text=json.dumps(
+                                item, indent=2, default=pydantic.json.pydantic_encoder
+                            ),
+                        )
+                    )
+            return result
+
+        # Single content type
+        if isinstance(value, (TextContent, ImageContent)):
+            return [value]
+
+        # Image helper
+        if isinstance(value, Image):
+            return [value.to_image_content()]
+
+        # All other types - convert to JSON string with pydantic encoder
+        return [
+            TextContent(
+                type="text",
+                text=json.dumps(
+                    value, indent=2, default=pydantic.json.pydantic_encoder
+                ),
             )
-        if isinstance(value, BaseModel):
-            return TextContent(type="text", text=value.model_dump_json(indent=2))
-        return TextContent(type="text", text=str(value))
+        ]
 
     def add_tool(
         self,

{fastmcp-0.1.0 → fastmcp-0.2.0}/src/fastmcp/tools.py

@@ -1,8 +1,11 @@
 """Tool management for FastMCP."""
 
+import base64
 import inspect
-from typing import Any, Callable, Dict, Optional
+from pathlib import Path
+from typing import Any, Callable, Dict, Optional, Union
 
+from mcp.types import ImageContent
 from pydantic import BaseModel, Field, TypeAdapter, validate_call
 
 from .exceptions import ToolError
@@ -11,6 +14,52 @@ from .utilities.logging import get_logger
 logger = get_logger(__name__)
 
 
+class Image:
+    """Helper class for returning images from tools."""
+
+    def __init__(
+        self,
+        path: Optional[Union[str, Path]] = None,
+        data: Optional[bytes] = None,
+        format: Optional[str] = None,
+    ):
+        if path is None and data is None:
+            raise ValueError("Either path or data must be provided")
+        if path is not None and data is not None:
+            raise ValueError("Only one of path or data can be provided")
+
+        self.path = Path(path) if path else None
+        self.data = data
+        self._format = format
+        self._mime_type = self._get_mime_type()
+
+    def _get_mime_type(self) -> str:
+        """Get MIME type from format or guess from file extension."""
+        if self._format:
+            return f"image/{self._format.lower()}"
+
+        if self.path:
+            suffix = self.path.suffix.lower()
+            return {
+                ".png": "image/png",
+                ".jpg": "image/jpeg",
+                ".jpeg": "image/jpeg",
+                ".gif": "image/gif",
+                ".webp": "image/webp",
+            }.get(suffix, "application/octet-stream")
+        return "image/png"  # default for raw binary data
+
+    def to_image_content(self) -> ImageContent:
+        """Convert to MCP ImageContent."""
+        if self.path:
+            with open(self.path, "rb") as f:
+                data = base64.b64encode(f.read()).decode()
+        else:
+            data = base64.b64encode(self.data).decode()
+
+        return ImageContent(type="image", data=data, mimeType=self._mime_type)
+
+
 class Tool(BaseModel):
     """Internal tool registration info."""
 

{fastmcp-0.1.0 → fastmcp-0.2.0/src/fastmcp.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: fastmcp
-Version: 0.1.0
+Version: 0.2.0
 Summary: A more ergonomic interface for MCP servers
 Author: Jeremiah Lowin
 License: Apache-2.0
@@ -95,15 +95,37 @@ def calculate(x: int, y: int) -> int:
 FastMCP includes a development server with the MCP Inspector for testing your server:
 
 ```bash
+# Basic usage
 fastmcp dev your_server.py
+
+# Install package in editable mode from current directory
+fastmcp dev your_server.py --with-editable .
+
+# Install additional packages
+fastmcp dev your_server.py --with pandas --with numpy
+
+# Combine both
+fastmcp dev your_server.py --with-editable . --with pandas --with numpy
 ```
 
+The `--with` flag automatically includes `fastmcp` and any additional packages you specify. The `--with-editable` flag installs the package from the specified directory in editable mode, which is useful during development.
+
 ### Installing in Claude
 
 To use your server with Claude Desktop:
 
 ```bash
+# Basic usage
 fastmcp install your_server.py --name "My Server"
+
+# Install package in editable mode
+fastmcp install your_server.py --with-editable .
+
+# Install additional packages
+fastmcp install your_server.py --with pandas --with numpy
+
+# Combine options
+fastmcp install your_server.py --with-editable . --with pandas --with numpy
 ```
 
 

{fastmcp-0.1.0 → fastmcp-0.2.0}/src/fastmcp.egg-info/SOURCES.txt

@@ -8,7 +8,7 @@ examples/desktop.py
 examples/screenshot.py
 src/fastmcp/__init__.py
 src/fastmcp/_version.py
-src/fastmcp/cli.py
+src/fastmcp/app.py
 src/fastmcp/exceptions.py
 src/fastmcp/resources.py
 src/fastmcp/server.py

fastmcp-0.2.0/tests/test_server.py

@@ -0,0 +1,266 @@
+from mcp.shared.memory import (
+    create_connected_server_and_client_session as client_session,
+)
+from fastmcp import FastMCP
+from fastmcp.resources import FileResource, FunctionResource
+from fastmcp.tools import Image
+from mcp.types import TextContent, ImageContent
+import pytest
+from pydantic import BaseModel
+from pathlib import Path
+import base64
+from typing import Union
+
+
+class TestServer:
+    async def test_create_server(self):
+        mcp = FastMCP()
+        assert mcp.name == "FastMCP"
+
+    async def test_add_tool_decorator(self):
+        mcp = FastMCP()
+
+        @mcp.tool()
+        def add(x: int, y: int) -> int:
+            return x + y
+
+        assert len(mcp._tool_manager.list_tools()) == 1
+
+    async def test_add_tool_decorator_incorrect_usage(self):
+        mcp = FastMCP()
+
+        with pytest.raises(TypeError, match="The @tool decorator was used incorrectly"):
+
+            @mcp.tool  # Missing parentheses
+            def add(x: int, y: int) -> int:
+                return x + y
+
+    async def test_add_resource_decorator(self):
+        mcp = FastMCP()
+
+        @mcp.resource("r://data")
+        def get_data(x: str) -> str:
+            return f"Data: {x}"
+
+        assert len(mcp._resource_manager.list_resources()) == 1
+
+    async def test_add_resource_decorator_incorrect_usage(self):
+        mcp = FastMCP()
+
+        with pytest.raises(
+            TypeError, match="The @resource decorator was used incorrectly"
+        ):
+
+            @mcp.resource  # Missing parentheses
+            def get_data(x: str) -> str:
+                return f"Data: {x}"
+
+
+def tool_fn(x: int, y: int) -> int:
+    return x + y
+
+
+def error_tool_fn() -> None:
+    raise ValueError("Test error")
+
+
+class ErrorResponse(BaseModel):
+    is_error: bool = True
+    message: str
+
+
+def image_tool_fn(path: str) -> Image:
+    return Image(path)
+
+
+def mixed_content_tool_fn() -> list[Union[TextContent, ImageContent]]:
+    return [
+        TextContent(type="text", text="Hello"),
+        ImageContent(type="image", data="abc", mimeType="image/png"),
+    ]
+
+
+class TestServerTools:
+    async def test_add_tool(self):
+        mcp = FastMCP()
+        mcp.add_tool(tool_fn)
+        mcp.add_tool(tool_fn)
+        assert len(mcp._tool_manager.list_tools()) == 1
+
+    async def test_list_tools(self):
+        mcp = FastMCP()
+        mcp.add_tool(tool_fn)
+        async with client_session(mcp._mcp_server) as client:
+            tools = await client.list_tools()
+            assert len(tools.tools) == 1
+
+    async def test_call_tool(self):
+        mcp = FastMCP()
+        mcp.add_tool(tool_fn)
+        async with client_session(mcp._mcp_server) as client:
+            result = await client.call_tool("my_tool", {"arg1": "value"})
+            assert "error" not in result
+            assert len(result.content) > 0
+
+    async def test_tool_exception_handling(self):
+        mcp = FastMCP()
+        mcp.add_tool(error_tool_fn)
+        async with client_session(mcp._mcp_server) as client:
+            result = await client.call_tool("error_tool_fn", {})
+            assert len(result.content) == 1
+            assert result.content[0].type == "text"
+            assert "Test error" in result.content[0].text
+            assert result.content[0].is_error is True
+
+    async def test_tool_exception_content(self):
+        """Test that exception details are properly formatted in the response"""
+        mcp = FastMCP()
+        mcp.add_tool(error_tool_fn)
+        async with client_session(mcp._mcp_server) as client:
+            result = await client.call_tool("error_tool_fn", {})
+            content = result.content[0]
+            assert content.type == "text"
+            assert isinstance(content.text, str)
+            assert "Test error" in content.text
+            assert content.is_error is True
+
+    async def test_tool_text_conversion(self):
+        mcp = FastMCP()
+        mcp.add_tool(tool_fn)
+        async with client_session(mcp._mcp_server) as client:
+            result = await client.call_tool("tool_fn", {"x": 1, "y": 2})
+            assert len(result.content) == 1
+            assert result.content[0].type == "text"
+            assert result.content[0].text == "3"
+
+    async def test_tool_image_helper(self, tmp_path: Path):
+        # Create a test image
+        image_path = tmp_path / "test.png"
+        image_path.write_bytes(b"fake png data")
+
+        mcp = FastMCP()
+        mcp.add_tool(image_tool_fn)
+        async with client_session(mcp._mcp_server) as client:
+            result = await client.call_tool("image_tool_fn", {"path": str(image_path)})
+            assert len(result.content) == 1
+            assert result.content[0].type == "image"
+            assert result.content[0].mimeType == "image/png"
+            # Verify base64 encoding
+            decoded = base64.b64decode(result.content[0].data)
+            assert decoded == b"fake png data"
+
+    async def test_tool_mixed_content(self):
+        mcp = FastMCP()
+        mcp.add_tool(mixed_content_tool_fn)
+        async with client_session(mcp._mcp_server) as client:
+            result = await client.call_tool("mixed_content_tool_fn", {})
+            assert len(result.content) == 2
+            assert result.content[0].type == "text"
+            assert result.content[0].text == "Hello"
+            assert result.content[1].type == "image"
+            assert result.content[1].mimeType == "image/png"
+            assert result.content[1].data == "abc"
+
+    async def test_tool_mixed_list_with_image(self, tmp_path: Path):
+        """Test that lists containing Image objects and other types are handled correctly"""
+        # Create a test image
+        image_path = tmp_path / "test.png"
+        image_path.write_bytes(b"test image data")
+
+        def mixed_list_fn() -> list:
+            return [
+                "text message",
+                Image(image_path),
+                {"key": "value"},
+                TextContent(type="text", text="direct content"),
+            ]
+
+        mcp = FastMCP()
+        mcp.add_tool(mixed_list_fn)
+        async with client_session(mcp._mcp_server) as client:
+            result = await client.call_tool("mixed_list_fn", {})
+            assert len(result.content) == 4
+            # Check text conversion
+            assert result.content[0].type == "text"
+            assert '"text message"' in result.content[0].text
+            # Check image conversion
+            assert result.content[1].type == "image"
+            assert result.content[1].mimeType == "image/png"
+            assert base64.b64decode(result.content[1].data) == b"test image data"
+            # Check dict conversion
+            assert result.content[2].type == "text"
+            assert '"key": "value"' in result.content[2].text
+            # Check direct TextContent
+            assert result.content[3].type == "text"
+            assert result.content[3].text == "direct content"
+
+
+class TestServerResources:
+    async def test_text_resource(self):
+        mcp = FastMCP()
+
+        def get_text():
+            return "Hello, world!"
+
+        resource = FunctionResource(uri="resource://test", name="test", func=get_text)
+        mcp.add_resource(resource)
+
+        async with client_session(mcp._mcp_server) as client:
+            result = await client.read_resource("resource://test")
+            assert result.contents[0].text == "Hello, world!"
+
+    async def test_binary_resource(self):
+        mcp = FastMCP()
+
+        def get_binary():
+            return b"Binary data"
+
+        resource = FunctionResource(
+            uri="resource://binary",
+            name="binary",
+            func=get_binary,
+            is_binary=True,
+            mime_type="application/octet-stream",
+        )
+        mcp.add_resource(resource)
+
+        async with client_session(mcp._mcp_server) as client:
+            result = await client.read_resource("resource://binary")
+            assert result.contents[0].blob == base64.b64encode(b"Binary data").decode()
+
+    async def test_file_resource_text(self, tmp_path: Path):
+        mcp = FastMCP()
+
+        # Create a text file
+        text_file = tmp_path / "test.txt"
+        text_file.write_text("Hello from file!")
+
+        resource = FileResource(uri="file://test.txt", name="test.txt", path=text_file)
+        mcp.add_resource(resource)
+
+        async with client_session(mcp._mcp_server) as client:
+            result = await client.read_resource("file://test.txt")
+            assert result.contents[0].text == "Hello from file!"
+
+    async def test_file_resource_binary(self, tmp_path: Path):
+        mcp = FastMCP()
+
+        # Create a binary file
+        binary_file = tmp_path / "test.bin"
+        binary_file.write_bytes(b"Binary file data")
+
+        resource = FileResource(
+            uri="file://test.bin",
+            name="test.bin",
+            path=binary_file,
+            is_binary=True,
+            mime_type="application/octet-stream",
+        )
+        mcp.add_resource(resource)
+
+        async with client_session(mcp._mcp_server) as client:
+            result = await client.read_resource("file://test.bin")
+            assert (
+                result.contents[0].blob
+                == base64.b64encode(b"Binary file data").decode()
+            )

{fastmcp-0.1.0 → fastmcp-0.2.0}/uv.lock

@@ -222,7 +222,7 @@ wheels = [
 
 [[package]]
 name = "fastmcp"
-version = "0.1.dev4+g18aaf41.d20241129"
+version = "0.1.1.dev3+gbffea91.d20241130"
 source = { editable = "." }
 dependencies = [
     { name = "httpx" },

fastmcp-0.1.0/examples/screenshot.py

@@ -1,34 +0,0 @@
-# /// script
-# dependencies = ["pyautogui"]
-# ///
-
-"""
-FastMCP Screenshot Example
-
-A simple example that provides a tool to capture screenshots.
-"""
-
-import base64
-import io
-import pyautogui
-
-from fastmcp.server import FastMCP
-
-# Create server
-mcp = FastMCP("Screenshot Demo")
-
-
-@mcp.tool()
-def take_screenshot() -> str:
-    """Take a screenshot and return it as a base64 encoded string"""
-    # Capture the screen
-    screenshot = pyautogui.screenshot()
-
-    # Convert to base64
-    buffer = io.BytesIO()
-    screenshot.save(buffer, format="PNG")
-    return base64.b64encode(buffer.getvalue()).decode()
-
-
-if __name__ == "__main__":
-    mcp.run()

fastmcp-0.1.0/src/fastmcp/__init__.py

@@ -1 +0,0 @@
-from .server import FastMCP

fastmcp-0.1.0/tests/test_server.py

@@ -1,76 +0,0 @@
-from mcp.shared.memory import (
-    create_connected_server_and_client_session as client_session,
-)
-from fastmcp import FastMCP
-import pytest
-
-
-class TestServer:
-    async def test_create_server(self):
-        mcp = FastMCP()
-        assert mcp.name == "FastMCP"
-
-    async def test_add_tool_decorator(self):
-        mcp = FastMCP()
-
-        @mcp.tool()
-        def add(x: int, y: int) -> int:
-            return x + y
-
-        assert len(mcp._tool_manager.list_tools()) == 1
-
-    async def test_add_tool_decorator_incorrect_usage(self):
-        mcp = FastMCP()
-
-        with pytest.raises(TypeError, match="The @tool decorator was used incorrectly"):
-
-            @mcp.tool  # Missing parentheses
-            def add(x: int, y: int) -> int:
-                return x + y
-
-    async def test_add_resource_decorator(self):
-        mcp = FastMCP()
-
-        @mcp.resource("r://data")
-        def get_data(x: str) -> str:
-            return f"Data: {x}"
-
-        assert len(mcp._resource_manager.list_resources()) == 1
-
-    async def test_add_resource_decorator_incorrect_usage(self):
-        mcp = FastMCP()
-
-        with pytest.raises(
-            TypeError, match="The @resource decorator was used incorrectly"
-        ):
-
-            @mcp.resource  # Missing parentheses
-            def get_data(x: str) -> str:
-                return f"Data: {x}"
-
-
-def tool_fn(x: int, y: int) -> int:
-    return x + y
-
-
-class TestServerTools:
-    async def test_add_tool(self):
-        mcp = FastMCP()
-        mcp.add_tool(tool_fn)
-        mcp.add_tool(tool_fn)
-        assert len(mcp._tool_manager.list_tools()) == 1
-
-    async def test_list_tools(self):
-        mcp = FastMCP()
-        mcp.add_tool(tool_fn)
-        async with client_session(mcp._mcp_server) as client:
-            tools = await client.list_tools()
-            assert len(tools.tools) == 1
-
-    async def test_call_tool(self):
-        mcp = FastMCP()
-        mcp.add_tool(tool_fn)
-        async with client_session(mcp._mcp_server) as client:
-            result = await client.call_tool("my_tool", {"arg1": "value"})
-            assert "error" not in result
-            assert len(result.content) > 0