docs: add documentation for 19 missing features (SEP-1730 Tier 1)

Add documentation with examples for all previously undocumented features:

Server (docs/server.md - 260 lines added):
- Tools: audio results, change notifications
- Resources: binary reading, subscribing, unsubscribing
- Prompts: embedded resources, image content, change notifications
- Logging: setting level
- Elicitation: enum values, complete notification

Client (docs/client.md - 109 lines added):
- Roots: listing, change notifications
- SSE transport (legacy client)
- Ping, logging

Protocol (docs/protocol.md - 110 lines added):
- Ping, cancellation, capability negotiation
- Protocol version negotiation, JSON Schema 2020-12

All code snippets verified against SDK source.

Author: felixweinberger

docs/client.md

@@ -306,6 +306,115 @@ Pass a `logging_callback` to receive log messages from the server:
 from mcp import ClientSession, types
 
 
+async def handle_log(params: types.LoggingMessageNotificationParams) -> None:
+    """Handle log messages from the server."""
+    print(f"[{params.level}] {params.data}")
+
+
+session = ClientSession(
+    read_stream,
+    write_stream,
+    logging_callback=handle_log,
+)
+```
+
+### Setting the Server Log Level
+
+Request that the server change its minimum log level:
+
+```python
+await session.set_logging_level("debug")
+```
+
+The `level` parameter is a `LoggingLevel` string: `"debug"`, `"info"`, `"notice"`, `"warning"`, `"error"`, `"critical"`, `"alert"`, or `"emergency"`.
+
+## Roots
+
+### Listing Roots
+
+Clients can provide a `list_roots_callback` so that servers can discover the client's workspace roots (directories, project folders, etc.):
+
+```python
+from mcp import ClientSession, types
+from mcp.shared.context import RequestContext
+
+
+async def handle_list_roots(
+    context: RequestContext[ClientSession, None],
+) -> types.ListRootsResult:
+    """Return the client's workspace roots."""
+    return types.ListRootsResult(
+        roots=[
+            types.Root(uri="file:///home/user/project", name="My Project"),
+            types.Root(uri="file:///home/user/data", name="Data Folder"),
+        ]
+    )
+
+
+# Pass the callback when creating the session
+session = ClientSession(
+    read_stream,
+    write_stream,
+    list_roots_callback=handle_list_roots,
+)
+```
+
+When a `list_roots_callback` is provided, the client automatically declares the `roots` capability (with `listChanged=True`) during initialization.
+
+### Roots Change Notifications
+
+When the client's workspace roots change (e.g., a folder is added or removed), notify the server:
+
+```python
+# After roots change, notify the server
+await session.send_roots_list_changed()
+```
+
+## SSE Transport (Legacy)
+
+For servers that use the older SSE transport, use `sse_client()` from `mcp.client.sse`:
+
+```python
+import asyncio
+
+from mcp import ClientSession
+from mcp.client.sse import sse_client
+
+
+async def main():
+    async with sse_client("http://localhost:8000/sse") as (read_stream, write_stream):
+        async with ClientSession(read_stream, write_stream) as session:
+            await session.initialize()
+
+            tools = await session.list_tools()
+            print(f"Available tools: {[t.name for t in tools.tools]}")
+
+
+asyncio.run(main())
+```
+
+The `sse_client()` function accepts optional `headers`, `timeout`, `sse_read_timeout`, and `auth` parameters. The SSE transport is considered legacy; prefer [Streamable HTTP](https://modelcontextprotocol.io/specification/2025-03-26/basic/transports#streamable-http) for new servers.
+
+## Ping
+
+Send a ping to verify the server is responsive:
+
+```python
+# After session.initialize()
+result = await session.send_ping()
+# Returns EmptyResult on success; raises on timeout
+```
+
+## Logging
+
+### Receiving Log Messages
+
+Pass a `logging_callback` to receive log messages from the server:
+
+```python
+from mcp import ClientSession, types
+
+
 async def handle_log(params: types.LoggingMessageNotificationParams) -> None:
     """Handle log messages from the server."""
     print(f"[{params.level}] {params.data}")

docs/server.md

@@ -1111,6 +1111,28 @@ server = Server("Logging Level Example")
 current_level: types.LoggingLevel = "warning"
 
 
+@server.set_logging_level()
+async def handle_set_level(level: types.LoggingLevel) -> None:
+    """Handle client request to change the logging level."""
+    global current_level
+    current_level = level
+```
+
+When this handler is registered, the server automatically declares the `logging` capability during initialization.
+
+### Authentication
+
+Clients can request a minimum logging level via `logging/setLevel`. Use the low-level server API to handle this:
+
+```python
+import mcp.types as types
+from mcp.server.lowlevel import Server
+
+server = Server("Logging Level Example")
+
+current_level: types.LoggingLevel = "warning"
+
+
 @server.set_logging_level()
 async def handle_set_level(level: types.LoggingLevel) -> None:
     """Handle client request to change the logging level."""