fastmcp 0.1.0__py3-none-any.whl → 0.2.0__py3-none-any.whl

fastmcp/__init__.py

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

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/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/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/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/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/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.dist-info → fastmcp-0.2.0.dist-info}/METADATA

@@ -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.2.0.dist-info/RECORD

@@ -0,0 +1,17 @@
+fastmcp/__init__.py,sha256=3E3aQizHaMEwjxRUALigtM5J4lPTvaviMEr4hf975mY,53
+fastmcp/_version.py,sha256=H-qsvrxCpdhaQzyddR-yajEqI71hPxLa4KxzpP3uS1g,411
+fastmcp/app.py,sha256=RjtnF_4ApkIjxWfQlRmshb03icP6_nlNVV0LKnZGA5w,89
+fastmcp/exceptions.py,sha256=K0rCgXsUVlws39hz98Tb4BBf_BzIql_zXFZgqbkNTiE,348
+fastmcp/resources.py,sha256=efuEEnir4qCWp8qFrOyQW50sxACcLdKJpnuTZ99eYhM,7708
+fastmcp/server.py,sha256=ufsuoUbfGhA5PnGjAlYgxtkv2WRBMwd74duHJ3m58E8,10519
+fastmcp/tools.py,sha256=K4NspegydDmEvZyLHw56WyYBU9QHv9D8HsD4nHp_oYA,4858
+fastmcp/cli/__init__.py,sha256=RUaBw4rNUJ7CjHrzVazB2jl60E6KA0Wo0x4OqHByL6c,68
+fastmcp/cli/claude.py,sha256=rgJWxLPsdqV-UAQenafbAEREsyVuW_PFEyEsX92sHrg,3185
+fastmcp/cli/cli.py,sha256=LP6wQ2CMwHURWN8UHq1aUFWN4JveiUr0Ap_dWT4raXI,9627
+fastmcp/utilities/__init__.py,sha256=-imJ8S-rXmbXMWeDamldP-dHDqAPg_wwmPVz-LNX14E,31
+fastmcp/utilities/logging.py,sha256=t2w5bwtrkxHxioWSy5vY8esxLQxyxN8tfFZ1FI3Cb6E,704
+fastmcp-0.2.0.dist-info/METADATA,sha256=PvjUvOjHjrSR3XyJhusgbnn-FXbp99lXXWqKSn43eKY,3730
+fastmcp-0.2.0.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
+fastmcp-0.2.0.dist-info/entry_points.txt,sha256=ff8bMtKX1JvXyurMibAacMSKbJEPmac9ffAKU9mLnM8,44
+fastmcp-0.2.0.dist-info/top_level.txt,sha256=9NvhdRmSJxxf5iTz58rYyea0DtTsKgvGQHMRZaa7NN4,8
+fastmcp-0.2.0.dist-info/RECORD,,

fastmcp-0.1.0.dist-info/RECORD

@@ -1,17 +0,0 @@
-fastmcp/__init__.py,sha256=r_Qr4WYOFDNF1SSkJY9c3L3ZasYVKB7_U7EM31D5yfE,27
-fastmcp/_version.py,sha256=IMl2Pr_Sy4LVRKy_Sm4CdwUl1Gryous6ncL96EMYsnM,411
-fastmcp/cli.py,sha256=RjtnF_4ApkIjxWfQlRmshb03icP6_nlNVV0LKnZGA5w,89
-fastmcp/exceptions.py,sha256=K0rCgXsUVlws39hz98Tb4BBf_BzIql_zXFZgqbkNTiE,348
-fastmcp/resources.py,sha256=Y1VwYEU7xBl0brHNZarBAgFmDdOZf4Q7xdbYxK7osnU,7065
-fastmcp/server.py,sha256=oDIid6XLXhqUNVliMw2x_SN2QC0BEcjSDAdi3YRRWeM,9311
-fastmcp/tools.py,sha256=EAkST81hTkMch7IlEGl4WC7npIDjGICLMEaXjPbttSo,3210
-fastmcp/cli/__init__.py,sha256=RUaBw4rNUJ7CjHrzVazB2jl60E6KA0Wo0x4OqHByL6c,68
-fastmcp/cli/claude.py,sha256=_kkDTlFdqkhl1GElVWtCd15txyw1liTYpmBVl8CA2VE,2458
-fastmcp/cli/cli.py,sha256=4Ld9ohDmJMMaveDpe_Wm4RtlnFyLeKaU-4tPhX-CQRA,8276
-fastmcp/utilities/__init__.py,sha256=-imJ8S-rXmbXMWeDamldP-dHDqAPg_wwmPVz-LNX14E,31
-fastmcp/utilities/logging.py,sha256=t2w5bwtrkxHxioWSy5vY8esxLQxyxN8tfFZ1FI3Cb6E,704
-fastmcp-0.1.0.dist-info/METADATA,sha256=3oRrtc8oV24OH6GIjE0bxDBojjDpU95x_T8M1O2F5XM,2932
-fastmcp-0.1.0.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
-fastmcp-0.1.0.dist-info/entry_points.txt,sha256=ff8bMtKX1JvXyurMibAacMSKbJEPmac9ffAKU9mLnM8,44
-fastmcp-0.1.0.dist-info/top_level.txt,sha256=9NvhdRmSJxxf5iTz58rYyea0DtTsKgvGQHMRZaa7NN4,8
-fastmcp-0.1.0.dist-info/RECORD,,