fastmcp 2.1.1__py3-none-any.whl → 2.2.0__py3-none-any.whl

fastmcp/settings.py

@@ -1,6 +1,5 @@
 from __future__ import annotations as _annotations
 
-from enum import Enum
 from typing import TYPE_CHECKING, Literal
 
 from pydantic import Field
@@ -11,12 +10,7 @@ if TYPE_CHECKING:
 
 LOG_LEVEL = Literal["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"]
 
-
-class DuplicateBehavior(Enum):
-    WARN = "warn"
-    ERROR = "error"
-    REPLACE = "replace"
-    IGNORE = "ignore"
+DuplicateBehavior = Literal["warn", "error", "replace", "ignore"]
 
 
 class Settings(BaseSettings):
@@ -48,26 +42,29 @@ class ServerSettings(BaseSettings):
     log_level: LOG_LEVEL = Field(default_factory=lambda: Settings().log_level)
 
     # HTTP settings
-    host: str = "0.0.0.0"
+    host: str = "127.0.0.1"
     port: int = 8000
     sse_path: str = "/sse"
     message_path: str = "/messages/"
     debug: bool = False
 
     # resource settings
-    on_duplicate_resources: DuplicateBehavior = DuplicateBehavior.WARN
+    on_duplicate_resources: DuplicateBehavior = "warn"
 
     # tool settings
-    on_duplicate_tools: DuplicateBehavior = DuplicateBehavior.WARN
+    on_duplicate_tools: DuplicateBehavior = "warn"
 
     # prompt settings
-    on_duplicate_prompts: DuplicateBehavior = DuplicateBehavior.WARN
+    on_duplicate_prompts: DuplicateBehavior = "warn"
 
     dependencies: list[str] = Field(
         default_factory=list,
         description="List of dependencies to install in the server environment",
     )
 
+    # cache settings (for checking mounted servers)
+    cache_expiration_seconds: float = 0
+
 
 class ClientSettings(BaseSettings):
     """FastMCP client settings."""

fastmcp/tools/tool.py

@@ -1,15 +1,18 @@
-from __future__ import annotations as _annotations
+from __future__ import annotations
 
 import inspect
+import json
 from collections.abc import Callable
 from typing import TYPE_CHECKING, Annotated, Any
 
+import pydantic_core
+from mcp.types import EmbeddedResource, ImageContent, TextContent
+from mcp.types import Tool as MCPTool
 from pydantic import BaseModel, BeforeValidator, Field
-from typing_extensions import Self
 
 from fastmcp.exceptions import ToolError
 from fastmcp.utilities.func_metadata import FuncMetadata, func_metadata
-from fastmcp.utilities.types import _convert_set_defaults
+from fastmcp.utilities.types import Image, _convert_set_defaults
 
 if TYPE_CHECKING:
     from mcp.server.session import ServerSessionT
@@ -58,7 +61,7 @@ class Tool(BaseModel):
         is_async = inspect.iscoroutinefunction(fn)
 
         if context_kwarg is None:
-            if isinstance(fn, classmethod):
+            if inspect.ismethod(fn) and hasattr(fn, "__func__"):
                 sig = inspect.signature(fn.__func__)
             else:
                 sig = inspect.signature(fn)
@@ -67,14 +70,16 @@ class Tool(BaseModel):
                     context_kwarg = param_name
                     break
 
+        # Use callable typing to ensure fn is treated as a callable despite being a classmethod
+        fn_callable: Callable[..., Any] = fn
         func_arg_metadata = func_metadata(
-            fn,
+            fn_callable,
             skip_names=[context_kwarg] if context_kwarg is not None else [],
         )
         parameters = func_arg_metadata.arg_model.model_json_schema()
 
         return cls(
-            fn=fn,
+            fn=fn_callable,
             name=func_name,
             description=func_doc,
             parameters=parameters,
@@ -88,10 +93,10 @@ class Tool(BaseModel):
         self,
         arguments: dict[str, Any],
         context: Context[ServerSessionT, LifespanContextT] | None = None,
-    ) -> Any:
+    ) -> list[TextContent | ImageContent | EmbeddedResource]:
         """Run the tool with arguments."""
         try:
