Update docs and tests

docs/servers/tools.mdx

@@ -109,16 +109,19 @@ Field provides several validation and documentation features:
 
 #### Supported Types
 
-FastMCP supports a wide range of type annotations:
+FastMCP supports a wide range of type annotations, including all Pydantic types:
 
 | Type Annotation         | Example                       | Description                         |
 | :---------------------- | :---------------------------- | :---------------------------------- |
 | Basic types             | `int`, `float`, `str`, `bool` | Simple scalar values - see [Built-in Types](#built-in-types) |
-| Binary data             | `bytes`                       | Binary content - see [Binary Data Handling](#binary-data-handling) |
+| Binary data             | `bytes`                       | Binary content - see [Binary Data](#binary-data) |
+| Date and Time           | `datetime`, `date`, `timedelta` | Date and time objects - see [Date and Time Types](#date-and-time-types) |
 | Collection types        | `list[str]`, `dict[str, int]`, `set[int]` | Collections of items - see [Collection Types](#collection-types) |
 | Optional types          | `float \| None`, `Optional[float]`| Parameters that may be null/omitted - see [Union and Optional Types](#union-and-optional-types) |
 | Union types             | `str \| int`, `Union[str, int]`| Parameters accepting multiple types - see [Union and Optional Types](#union-and-optional-types) |
 | Constrained types       | `Literal["A", "B"]`, `Enum`   | Parameters with specific allowed values - see [Constrained Types](#constrained-types) |
+| Paths                   | `Path`                        | File system paths - see [Paths](#paths) |
+| UUIDs                   | `UUID`                        | Universally unique identifiers - see [UUIDs](#uuids) |
 | Pydantic models         | `UserData`                    | Complex structured data - see [Pydantic Models](#pydantic-models) |
 
 For additional type annotations not listed here, see the [Parameter Types](#parameter-types) section below for more detailed information and examples.
@@ -334,11 +337,10 @@ The duplicate behavior options are:
 
 FastMCP supports a wide variety of parameter types to give you flexibility when designing your tools.
 
-
+FastMCP generally supports all types that Pydantic supports as fields, including all Pydantic custom types. This means you can use any type that can be validated and parsed by Pydantic in your tool parameters.
 
 FastMCP supports **type coercion** when possible. This means that if a client sends data that doesn't match the expected type, FastMCP will attempt to convert it to the appropriate type. For example, if a client sends a string for a parameter annotated as `int`, FastMCP will attempt to convert it to an integer. If the conversion is not possible, FastMCP will return a validation error.
 
-
 ### Built-in Types
 
 The most common parameter types are Python's built-in scalar types:
@@ -357,6 +359,32 @@ def process_values(
 
 These types provide clear expectations to the LLM about what values are acceptable and allow FastMCP to validate inputs properly. Even if a client provides a string like "42", it will be coerced to an integer for parameters annotated as `int`.
 
+### Date and Time Types
+
+FastMCP supports various date and time types from the `datetime` module:
+
+```python
+from datetime import datetime, date, timedelta
+
+@mcp.tool()
+def process_date_time(
+    event_date: date,             # ISO format date string or date object
+    event_time: datetime,         # ISO format datetime string or datetime object
+    duration: timedelta = timedelta(hours=1)  # Integer seconds or timedelta
+) -> str:
+    """Process date and time information."""
+    # Types are automatically converted from strings
+    assert isinstance(event_date, date)  
+    assert isinstance(event_time, datetime)
+    assert isinstance(duration, timedelta)
+    
+    return f"Event on {event_date} at {event_time} for {duration}"
+```
+
+- `datetime` - Accepts ISO format strings (e.g., "2023-04-15T14:30:00")
+- `date` - Accepts ISO format date strings (e.g., "2023-04-15")
+- `timedelta` - Accepts integer seconds or timedelta objects
+
 ### Collection Types
 
 FastMCP supports all standard Python collection types:
@@ -502,6 +530,40 @@ def process_image_data(
 
 This approach is recommended when you expect to receive base64-encoded binary data from clients.
 
+### Paths
+
+The `Path` type from the `pathlib` module can be used for file system paths:
+
+```python
+from pathlib import Path
+
+@mcp.tool()
+def process_file(path: Path) -> str:
+    """Process a file at the given path."""
+    assert isinstance(path, Path)  # Path is properly converted
+    return f"Processing file at {path}"
+```
+
+When a client sends a string path, FastMCP automatically converts it to a `Path` object.
+
+### UUIDs
+
+The `UUID` type from the `uuid` module can be used for unique identifiers:
+
+```python
+import uuid
+
+@mcp.tool()
+def process_item(
+    item_id: uuid.UUID  # String UUID or UUID object
+) -> str:
+    """Process an item with the given UUID."""
+    assert isinstance(item_id, uuid.UUID)  # Properly converted to UUID
+    return f"Processing item {item_id}"
+```
+
+When a client sends a string UUID (e.g., "123e4567-e89b-12d3-a456-426614174000"), FastMCP automatically converts it to a `UUID` object.
+
 ### Pydantic Models
 
 For complex, structured data with nested fields and validation, use Pydantic models:

tests/server/test_server_interactions.py

@@ -1,5 +1,7 @@
 import base64
+import datetime
 import json
+import uuid
 from enum import Enum
 from pathlib import Path
 from typing import Annotated, Literal
@@ -159,6 +161,8 @@ class TestTools:
             assert isinstance(content3, TextContent)
             assert content3.text == "direct content"
 
+
+class TestToolParameters:
     async def test_parameter_descriptions_with_field_annotations(self):
         mcp = FastMCP("Test Server")
 
@@ -461,6 +465,145 @@ class TestTools:
             with pytest.raises(ClientError, match="2 validation errors for analyze"):
                 await client.call_tool("analyze", {"x": "not a number"})
 
+    async def test_path_type(self):
+        mcp = FastMCP()
+
+        @mcp.tool()
+        def send_path(path: Path) -> str:
+            assert isinstance(path, Path)
+            return str(path)
+
+        async with Client(mcp) as client:
+            result = await client.call_tool("send_path", {"path": "/tmp/test.txt"})
+            assert isinstance(result[0], TextContent)
+            assert result[0].text == "/tmp/test.txt"
+
+    async def test_path_type_error(self):
+        mcp = FastMCP()
+
+        @mcp.tool()
+        def send_path(path: Path) -> str:
+            return str(path)
+
+        async with Client(mcp) as client:
+            with pytest.raises(ClientError, match="Input is not a valid path"):
+                await client.call_tool("send_path", {"path": 1})
+
+    async def test_uuid_type(self):
+        mcp = FastMCP()
+
+        @mcp.tool()
+        def send_uuid(x: uuid.UUID) -> str:
+            assert isinstance(x, uuid.UUID)
+            return str(x)
+
+        test_uuid = uuid.uuid4()
+
+        async with Client(mcp) as client:
+            result = await client.call_tool("send_uuid", {"x": test_uuid})
+            assert isinstance(result[0], TextContent)
+            assert result[0].text == str(test_uuid)
+
+    async def test_uuid_type_error(self):
+        mcp = FastMCP()
+
+        @mcp.tool()
+        def send_uuid(x: uuid.UUID) -> str:
+            return str(x)
+
+        async with Client(mcp) as client:
+            with pytest.raises(ClientError, match="Input should be a valid UUID"):
+                await client.call_tool("send_uuid", {"x": "not a uuid"})
+
+    async def test_datetime_type(self):
+        mcp = FastMCP()
+
+        @mcp.tool()
+        def send_datetime(x: datetime.datetime) -> str:
+            return x.isoformat()
+
+        async with Client(mcp) as client:
+            result = await client.call_tool(
+                "send_datetime", {"x": datetime.datetime.now()}
+            )
+            assert isinstance(result[0], TextContent)
+            assert result[0].text == datetime.datetime.now().isoformat()
+
+    async def test_datetime_type_parse_string(self):
+        mcp = FastMCP()
+
+        @mcp.tool()
+        def send_datetime(x: datetime.datetime) -> str:
+            return x.isoformat()
+
+        async with Client(mcp) as client:
+            result = await client.call_tool(
+                "send_datetime", {"x": "2021-01-01T00:00:00"}
+            )
+            assert isinstance(result[0], TextContent)
+            assert result[0].text == "2021-01-01T00:00:00"
+
+    async def test_datetime_type_error(self):
+        mcp = FastMCP()
+
+        @mcp.tool()
+        def send_datetime(x: datetime.datetime) -> str:
+            return x.isoformat()
+
+        async with Client(mcp) as client:
+            with pytest.raises(ClientError, match="Input should be a valid datetime"):
+                await client.call_tool("send_datetime", {"x": "not a datetime"})
+
+    async def test_date_type(self):
+        mcp = FastMCP()
+
+        @mcp.tool()
+        def send_date(x: datetime.date) -> str:
+            return x.isoformat()
+
+        async with Client(mcp) as client:
+            result = await client.call_tool("send_date", {"x": datetime.date.today()})
+            assert isinstance(result[0], TextContent)
+            assert result[0].text == datetime.date.today().isoformat()
+
+    async def test_date_type_parse_string(self):
+        mcp = FastMCP()
+
+        @mcp.tool()
+        def send_date(x: datetime.date) -> str:
+            return x.isoformat()
+
+        async with Client(mcp) as client:
+            result = await client.call_tool("send_date", {"x": "2021-01-01"})
+            assert isinstance(result[0], TextContent)
+            assert result[0].text == "2021-01-01"
+
+    async def test_timedelta_type(self):
+        mcp = FastMCP()
+
+        @mcp.tool()
+        def send_timedelta(x: datetime.timedelta) -> str:
+            return str(x)
+
+        async with Client(mcp) as client:
+            result = await client.call_tool(
+                "send_timedelta", {"x": datetime.timedelta(days=1)}
+            )
+            assert isinstance(result[0], TextContent)
+            assert result[0].text == "1 day, 0:00:00"
+
+    async def test_timedelta_type_parse_int(self):
+        mcp = FastMCP()
+
+        @mcp.tool()
+        def send_timedelta(x: datetime.timedelta) -> str:
+            return str(x)
+
+        async with Client(mcp) as client:
+            result = await client.call_tool("send_timedelta", {"x": 1000})
+            assert isinstance(result[0], TextContent)
+            assert result[0].text == "0:16:40"
+
 
 class TestResources:
     async def test_text_resource(self):