-            return await self.fn_metadata.call_fn_with_arg_validation(
+            result = await self.fn_metadata.call_fn_with_arg_validation(
                 self.fn,
                 self.is_async,
                 arguments,
@@ -99,17 +104,64 @@ class Tool(BaseModel):
                 if self.context_kwarg is not None
                 else None,
             )
+            return _convert_to_content(result)
         except Exception as e:
             raise ToolError(f"Error executing tool {self.name}: {e}") from e
 
-    def copy(self, updates: dict[str, Any] | None = None) -> Self:
-        """Copy the tool with optional updates."""
-        data = self.model_dump()
-        if updates:
-            data.update(updates)
-        return type(self)(**data)
+    def to_mcp_tool(self, **overrides: Any) -> MCPTool:
+        kwargs = {
+            "name": self.name,
+            "description": self.description,
+            "inputSchema": self.parameters,
+        }
+        return MCPTool(**kwargs | overrides)
 
     def __eq__(self, other: object) -> bool:
         if not isinstance(other, Tool):
             return False
         return self.model_dump() == other.model_dump()
+
+
+def _convert_to_content(
+    result: Any,
+    _process_as_single_item: bool = False,
+) -> list[TextContent | ImageContent | EmbeddedResource]:
+    """Convert a result to a sequence of content objects."""
+    if result is None:
+        return []
+
+    if isinstance(result, TextContent | ImageContent | EmbeddedResource):
+        return [result]
+
+    if isinstance(result, Image):
+        return [result.to_image_content()]
+
+    if isinstance(result, list | tuple) and not _process_as_single_item:
+        # if the result is a list, then it could either be a list of MCP types,
+        # or a "regular" list that the tool is returning, or a mix of both.
+        #
+        # so we extract all the MCP types / images and convert them as individual content elements,
+        # and aggregate the rest as a single content element
+
+        mcp_types = []
+        other_content = []
+
+        for item in result:
+            if isinstance(item, TextContent | ImageContent | EmbeddedResource | Image):
+                mcp_types.append(_convert_to_content(item)[0])
+            else:
+                other_content.append(item)
+        if other_content:
+            other_content = _convert_to_content(
+                other_content, _process_as_single_item=True
+            )
+
+        return other_content + mcp_types
+
+    if not isinstance(result, str):
+        try:
+            result = json.dumps(pydantic_core.to_jsonable_python(result))
+        except Exception:
+            result = str(result)
+
+    return [TextContent(type="text", text=result)]

fastmcp/tools/tool_manager.py

@@ -4,8 +4,9 @@ from collections.abc import Callable
 from typing import TYPE_CHECKING, Any
 
 from mcp.shared.context import LifespanContextT
+from mcp.types import EmbeddedResource, ImageContent, TextContent
 
-from fastmcp.exceptions import ToolError
+from fastmcp.exceptions import NotFoundError
 from fastmcp.settings import DuplicateBehavior
 from fastmcp.tools.tool import Tool
 from fastmcp.utilities.logging import get_logger
@@ -21,17 +22,38 @@ logger = get_logger(__name__)
 class ToolManager:
     """Manages FastMCP tools."""
 
-    def __init__(self, duplicate_behavior: DuplicateBehavior = DuplicateBehavior.WARN):
+    def __init__(self, duplicate_behavior: DuplicateBehavior | None = None):
         self._tools: dict[str, Tool] = {}
+
+        # Default to "warn" if None is provided
+        if duplicate_behavior is None:
+            duplicate_behavior = "warn"
+
+        if duplicate_behavior not in DuplicateBehavior.__args__:
+            raise ValueError(
+                f"Invalid duplicate_behavior: {duplicate_behavior}. "
+                f"Must be one of: {', '.join(DuplicateBehavior.__args__)}"
+            )
+
         self.duplicate_behavior = duplicate_behavior
 
-    def get_tool(self, name: str) -> Tool | None:
-        """Get tool by name."""
-        return self._tools.get(name)
+    def has_tool(self, key: str) -> bool:
+        """Check if a tool exists."""
+        return key in self._tools
+
+    def get_tool(self, key: str) -> Tool:
+        """Get tool by key."""
+        if key in self._tools:
+            return self._tools[key]
+        raise NotFoundError(f"Unknown tool: {key}")
+
+    def get_tools(self) -> dict[str, Tool]:
+        """Get all registered tools, indexed by registered key."""
+        return self._tools
 
     def list_tools(self) -> list[Tool]:
         """List all registered tools."""
-        return list(self._tools.values())
+        return list(self.get_tools().values())
 
     def add_tool_from_fn(
         self,
@@ -44,53 +66,33 @@ class ToolManager:
         tool = Tool.from_function(fn, name=name, description=description, tags=tags)
         return self.add_tool(tool)
 
-    def add_tool(self, tool: Tool) -> Tool:
+    def add_tool(self, tool: Tool, key: str | None = None) -> Tool:
         """Register a tool with the server."""
-        existing = self._tools.get(tool.name)
+        key = key or tool.name
+        existing = self._tools.get(key)
         if existing:
-            if self.duplicate_behavior == DuplicateBehavior.WARN:
-                logger.warning(f"Tool already exists: {tool.name}")
-                self._tools[tool.name] = tool
-            elif self.duplicate_behavior == DuplicateBehavior.REPLACE:
-                self._tools[tool.name] = tool
-            elif self.duplicate_behavior == DuplicateBehavior.ERROR:
-                raise ValueError(f"Tool already exists: {tool.name}")
-            elif self.duplicate_behavior == DuplicateBehavior.IGNORE:
-                pass
-        self._tools[tool.name] = tool
+            if self.duplicate_behavior == "warn":
+                logger.warning(f"Tool already exists: {key}")
+                self._tools[key] = tool
+            elif self.duplicate_behavior == "replace":
+                self._tools[key] = tool
+            elif self.duplicate_behavior == "error":
+                raise ValueError(f"Tool already exists: {key}")
+            elif self.duplicate_behavior == "ignore":
+                return existing
+        else:
+            self._tools[key] = tool
         return tool
 
     async def call_tool(
         self,
-        name: str,
+        key: str,
         arguments: dict[str, Any],
         context: Context[ServerSessionT, LifespanContextT] | None = None,
-    ) -> Any:
+    ) -> list[TextContent | ImageContent | EmbeddedResource]:
         """Call a tool by name with arguments."""
-        tool = self.get_tool(name)
+        tool = self.get_tool(key)
         if not tool:
-            raise ToolError(f"Unknown tool: {name}")
+            raise NotFoundError(f"Unknown tool: {key}")
 
         return await tool.run(arguments, context=context)
-
-    def import_tools(
-        self, tool_manager: ToolManager, prefix: str | None = None
-    ) -> None:
-        """
-        Import all tools from another ToolManager with prefixed names.
-
-        Args:
-            tool_manager: Another ToolManager instance to import tools from
-            prefix: Prefix to add to tool names, including the delimiter.
-                   The resulting tool name will be in the format "{prefix}{original_name}"
-                   if prefix is provided, otherwise the original name is used.
-                   For example, with prefix "weather/" and tool "forecast",
-                   the imported tool would be available as "weather/forecast"
-        """
-        for name, tool in tool_manager._tools.items():
-            prefixed_name = f"{prefix}{name}" if prefix else name
-
-            new_tool = tool.copy(updates=dict(name=prefixed_name))
-            # Store the copied tool
-            self.add_tool(new_tool)
-            logger.debug(f'Imported tool "{name}" as "{prefixed_name}"')

fastmcp/utilities/logging.py

@@ -20,15 +20,23 @@ def get_logger(name: str) -> logging.Logger:
 
 
 def configure_logging(
-    level: Literal["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"] = "INFO",
+    level: Literal["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"] | int = "INFO",
 ) -> None:
     """Configure logging for FastMCP.
 
     Args:
         level: the log level to use
     """
-    logging.basicConfig(
-        level=level,
-        format="%(message)s",
-        handlers=[RichHandler(console=Console(stderr=True), rich_tracebacks=True)],
-    )
+    # Only configure the FastMCP logger namespace
+    handler = RichHandler(console=Console(stderr=True), rich_tracebacks=True)
+    formatter = logging.Formatter("%(message)s")
+    handler.setFormatter(formatter)
+
+    fastmcp_logger = logging.getLogger("FastMCP")
+    fastmcp_logger.setLevel(level)
+
+    # Remove any existing handlers to avoid duplicates on reconfiguration
+    for hdlr in fastmcp_logger.handlers[:]:
+        fastmcp_logger.removeHandler(hdlr)
+
+    fastmcp_logger.addHandler(handler)

fastmcp/utilities/openapi.py

@@ -150,93 +150,6 @@ def _resolve_ref(
     return item
 
 
-def _extract_schema_as_dict(
-    schema_obj: Schema | Reference, openapi: OpenAPI
-) -> JsonSchema:
-    """Resolves a schema/reference and returns it as a dictionary."""
-    resolved_schema = _resolve_ref(schema_obj, openapi)
-    if isinstance(resolved_schema, Schema):
-        # Using exclude_none=True might be better than exclude_unset sometimes
-        return resolved_schema.model_dump(mode="json", by_alias=True, exclude_none=True)
-    elif isinstance(resolved_schema, dict):
-        logger.warning(
-            "Resolved schema reference resulted in a dict, not a Schema model."
-        )
-        return resolved_schema
-    else:
-        ref_str = getattr(schema_obj, "ref", "unknown")
-        logger.warning(
-            f"Expected Schema after resolving ref '{ref_str}', got {type(resolved_schema)}. Returning empty dict."
-        )
-        return {}
-
-
-def _convert_to_parameter_location(param_in: str) -> ParameterLocation:
-    """Convert string parameter location to our ParameterLocation type."""
-    if param_in == "path":
-        return "path"
-    elif param_in == "query":
-        return "query"
-    elif param_in == "header":
-        return "header"
-    elif param_in == "cookie":
-        return "cookie"
-    else:
-        logger.warning(f"Unknown parameter location: {param_in}, defaulting to 'query'")
-        return "query"
-
-
-def _extract_responses(
-    operation_responses: dict[str, Response | Reference] | None,
-    openapi: OpenAPI,
-) -> dict[str, ResponseInfo]:
-    """Extracts and resolves response information for an operation."""
-    extracted_responses: dict[str, ResponseInfo] = {}
-    if not operation_responses:
-        return extracted_responses
-
-    for status_code, resp_or_ref in operation_responses.items():
-        try:
-            response = cast(Response, _resolve_ref(resp_or_ref, openapi))
-            if not isinstance(response, Response):
-                ref_str = getattr(resp_or_ref, "ref", "unknown")
-                logger.warning(
-                    f"Expected Response after resolving ref '{ref_str}' for status code {status_code}, got {type(response)}. Skipping."
-                )
-                continue
-
-            content_schemas: dict[str, JsonSchema] = {}
-            if response.content:
-                for media_type_str, media_type_obj in response.content.items():
-                    if (
-                        isinstance(media_type_obj, MediaType)
-                        and media_type_obj.media_type_schema
-                    ):
-                        try:
-                            schema_dict = _extract_schema_as_dict(
-                                media_type_obj.media_type_schema, openapi
-                            )
-                            content_schemas[media_type_str] = schema_dict
-                        except ValueError as schema_err:
-                            logger.error(
-                                f"Failed to extract schema for media type '{media_type_str}' in response {status_code}: {schema_err}"
-                            )
-
-            resp_info = ResponseInfo(
-                description=response.description, content_schema=content_schemas
-            )
-            extracted_responses[str(status_code)] = resp_info
-
-        except (ValidationError, ValueError, AttributeError) as e:
-            ref_name = getattr(resp_or_ref, "ref", "unknown")
-            logger.error(
-                f"Failed to extract response for status code {status_code} (ref: '{ref_name}'): {e}",
-                exc_info=False,
-            )
-
-    return extracted_responses
-
-
 # --- Main Parsing Function ---
 # (No changes needed in the main loop logic, only in the helpers it calls)
 def parse_openapi_to_http_routes(openapi_dict: dict[str, Any]) -> list[HTTPRoute]:

{fastmcp-2.1.1.dist-info → fastmcp-2.2.0.dist-info}/METADATA

@@ -1,13 +1,25 @@
 Metadata-Version: 2.4
 Name: fastmcp
-Version: 2.1.1
+Version: 2.2.0
 Summary: The fast, Pythonic way to build MCP servers.
+Project-URL: Homepage, https://gofastmcp.com
+Project-URL: Repository, https://github.com/jlowin/fastmcp
+Project-URL: Documentation, https://gofastmcp.com
 Author: Jeremiah Lowin
-License: Apache-2.0
+License-Expression: Apache-2.0
 License-File: LICENSE
+Keywords: agent,fastmcp,llm,mcp,mcp client,mcp server,model context protocol
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Typing :: Typed
 Requires-Python: >=3.10
 Requires-Dist: dotenv>=0.9.9
-Requires-Dist: fastapi>=0.115.12
+Requires-Dist: exceptiongroup>=1.2.2
+Requires-Dist: httpx>=0.28.1
 Requires-Dist: mcp<2.0.0,>=1.6.0
 Requires-Dist: openapi-pydantic>=0.5.1
 Requires-Dist: rich>=13.9.4
@@ -26,6 +38,7 @@ Description-Content-Type: text/markdown
 [![Tests](https://github.com/jlowin/fastmcp/actions/workflows/run-tests.yml/badge.svg)](https://github.com/jlowin/fastmcp/actions/workflows/run-tests.yml)
 [![License](https://img.shields.io/github/license/jlowin/fastmcp.svg)](https://github.com/jlowin/fastmcp/blob/main/LICENSE)
 
+<a href="https://trendshift.io/repositories/13266" target="_blank"><img src="https://trendshift.io/api/badge/repositories/13266" alt="jlowin%2Ffastmcp | Trendshift" style="width: 250px; height: 55px;" width="250" height="55"/></a>
 </div>
 
 The [Model Context Protocol (MCP)](https://modelcontextprotocol.io) is a new, standardized way to provide context and tools to your LLMs, and FastMCP makes building MCP servers and clients simple and intuitive. Create tools, expose resources, define prompts, and connect components with clean, Pythonic code.
@@ -109,7 +122,7 @@ FastMCP provides a high-level, Pythonic interface for building and interacting w
 
 ## Why FastMCP?
 
-The MCP protocol is powerful but implementing it involves a lot of boilerplate - server setup, protocol handlers, content types, error management. FastMCP handles all the complex protocol details and server management, so you can focus on building great tools. It’s designed to be high-level and Pythonic; in most cases, decorating a function is all you need.
+The MCP protocol is powerful but implementing it involves a lot of boilerplate - server setup, protocol handlers, content types, error management. FastMCP handles all the complex protocol details and server management, so you can focus on building great tools. It's designed to be high-level and Pythonic; in most cases, decorating a function is all you need.
 
 FastMCP aims to be:
 
@@ -568,13 +581,13 @@ proxy_client = Client(
 )
 
 # Create a proxy server that connects to the client and exposes its capabilities
-proxy = FastMCP.as_proxy(proxy_client, name="Stdio-to-SSE Proxy")
+proxy = FastMCP.from_client(proxy_client, name="Stdio-to-SSE Proxy")
 
 if __name__ == "__main__":
     proxy.run(transport='sse')
 ```
 
-`FastMCP.as_proxy` is an `async` classmethod. It connects to the target, discovers its capabilities, and dynamically builds the proxy server instance.
+`FastMCP.from_client` is a class method that connects to the target, discovers its capabilities, and dynamically builds the proxy server instance.
 
 
 
@@ -787,4 +800,4 @@ We use `ruff` via `pre-commit`.
 
 Please open an issue or discussion for questions or suggestions!
 
-</details>
+</details>

fastmcp-2.2.0.dist-info/RECORD

@@ -0,0 +1,40 @@
+fastmcp/__init__.py,sha256=2bwhjiyLJisyobp1O9tVYMjriHZAx_f4bIKJYOL-Rpk,399
+fastmcp/exceptions.py,sha256=QKVHbftoZp4YZQ2NxA-t1SjztqspFdX95YTFOAmr5EE,640
+fastmcp/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+fastmcp/settings.py,sha256=VCjc-3011pKRYjt2h9rZ68XhVEekbpyLyVUREVBTSrg,1955
+fastmcp/cli/__init__.py,sha256=Ii284TNoG5lxTP40ETMGhHEq3lQZWxu9m9JuU57kUpQ,87
+fastmcp/cli/claude.py,sha256=IAlcZ4qZKBBj09jZUMEx7EANZE_IR3vcu7zOBJmMOuU,4567
+fastmcp/cli/cli.py,sha256=vdnJi_zz4ZYoPxp9xlJbh6RlGogaFY3icaOPzO_xsLE,14874
+fastmcp/client/__init__.py,sha256=BXO9NUhntZ5GnUACfaRCzDJ5IzxqFJs8qKG-CRMSco4,490
+fastmcp/client/base.py,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+fastmcp/client/client.py,sha256=1WxEaBqyAvYGhS6y_Xzei173Ufjd4rZ_REfbNFNWJnE,8033
+fastmcp/client/roots.py,sha256=IxI_bHwHTmg6c2H-s1av1ZgrRnNDieHtYwdGFbzXT5c,2471
+fastmcp/client/sampling.py,sha256=WdRhIZbWv54rXYI8lWHv0thXmGCloZYPFpwJK9El_sQ,1613
+fastmcp/client/transports.py,sha256=lEE1PbqbntbFFKlVbrJtOpWzZa6N0_d1UXwixLgcpg0,15474
+fastmcp/prompts/__init__.py,sha256=LtPAv2JKIu54AwUd3iwv-HUd4DPcwgEqy6itEd3BH_E,194
+fastmcp/prompts/prompt.py,sha256=mQ6iRnt7J8oKBUhlgPDYXnIzwwDNWCk4heTqCmv1sco,6622
+fastmcp/prompts/prompt_manager.py,sha256=tMob9a-igjuzf6oTPLPGidFpJdg5JaPJVlYgyNkiCbE,2901
+fastmcp/resources/__init__.py,sha256=t0x1j8lc74rjUKtXe9H5Gs4fpQt82K4NgBK6Y7A0xTg,467
+fastmcp/resources/resource.py,sha256=5FN2a7dpNwf7FSEYTNvQvkTxtodu1OPxSlJL-U-8yrM,2413
+fastmcp/resources/resource_manager.py,sha256=_0itubfjYvfkA_wXKa4DQN5YpE7ejXhsE1hdt7m8XwU,9072
+fastmcp/resources/template.py,sha256=Xed7mmCNHUPG2lR9YOZ2MJ1jLiHP_Cp8Osms0b69ExM,5761
+fastmcp/resources/types.py,sha256=tigil7z-SUJMakGXzDLIGSqTepPrAsRpwqwtBA4yoUY,6168
+fastmcp/server/__init__.py,sha256=pdkghG11VLMZiluQ-4_rl2JK1LMWmV003m9dDRUN8W4,92
+fastmcp/server/context.py,sha256=s1885AZRipKB3VltfaO3VEtMxGefKs8fdZByj-4tbNI,7120
+fastmcp/server/openapi.py,sha256=DVdUfs-rbBF_CIlxrI6HJ5aYbzuyDqGLAhT1TeyxwFc,22424
+fastmcp/server/proxy.py,sha256=in-ZGwd7I8h7fITKMyHXaJRqODudn7MXsG0hVv9M0rA,8580
+fastmcp/server/server.py,sha256=izKw5m1nuabaFg4DeC26DYqytEq1GkqUMiuMoNVTUYI,31681
+fastmcp/tools/__init__.py,sha256=ocw-SFTtN6vQ8fgnlF8iNAOflRmh79xS1xdO0Bc3QPE,96
+fastmcp/tools/tool.py,sha256=FGihp_hzKLj4hK7EdHNUwe8o3NMzCngw4ftMmL_X4XI,5797
+fastmcp/tools/tool_manager.py,sha256=hClv7fwj0cQSSwW0i-Swt7xiVqR4T9LVmr1Tp704nW4,3283
+fastmcp/utilities/__init__.py,sha256=-imJ8S-rXmbXMWeDamldP-dHDqAPg_wwmPVz-LNX14E,31
+fastmcp/utilities/decorators.py,sha256=AjhjsetQZF4YOPV5MTZmIxO21iFp_4fDIS3O2_KNCEg,2990
+fastmcp/utilities/func_metadata.py,sha256=uh-u3gAjLD4kCcGf0ZkZZwBTTl-84JuANZTnDqP5ztI,7841
+fastmcp/utilities/logging.py,sha256=zav8pnFxG_fvGJHUV2XpobmT9WVrmv1mlQBSCz-CPx4,1159
+fastmcp/utilities/openapi.py,sha256=PrH3usbTblaVC6jIH1UGiPEfgB2sSCLj33zA5dH7o_s,45193
+fastmcp/utilities/types.py,sha256=m2rPYMzO-ZFvvZ46N-1-Xqyw693K7yq9Z2xR4pVELyk,2091
+fastmcp-2.2.0.dist-info/METADATA,sha256=MheLzFNF_LxSDXigYZ4MS5kswED3sFguTOACOe0RjUs,27497
+fastmcp-2.2.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+fastmcp-2.2.0.dist-info/entry_points.txt,sha256=ff8bMtKX1JvXyurMibAacMSKbJEPmac9ffAKU9mLnM8,44
+fastmcp-2.2.0.dist-info/licenses/LICENSE,sha256=QwcOLU5TJoTeUhuIXzhdCEEDDvorGiC6-3YTOl4TecE,11356
+fastmcp-2.2.0.dist-info/RECORD,,

fastmcp-2.1.1.dist-info/RECORD

@@ -1,40 +0,0 @@
-fastmcp/__init__.py,sha256=2bwhjiyLJisyobp1O9tVYMjriHZAx_f4bIKJYOL-Rpk,399
-fastmcp/exceptions.py,sha256=9_KfANmugNdfZTCSZrohSeVmFmILZX5zz1LXI3wr_pw,508
-fastmcp/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-fastmcp/settings.py,sha256=r5LT5yAZmwS1Lppro_fzdrCUJ0otnAmgtjsNgDdQIvs,1980
-fastmcp/cli/__init__.py,sha256=Ii284TNoG5lxTP40ETMGhHEq3lQZWxu9m9JuU57kUpQ,87
-fastmcp/cli/claude.py,sha256=IAlcZ4qZKBBj09jZUMEx7EANZE_IR3vcu7zOBJmMOuU,4567
-fastmcp/cli/cli.py,sha256=M3BAkCjtnoGbyorUgaiqmCVSQg7S7_uEXerY-pqnOhk,13997
-fastmcp/client/__init__.py,sha256=BXO9NUhntZ5GnUACfaRCzDJ5IzxqFJs8qKG-CRMSco4,490
-fastmcp/client/base.py,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
-fastmcp/client/client.py,sha256=OMJ1FzrlcRRYKQg3DFxiQpaNDo4uYK3Acs23rxPyE-g,7941
-fastmcp/client/roots.py,sha256=IxI_bHwHTmg6c2H-s1av1ZgrRnNDieHtYwdGFbzXT5c,2471
-fastmcp/client/sampling.py,sha256=WdRhIZbWv54rXYI8lWHv0thXmGCloZYPFpwJK9El_sQ,1613
-fastmcp/client/transports.py,sha256=WVChsDV1UF0I3reiefsT3dipIh-P_K262TXpucwH-YY,14602
-fastmcp/prompts/__init__.py,sha256=LtPAv2JKIu54AwUd3iwv-HUd4DPcwgEqy6itEd3BH_E,194
-fastmcp/prompts/prompt.py,sha256=wy5gHHiTeYDsDufrVlfJzej_A7lTT34WNI9jwsEaNn8,6268
-fastmcp/prompts/prompt_manager.py,sha256=HGwg8vsx1TVh9hBBWwuDdLm-M-FzBU5oB6Xu8nZC524,3505
-fastmcp/resources/__init__.py,sha256=t0x1j8lc74rjUKtXe9H5Gs4fpQt82K4NgBK6Y7A0xTg,467
-fastmcp/resources/resource.py,sha256=MrfRdLA2FEglvRJP7KgduG7na_qgkBo-_iXTzRbil6c,2038
-fastmcp/resources/resource_manager.py,sha256=fIre1GkXhOyWJNGM36qwYoZQC74aEznV4oXfLfCoKdw,10971
-fastmcp/resources/template.py,sha256=Fpjb51_ktWFpS1aQ5CFCt1SFuPe6S7CPuyzQCz7c3Mg,3742
-fastmcp/resources/types.py,sha256=tigil7z-SUJMakGXzDLIGSqTepPrAsRpwqwtBA4yoUY,6168
-fastmcp/server/__init__.py,sha256=pdkghG11VLMZiluQ-4_rl2JK1LMWmV003m9dDRUN8W4,92
-fastmcp/server/context.py,sha256=s1885AZRipKB3VltfaO3VEtMxGefKs8fdZByj-4tbNI,7120
-fastmcp/server/openapi.py,sha256=J7HrAlRziaB2a6pwB0wStbjRJ1E5Lf818yMqD762s5U,22693
-fastmcp/server/proxy.py,sha256=gYcoQFDIBraqWMOpWSsZLqefKjL_v0v74juLW1SU1AU,8058
-fastmcp/server/server.py,sha256=ryN7o7G1gNFE1NsAuZVc3WpcmsBtcKOo-mXACN5NCoc,28814
-fastmcp/tools/__init__.py,sha256=ocw-SFTtN6vQ8fgnlF8iNAOflRmh79xS1xdO0Bc3QPE,96
-fastmcp/tools/tool.py,sha256=yPRqEM8sntDIbWPtZBy9evDg3BXupe0BKqnpvMwy7Sc,3872
-fastmcp/tools/tool_manager.py,sha256=oUT8ExxIKKpJnFxCUDwThRxdK7WADD40e6yjGBYDPmI,3498
-fastmcp/utilities/__init__.py,sha256=-imJ8S-rXmbXMWeDamldP-dHDqAPg_wwmPVz-LNX14E,31
-fastmcp/utilities/decorators.py,sha256=AjhjsetQZF4YOPV5MTZmIxO21iFp_4fDIS3O2_KNCEg,2990
-fastmcp/utilities/func_metadata.py,sha256=uh-u3gAjLD4kCcGf0ZkZZwBTTl-84JuANZTnDqP5ztI,7841
-fastmcp/utilities/logging.py,sha256=1ipiOXzgWUp3Vih_JtEiLX7aAFmrUDZNr4KrZbofZTM,818
-fastmcp/utilities/openapi.py,sha256=HiGCC5nh1sWtJRJ7DrFNhdjf1m-7SgyXWOE4nsRvyOc,48762
-fastmcp/utilities/types.py,sha256=m2rPYMzO-ZFvvZ46N-1-Xqyw693K7yq9Z2xR4pVELyk,2091
-fastmcp-2.1.1.dist-info/METADATA,sha256=Db4PK68mC7j-FCLfkUiyAg4hIaFgYho-X465u0c0sOs,26634
-fastmcp-2.1.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-fastmcp-2.1.1.dist-info/entry_points.txt,sha256=ff8bMtKX1JvXyurMibAacMSKbJEPmac9ffAKU9mLnM8,44
-fastmcp-2.1.1.dist-info/licenses/LICENSE,sha256=QwcOLU5TJoTeUhuIXzhdCEEDDvorGiC6-3YTOl4TecE,11356
-fastmcp-2.1.1.dist-info/RECORD,,