prefecthq-fastmcp-3925-3889

total 620
drwxr-xr-x 1 root root   4096 Nov  5 18:42 .
drwxr-xr-x 1 root root   4096 Nov  5 18:42 ..
-rw-r--r-- 1 root root    115 Nov  5 18:41 .ccignore
drwxr-xr-x 1 root root   4096 Nov  5 18:42 .claude
-rw-r--r-- 1 root root     53 Nov  5 18:42 .coderabbit.yaml
drwxr-xr-x 1 root root   4096 Nov  5 18:42 .cursor
drwxr-xr-x 1 root root   4096 Nov  5 18:43 .git
drwxr-xr-x 1 root root   4096 Nov  5 18:42 .github
-rw-r--r-- 1 root root    819 Nov  5 18:41 .gitignore
-rw-r--r-- 1 root root   1369 Nov  5 18:42 .pre-commit-config.yaml
-rw-r--r-- 1 root root      5 Nov  5 18:41 .python-version

lrwxrwxrwx 1 root root      9 Nov  5 18:42 AGENTS.md -> CLAUDE.md
-rw-r--r-- 1 root root  12079 Nov  5 18:42 CLAUDE.md
-rw-r--r-- 1 root root   5218 Nov  5 18:41 CODE_OF_CONDUCT.md
-rw-r--r-- 1 root root   5633 Nov  5 18:42 CONTRIBUTING.md
-rw-r--r-- 1 root root  11356 Nov  5 18:41 LICENSE
-rw-r--r-- 
…[318 chars omitted]…
root   1198 Nov  5 18:42 loq.toml
-rw-r--r-- 1 root root   7986 Nov  5 18:42 pyproject.toml
drwxr-xr-x 1 root root   4096 Nov  5 18:42 scripts
drwxr-xr-x 1 root root   4096 Nov  5 18:42 skills
drwxr-xr-x 1 root root   4096 Nov  5 18:42 src
drwxr-xr-x 1 root root   4096 Nov  5 18:42 tests
-rw-r--r-- 1 root root 545088 Nov  5 18:42 uv.lock
drwxr-xr-x 1 root root   4096 Nov  5 18:42 v3-notes
8e453a8 base

src/fastmcp/client/telemetry.py
src/fastmcp/server/telemetry.py
src/fastmcp/telemetry.py

"""Client-side telemetry helpers."""

from collections.abc import Generator
from contextlib import contextmanager

from opentelemetry.trace import Span, SpanKind, Status, StatusCode

from fastmcp.telemetry import get_tracer


@contextmanager
def client_span(

    name: str,
    method: str,
    component_key: str,
    session_id: str | None = None,
    resource_uri: str | None = None,
) -> Generator[Span, None, None]:
    """Create a CLIENT span with standard MCP attributes.

    Automatically records any exception on the span and sets error status.
    """
    tracer = get_tracer()
    with tracer.start_as_current_span(name, kind=SpanKind.CLIENT) as span:
        attrs: dict[str, str] = {
            # RPC semantic conventions
            "rpc.system": "mcp",
            "rpc.method": method,
            # MCP semantic conventions
            "mcp.method.name": method,
            # F
…[3918 chars omitted]…
r(meta[TRACE_PARENT_KEY])
    if TRACE_STATE_KEY in meta:
        carrier["tracestate"] = str(meta[TRACE_STATE_KEY])

    if carrier:
        return propagate.extract(carrier)
    return otel_context.get_current()


__all__ = [
    "INSTRUMENTATION_NAME",
    "TRACE_PARENT_KEY",
    "TRACE_STATE_KEY",
    "extract_trace_context",
    "get_tracer",
    "inject_trace_context",
    "record_span_error",
]

async def analyze_with_context(table_name: str, ctx: Context) -> list[Message]:
                await ctx.info(f"Analyzing table {table_name}")
                schema = read_table_schema(table_name)
                return [
                    {
                        "role": "user",
                        "content": f"Analyze this schema:\n{schema}"
                    }
                ]

            @server.prompt("custom_name")
            async def analyze_file(path: str) -> list[Message]:

                content = await read_file(path)
                return [
                    {
                        "role": "user",
                        "content": {
                            "type": "resource",
                            "resource": {
                                "uri": f"file://{path}",
                                "text": content
                
…[4627 chars omitted]…
ver.providers.proxy import FastMCPProxy

                if not isinstance(server, FastMCPProxy):
                    server = FastMCP.as_proxy(server)

        # Warn if parent masks errors but child doesn't (or vice versa)
        if self._mask_error_details and not server._mask_error_details:
            logger.warning(
                f"Parent server {self.name!r} has mask_error_details=True but "

"""Tool-related methods for FastMCP Client."""

from __future__ import annotations

import uuid
import weakref
from typing import TYPE_CHECKING, Any, Literal, overload

import mcp.types
from pydantic import RootModel

if TYPE_CHECKING:

    import datetime

    from fastmcp.client.client import CallToolResult, Client
from fastmcp.client.progress import ProgressHandler
from fastmcp.client.tasks import ToolTask
from fastmcp.client.telemetry import client_span
from fastmcp.exceptions import ToolError
from fastmcp.telemetry import inject_trace_context
from fastmcp.utilities.json_schema_type import json_schema_to_type
from fastmcp.utilities.logging import get_logger
from fastmcp.utilities.timeout import normalize_timeout_to_timedelta
from fastmcp.utilities.types import get_cached_typeadapter

logger = get_logger(__name__)

AUTO_PAGINATION_MAX_PAGES = 250

# Type alias for task response unio
…[8628 chars omitted]…
a ToolTask object if task=True. If the tool returns structured
                outputs, they are returned as a dataclass (if an output schema
                is available) or a dictionary; otherwise, a list of content
                blocks is returned. Note: to receive both structured and
                unstructured outputs, use call_tool_mcp instead and access the
                raw result object.

8-
9-import mcp.types
10-from pydantic import RootModel
11-
12-if TYPE_CHECKING:
13-    import datetime
14-
15-    from fastmcp.client.client import CallToolResult, Client
16-from fastmcp.client.progress import ProgressHandler
17-from fastmcp.client.tasks import ToolTask
18:from fastmcp.client.telemetry import client_span
19-from fastmcp.exceptions import ToolError

20-from fastmcp.telemetry import inject_trace_context
21-from fastmcp.utilities.json_schema_type import json_schema_to_type
22-from fastmcp.utilities.logging import get_logger
23-from fastmcp.utilities.timeout import normalize_timeout_to_timedelta
24-from fastmcp.utilities.types import get_cached_typeadapter
25-
26-logger = get_logger(__name__)
27-
28-AUTO_PAGINATION_MAX_PAGES = 250
29-
30-# Type alias for task response union (SEP-1686 graceful degradation)
31-ToolTaskResponseUnion = RootModel[mcp.types.CreateTaskResult | m
…[8628 chars omitted]…
rgument]
218-                    )
219-                )
220-                result = await self._await_with_session_monitoring(
221-                    self.session.send_request(
222-                        request=request,  # type: ignore[arg-type]  # ty:ignore[invalid-argument-type]
223-                        result_type=mcp.types.ReadResourceResult,
224-                    )
225-                )

" Use list_prompts_mcp() with cursor for manual pagination,"
                " or increase max_pages."
            )

        return all_prompts

    # --- Prompt ---
    async def get_prompt_mcp(
        self: Client,
        name: str,
        arguments: dict[str, Any] | None = None,
        meta: dict[str, Any] | None = None,

    ) -> mcp.types.GetPromptResult:
        """Send a prompts/get request and return the complete MCP protocol result.

        Args:
            name (str): The name of the prompt to retrieve.
            arguments (dict[str, Any] | None, optional): Arguments to pass to the prompt. Defaults to None.
            meta (dict[str, Any] | None, optional): Request metadata (e.g., for SEP-1686 tasks). Defaults to None.

        Returns:
            mcp.types.GetPromptResult: The complete response object from the protocol,
                containing t
…[8629 chars omitted]…
esult(
        self: Client,
        name: str,
        result: mcp.types.CallToolResult,
        raise_on_error: bool = False,
    ) -> CallToolResult:
        """Parse an mcp.types.CallToolResult into our CallToolResult dataclass.

        Args:
            name: Tool name (for schema lookup)
            result: Raw MCP protocol result
            raise_on_error: Whether to raise ToolError on errors

74:from fastmcp.server.telemetry import server_span
1206:            with server_span(
1343:            with server_span(
1508:            with server_span(
                mw_context = MiddlewareContext[CallToolRequestParams](
                    message=mcp.types.CallToolRequestParams(
                        name=name, arguments=arguments or {}
                    ),
                    source="client",
                    type="request",
                    method="tools/call",
                    fastmcp_context=ctx,

                )
                return await self._run_middleware(
                    context=mw_context,
                    call_next=lambda context: self.call_tool(
                        context.message.name,
                        context.message.arguments or {},
                        version=version,
                        run_middleware=False,
        
…[5736 chars omitted]…
@tool decorator for examples.

        Args:
            tool: The Tool instance or @tool-decorated function to register

        Returns:
            The tool instance that was added to the server.
        """
        return self._local_provider.add_tool(tool)

    def remove_tool(self, name: str, version: str | None = None) -> None:
        """Remove tool(s) from the server.

        .. deprecated::

tests/client/telemetry/test_client_tracing.py
tests/client/telemetry/__init__.py
tests/server/telemetry/test_provider_tracing.py
tests/server/telemetry/test_server_tracing.py
tests/server/telemetry/__init__.py
tests/telemetry/test_module.py
tests/telemetry/__init__.py
"""Tests for client OpenTelemetry tracing."""

from __future__ import annotations

from collections.abc import AsyncGenerator

import pytest
from opentelemetry.sdk.trace.export.in_memory_span_exporter import InMemorySpanExporter
from opentelemetry.trace import SpanKind, StatusCode

from fastmcp import Client, FastMCP
from fastmcp.exceptions import ToolError


class TestClientToolTracing:
    """Tests for client tool call tracing."""

    async def test_call_tool_creates_span(self, trace_exporter: InMemorySpanExporter):
        server = FastMCP("test-server")

        @server.tool()
        def greet(name: str) -> str:
  
…[8630 chars omitted]…
 = client_span.attributes.get("mcp.session.id")
        server_session = server_span.attributes.get("mcp.session.id")

        assert client_session is not None, "Client span should have session ID"
        assert server_session is not None, "Server span should have session ID"
        assert client_session == server_session, (
            "Client and server should share the same session ID"
        )

"""Tests for server-level OpenTelemetry tracing."""

from __future__ import annotations

from unittest.mock import patch

import pytest
from opentelemetry.sdk.trace.export.in_memory_span_exporter import InMemorySpanExporter
from opentelemetry.trace import SpanKind, StatusCode

from fastmcp import FastMCP
from fastmcp.exceptions import NotFoundError, ToolError

from fastmcp.server.auth import AccessToken


class TestToolTracing:
    async def test_call_tool_creates_span(self, trace_exporter: InMemorySpanExporter):
        mcp = FastMCP("test-server")

        @mcp.tool()
        def greet(name: str) -> str:
            return f"Hello, {name}!"

        result = await mcp.call_tool("greet", {"name": "World"})
        assert "Hello, World!" in str(result)

        spans = trace_exporter.get_finished_spans()
        assert len(spans) == 1

        span = spans[0]
        assert span.name =
…[8629 chars omitted]…
          await mcp.call_tool("greet", {"name": "World"})

        spans = trace_exporter.get_finished_spans()
        assert len(spans) == 1

        span = spans[0]
        assert span.attributes is not None
        assert span.attributes["enduser.id"] == "client-no-scopes"
        # Scope attribute should not be present when scopes list is empty
        assert "enduser.scope" not in span.attributes

"""Custom exceptions for FastMCP."""

from mcp import McpError  # noqa: F401


class FastMCPDeprecationWarning(DeprecationWarning):
    """Deprecation warning for FastMCP APIs.

    Subclass of DeprecationWarning so that standard warning filters
    still apply, but FastMCP can selectively enable its own warnings
    without affecting other libraries in the process.
    """

class FastMCPError(Exception):
    """Base error for FastMCP."""


class ValidationError(FastMCPError):
    """Error in validating parameters or return values."""


class ResourceError(FastMCPError):
    """Error in resource operations."""


class ToolError(FastMCPError):
    """Error in tool operations."""


class PromptError(FastMCPError):
    """Error in prompt operations."""


class InvalidSignature(Exception):
    """Invalid signature for use with FastMCP."""


class ClientError(Exception):
    """Error in c
…[160 chars omitted]…
rizationError(FastMCPError):
    """Error when authorization check fails."""
15:class FastMCPError(Exception):
19:class ValidationError(FastMCPError):
23:class ResourceError(FastMCPError):
27:class ToolError(FastMCPError):
31:class PromptError(FastMCPError):
39:class ClientError(Exception):
43:class NotFoundError(Exception):
47:class DisabledError(Exception):
51:class AuthorizationError(FastMCPError):

"""Tests for provider-level OpenTelemetry tracing."""

from __future__ import annotations

from opentelemetry.sdk.trace.export.in_memory_span_exporter import InMemorySpanExporter

from fastmcp import FastMCP


class TestFastMCPProviderTracing:
    """Tests for FastMCPProvider delegation tracing."""

    async def test_mounted_tool_creates_delegate_span(
        self, trace_exporter: InMemorySpanExporter
    ):
        # Create a child server with a tool
        child = FastMCP("child-server")

        @child.tool()
        def child_tool() -> str:
            return "child result"

        # Create parent server and mount child with namespace
        parent = FastMCP("parent-server")
        parent.mount(child, namespace="child")

        # Call the tool through the parent (namespace uses underscore, not slash)
        result = await parent.call_tool("child_child_tool", {})
        as
…[3655 chars omitted]…
s in spans if s.name == "delegate greet")
        child_span = next(s for s in spans if s.name == "tools/call greet")

        # Verify parent-child relationships
        assert delegate_span.parent is not None
        assert child_span.parent is not None
        assert delegate_span.parent.span_id == parent_span.context.span_id
        assert child_span.parent.span_id == delegate_span.context.span_id

tests/server/mount/test_advanced.py:511:    async def test_enable_tool_prefixless_mount(self):
tests/server/mount/test_advanced.py:538:    async def test_enable_resource_prefixless_mount(self):
tests/server/mount/test_advanced.py:561:    async def test_enable_prompt_prefixless_mount(self):
tests/server/mount/test_mount.py:627:    async def test_child_not_mutated_by_mount(self):
tests/server/providers/test_transforming_provider.py:105:    async def test_renamed_tool_is_callable_via_mount(self):
tests/server/tasks/test_task_mount.py:625:    async def test_optional_mode_sync_through_mount(self, parent_with_modes):
tests/server/tasks/test_task_mount.py:631:    async def test_optional_mode_task_through_mount(self, parent_with_modes):
tests/server/tasks/test_task_mount.py:639:    async def test_required_mode_with_task_through_mount(self, parent_with_modes):
tests/server/tasks/test_task_moun
…[1269 chars omitted]…
quired_mode_without_task_through_mount(self, parent_with_modes):
tests/server/tasks/test_task_mount.py:657:    async def test_forbidden_mode_sync_through_mount(self, parent_with_modes):

tests/server/tasks/test_task_mount.py:663:    async def test_forbidden_mode_with_task_through_mount(self, parent_with_modes):
tests/test_fastmcp_app.py:492:    async def test_hashed_name_survives_namespace_mount(self):

190	        assert client_span.attributes["fastmcp.component.key"] == "welcome"
   191	
   192	
   193	class TestClientServerSpanHierarchy:
   194	    """Tests for span relationships between client and server."""
   195	
   196	    async def test_client_and_server_spans_created(
   197	        self, trace_exporter: InMemorySpanExporter
   198	    ):
   199	        """Both client and server should create spans for the same operation."""
   200	        server = FastMCP("test-server")
   201	

   202	        @server.tool()
   203	        def echo(message: str) -> str:
   204	            return message
   205	
   206	        client = Client(server)
   207	        async with client:
   208	            await client.call_tool("echo", {"message": "test"})
   209	
   210	        spans = trace_exporter.get_finished_spans()
   211	
   212	        # Find client span (no fastmcp.server.name) and
…[8629 chars omitted]…
utilities.tests import run_server_async
   509	
   510	        server = FastMCP("session-test-server")
   511	
   512	        @server.tool()
   513	        def echo(message: str) -> str:
   514	            return message
   515	
   516	        async with run_server_async(server) as url:
   517	            yield url
   518	
   519	    async def test_client_span_includes_session_id(
   520	        self,

300	
   301	
   302	class TestClientErrorTracing:
   303	    """Tests for client span creation during errors.
   304	
   305	    Note: MCP protocol errors are returned as successful responses with error content,
   306	    so client spans may not have ERROR status even when the operation fails. This is
   307	    different from server-side where exceptions happen inside the span.
   308	
   309	    The server-side span WILL have ERROR status because the exception occurs within
   310	    the server's span context. The client span represents the successful MCP protocol
   311	    round-trip, while application-level errors are communicated via the response.

   312	    """
   313	
   314	    async def test_call_tool_error_creates_spans(
   315	        self, trace_exporter: InMemorySpanExporter
   316	    ):
   317	        """Both client and server spans should be created when tool fai
…[8628 chars omitted]…
      )
   250	
   251	        with patch(
   252	            "fastmcp.server.dependencies.get_access_token", return_value=test_token
   253	        ):
   254	            await mcp.read_resource("config://app")
   255	
   256	        spans = trace_exporter.get_finished_spans()
   257	        assert len(spans) == 1
   258	
   259	        span = spans[0]
   260	        assert span.attributes is not None

import asyncio
import logging
import secrets
import socket
import sys
from collections.abc import Callable, Generator
from datetime import timedelta
from pathlib import Path
from typing import Any

import pytest
from opentelemetry import trace

from opentelemetry.sdk.trace import TracerProvider
from opentelemetry.sdk.trace.export import SimpleSpanProcessor
from opentelemetry.sdk.trace.export.in_memory_span_exporter import InMemorySpanExporter

from fastmcp.utilities.tests import temporary_settings

# Use SelectorEventLoop on Windows to avoid ProactorEventLoop crashes
# See: https://github.com/python/cpython/issues/116773
if sys.platform == "win32":
    asyncio.set_event_loop_policy(asyncio.WindowsSelectorEventLoopPolicy())


def pytest_collection_modifyitems(items):
    """Automatically mark tests in integration_tests folder with 'integration' marker."""
    for item in items:
        
…[2600 chars omitted]…
port = s.getsockname()[1]
                if port not in used_ports:
                    used_ports.add(port)
                    return port

    return get_port


@pytest.fixture(scope="session")
tests/conftest.py
tests/client/telemetry/test_client_tracing.py
tests/conftest.py
tests/server/telemetry/test_provider_tracing.py
tests/server/telemetry/test_server_tracing.py
tests/telemetry/test_module.py

fatal: unable to access 'https://github.com/PrefectHQ/fastmcp.git/': Could not resolve host: github.com

---
title: OpenTelemetry
sidebarTitle: Telemetry
description: Native OpenTelemetry instrumentation for distributed tracing.
icon: chart-line
tag: NEW
---

FastMCP includes native OpenTelemetry instrumentation for observability. Traces are automatically generated for tool, prompt, resource, and resource template operations, providing visibility into server behavior, request handling, and provider delegation chains.

## How It Works

FastMCP uses the OpenTelemetry API for instrumentation. This means:

- **Zero configuration required** - Instrumentation is always active
- **No overhead when unused** - Without an SDK, all operations are no-ops
- **Bring your own SDK** - You control collection, export, and sampling
- **Works with any OTEL backend** - Jaeger, Zipkin, Datadog, New Relic, etc.

## Enabling Telemetry

The easiest way to export traces is using `opentelemetry-instrument`, which 
…[7457 chars omitted]…
eld exporter
    exporter.clear()
    trace.set_tracer_provider(original_provider)

async def test_tool_creates_span(trace_exporter: InMemorySpanExporter) -> None:
    mcp = FastMCP("test")

    @mcp.tool()
    def hello() -> str:
        return "world"

    await mcp.call_tool("hello", {})

    spans = trace_exporter.get_finished_spans()
    assert any(s.name == "tools/call hello" for s in spans)
```

240	            arguments (dict[str, Any] | None, optional): Arguments to pass to the tool. Defaults to None.
   241	            version (str | None, optional): Specific tool version to call. If None, calls highest version.
   242	            timeout (datetime.timedelta | float | int | None, optional): The timeout for the tool call. Defaults to None.
   243	            progress_handler (ProgressHandler | None, optional): The progress handler to use for the tool call. Defaults to None.
   244	            raise_on_error (bool, optional): Whether to raise an exception if the tool call results in an error. Defaults to True.
   245	            meta (dict[str, Any] | None, optional): Additional metadata to include with the request.
   246	                This is useful for passing contextual information (like user IDs, trace IDs, or preferences)
   247	                that shouldn't be t
…[8629 chars omitted]…
as e:
   434	            logger.error(
   435	                f"[{client_name or 'client'}] Error parsing structured content: {e}"

   436	            )
   437	
   438	    return CallToolResult(
   439	        content=result.content,
   440	        structured_content=result.structuredContent,
   441	        meta=result.meta,
   442	        data=data,
   443	        is_error=result.isError,
   444	    )

Refused: `find /` walks the whole container FS. Scope under /repo.

/usr/local/lib/python3.12/site-packages/fastmcp-0.0.1.dev1+8e453a8.dist-info
/usr/local/lib/python3.12/site-packages/_editable_impl_fastmcp.pth
/usr/local/lib/python3.12/site-packages/mcp/server/fastmcp

grep: src/fastmcp/apps/__pycache__/config.cpython-312.pyc: binary file matches
grep: src/fastmcp/server/auth/__pycache__/auth.cpython-312.pyc: binary file matches
grep: src/fastmcp/server/__pycache__/server.cpython-312.pyc: binary file matches
grep: src/fastmcp/utilities/__pycache__/json_schema.cpython-312.pyc: binary file matches
grep: src/fastmcp/__pycache__/settings.cpython-312.pyc: binary file matches
src/fastmcp/apps/config.py:85:    be left unset (the resource itself is the UI).
src/fastmcp/contrib/bulk_tool_caller/bulk_tool_caller.py:136:                            "BulkToolCaller cannot call itself. "
src/fastmcp/server/auth/auth.py:293:            List of all routes for this provider (excluding the MCP endpoint itself)
src/fastmcp/server/auth/cimd.py:746:        # Keep CIMD redirect_uris as strings on the document itself so wildcard
src/fastmcp/server/auth/oauth_proxy/models.
…[6588 chars omitted]…
 about the prompt definition itself (returned when listing prompts).

docs/servers/providers/overview.mdx:56:Transforms can be added to individual providers (affecting just that source) or to the server itself (affecting all components). See [Transforms](/servers/transforms/transforms) for the full picture.
docs/servers/server.mdx:100:These parameters control how your server presents itself to clients.

src/fastmcp/tools/base.py:457:    def get_span_attributes(self) -> dict[str, Any]:
src/fastmcp/tools/base.py-458-        return super().get_span_attributes() | {
src/fastmcp/tools/base.py-459-            "fastmcp.component.type": "tool",
src/fastmcp/tools/base.py-460-            "fastmcp.provider.type": "LocalProvider",
src/fastmcp/tools/base.py-461-        }
src/fastmcp/tools/base.py-462-
src/fastmcp/tools/base.py-463-
src/fastmcp/tools/base.py-464-def _serialize_with_fallback(
src/fastmcp/tools/base.py-465-    result: Any, serializer: ToolResultSerializerType | None = None
src/fastmcp/tools/base.py-466-) -> str:
src/fastmcp/tools/base.py-467-    if serializer is not None:
src/fastmcp/tools/base.py-468-        try:

src/fastmcp/tools/base.py-469-            return serializer(result)
src/fastmcp/tools/base.py-470-        except Exception as e:
src/fastmcp/tools/base.py-471-            
…[4178 chars omitted]…
-> mcp.types.CreateTaskResult: ...
1236:                span.set_attributes(tool.get_span_attributes())
1360:                    span.set_attributes(synthesized.get_span_attributes())
1366:                    span.set_attributes(resource.get_span_attributes())
1403:                span.set_attributes(template.get_span_attributes())
1514:                span.set_attributes(prompt.get_span_attributes())

src/fastmcp/utilities/components.py:257:    def get_span_attributes(self) -> dict[str, Any]:
src/fastmcp/utilities/components.py-258-        """Return span attributes for telemetry.
src/fastmcp/utilities/components.py-259-
src/fastmcp/utilities/components.py-260-        Subclasses should call super() and merge their specific attributes.
src/fastmcp/utilities/components.py-261-        """
src/fastmcp/utilities/components.py-262-        return {"fastmcp.component.key": self.key}
--
src/fastmcp/prompts/base.py:404:    def get_span_attributes(self) -> dict[str, Any]:
src/fastmcp/prompts/base.py-405-        return super().get_span_attributes() | {
src/fastmcp/prompts/base.py-406-            "fastmcp.component.type": "prompt",
src/fastmcp/prompts/base.py-407-            "fastmcp.provider.type": "LocalProvider",
src/fastmcp/prompts/base.py-408-        }

src/fastmcp/prompts/base.py-409-
src/f
…[8629 chars omitted]…
i, params, task_meta=task_meta)
  1410	                except (FastMCPError, McpError):
  1411	                    logger.exception(f"Error reading resource {uri!r}")
  1412	                    raise
  1413	                except Exception as e:
  1414	                    logger.exception(f"Error reading resource {uri!r}")
  1415	                    # Handle actionable errors that should reach the LLM

1200	                        run_middleware=False,
  1201	                        task_meta=task_meta,
  1202	                    ),
  1203	                )
  1204	
  1205	            # Core logic: find and execute tool
  1206	            with server_span(
  1207	                f"tools/call {name}", "tools/call", self.name, "tool", name
  1208	            ) as span:
  1209	                # Try normal display-name resolution first.
  1210	                tool: Tool | None = await self.get_tool(name, version=version)
  1211	

  1212	                # If that fails, try hashed-name dispatch. This walks
  1213	                # the provider tree recursively (same pattern as the old
  1214	                # get_app_tool) looking for a tool whose stored hash
  1215	                # matches the parsed prefix.
  1216	                if tool is None:
  1217	                    hashed = pa
…[4252 chars omitted]…
eads highest version.
  1301	            run_middleware: If True (default), apply the middleware chain.
  1302	                Set to False when called from middleware to avoid re-applying.
  1303	            task_meta: If provided, execute as a background task and return
  1304	                CreateTaskResult. If None (default), execute synchronously and
  1305	                return ResourceResult.

[11/05/26 18:46:37] Error calling tool 'failing_tool'                           
                    ╭─────────── Traceback (most recent call last) ────────────╮
                    │ /repo/src/fastmcp/server/server.py:1240 in call_tool     │
                    │                                                          │
                    │ /repo/src/fastmcp/tools/base.py:377 in _run              │
                    │                                                          │
                    │                 ... 5 frames hidden ...                  │
                    │                                                          │
                    │ /usr/local/lib/python3.12/site-packages/pydantic/type_ad │
                    │ apter.py:410 in validate_python                          │
                    │                                                          │
      

…[8629 chars omitted]…
src/fastmcp/client/client.py", line 757, in _await_with_session_monitoring\n    return call_task.result()\n           ^^^^^^^^^^^^^^^^^^\n  File "/usr/local/lib/python3.12/site-packages/mcp/shared/session.py", line 306, in send_request\n    raise McpError(response_or_error.error)\nmcp.shared.exceptions.McpError: Error reading resource \'data://fail\': Resource error\n', 'exception.escaped': 'False'})]

tests/client/telemetry/test_client_tracing.py:52:        client_span = next(
tests/client/telemetry/test_client_tracing.py:62:        assert client_span is not None
tests/client/telemetry/test_client_tracing.py:63:        assert client_span.attributes is not None
tests/client/telemetry/test_client_tracing.py:65:        assert client_span.attributes["mcp.method.name"] == "tools/call"
tests/client/telemetry/test_client_tracing.py:67:        assert client_span.attributes["rpc.system"] == "mcp"
tests/client/telemetry/test_client_tracing.py:68:        assert client_span.attributes["rpc.method"] == "tools/call"
tests/client/telemetry/test_client_tracing.py:70:        assert client_span.attributes["fastmcp.component.key"] == "add"
tests/client/telemetry/test_client_tracing.py:112:        client_span = next(
tests/client/telemetry/test_client_tracing.py:122:        assert client_span is not N
…[5200 chars omitted]…
der(
tests/server/providers/proxy/test_proxy_server.py:880:            p for p in proxy.providers if isinstance(p, ProxyProvider)

tests/server/telemetry/test_provider_tracing.py:45:        assert delegate_span.attributes["fastmcp.provider.type"] == "FastMCPProvider"
tests/server/telemetry/test_provider_tracing.py:101:        assert delegate_span.attributes["fastmcp.provider.type"] == "FastMCPProvider"

tests/client/telemetry/test_client_tracing.py:62:        assert client_span is not None
tests/client/telemetry/test_client_tracing.py:63:        assert client_span.attributes is not None
tests/client/telemetry/test_client_tracing.py:65:        assert client_span.attributes["mcp.method.name"] == "tools/call"
tests/client/telemetry/test_client_tracing.py:67:        assert client_span.attributes["rpc.system"] == "mcp"
tests/client/telemetry/test_client_tracing.py:68:        assert client_span.attributes["rpc.method"] == "tools/call"
tests/client/telemetry/test_client_tracing.py:70:        assert client_span.attributes["fastmcp.component.key"] == "add"
tests/client/telemetry/test_client_tracing.py:122:        assert client_span is not None
tests/client/telemetry/test_client_tracing.py:123:        assert client_span.attributes is not None
tests/client/telemetry/test_client_tracing.py:125: 
…[7195 chars omitted]…
turns_current_context(
        self, trace_exporter: InMemorySpanExporter

    ):
        ctx = extract_trace_context(None)
        assert ctx is not None

    def test_empty_meta_returns_current_context(
        self, trace_exporter: InMemorySpanExporter
    ):
        ctx = extract_trace_context({})
        span_ctx = trace.get_current_span(ctx).get_span_context()
        assert not span_ctx.is_valid

docs/changelog.mdx:154:🔐 Component versioning: serve `@tool(version="2.0")` alongside older versions from one codebase. Granular authorization on individual components with async auth checks, server-wide policies via `AuthMiddleware`, and scope-based access control. OAuth gets CIMD, Static Client Registration, Azure OBO via dependency injection, JWT audience validation, and confused-deputy protections. OpenTelemetry tracing with MCP semantic conventions. Response size limiting. Background tasks with distributed Redis notification and `ctx.elicit()` relay. Security fixes include dropping `diskcache` (CVE-2025-69872) and upgrading `python-multipart` and `protobuf` for additional CVEs.
docs/changelog.mdx:162:⚡ `--reload` auto-restarts on file changes. Standalone decorators return the original function, so decorated tools stay callable in tests and non-MCP contexts. Sync functions auto-di
…[2117 chars omitted]…
y [@zzstoatzz](https://github.com/zzstoatzz) in [#521](https://github.com/PrefectHQ/fastmcp/pull/521)
docs/changelog.mdx:2278:* Add lifespan property to app by [@jlowin](https://github.com/jlowin) in [#483](https://github.com/PrefectHQ/fastmcp/pull/483)
docs/changelog.mdx:2795:* Enter mounted app lifespans by [@jlowin](https://github.com/jlowin) in [#129](https://github.com/PrefectHQ/fastmcp/pull/129)

trace_meta: dict[str, Any] = {}
    if "traceparent" in carrier:
        trace_meta[TRACE_PARENT_KEY] = carrier["traceparent"]
    if "tracestate" in carrier:
        trace_meta[TRACE_STATE_KEY] = carrier["tracestate"]

    if trace_meta:
        return {**(meta or {}), **trace_meta}
    return meta


def get_error_type(exception: BaseException) -> str:

    """Return the semantic-convention error type for an exception.

    MCP tool failures use the low-cardinality ``tool_error`` value so that they
    can be distinguished from other exception classes.
    """
    from fastmcp.exceptions import ToolError

    if isinstance(exception, ToolError):
        return "tool_error"
    return type(exception).__name__


def record_span_error(span: Span, exception: BaseException) -> None:
    """Record an exception on a span and set error status."""
    span.record_exception(exception)
    s
…[1000 chars omitted]…
 = str(meta[TRACE_PARENT_KEY])
    if TRACE_STATE_KEY in meta:
        carrier["tracestate"] = str(meta[TRACE_STATE_KEY])

    if carrier:
        return propagate.extract(carrier)
    return otel_context.get_current()


__all__ = [
    "INSTRUMENTATION_NAME",
    "TRACE_PARENT_KEY",
    "TRACE_STATE_KEY",
    "extract_trace_context",
    "get_error_type",
    "get_tracer",
    "inject_trace_context",

"""Server-side telemetry helpers."""

from collections.abc import Generator
from contextlib import contextmanager

from mcp.server.lowlevel.server import request_ctx
from opentelemetry.context import Context
from opentelemetry.trace import Span, SpanKind

from fastmcp.telemetry import extract_trace_context, get_tracer, record_span_error

def get_auth_span_attributes() -> dict[str, str]:
    """Get auth attributes for the current request, if authenticated."""
    from fastmcp.server.dependencies import get_access_token

    attrs: dict[str, str] = {}
    try:
        token = get_access_token()
        if token:
            if token.client_id:
                attrs["enduser.id"] = token.client_id
            if token.scopes:
                attrs["enduser.scope"] = " ".join(token.scopes)
    except RuntimeError:
        pass
    return attrs


def get_session_span_attributes() -> dict[
…[2564 chars omitted]…
ibutes(
            {
                "fastmcp.provider.type": provider_type,
                "fastmcp.component.key": component_key,
            }
        )
        try:
            yield span
        except Exception as e:
            record_span_error(span, e)
            raise


__all__ = [
    "delegate_span",
    "get_auth_span_attributes",
    "get_session_span_attributes",
    "server_span",
]

"""Client-side telemetry helpers."""

from collections.abc import Generator
from contextlib import contextmanager

from opentelemetry.trace import Span, SpanKind

from fastmcp.telemetry import get_tracer, record_span_error


@contextmanager
def client_span(

    name: str,
    method: str,
    component_key: str,
    session_id: str | None = None,
    resource_uri: str | None = None,
) -> Generator[Span, None, None]:
    """Create a CLIENT span with standard MCP attributes.

    Automatically records any exception on the span and sets error status.
    """
    tracer = get_tracer()
    with tracer.start_as_current_span(name, kind=SpanKind.CLIENT) as span:
        attrs: dict[str, str] = {
            # MCP semantic conventions
            "mcp.method.name": method,
            # FastMCP-specific attributes
            "fastmcp.component.key": component_key,
        }
        if method 
…[97 chars omitted]…
ompts/get":
            attrs["gen_ai.prompt.name"] = component_key
        if session_id:
            attrs["mcp.session.id"] = session_id
        if resource_uri:
            attrs["mcp.resource.uri"] = resource_uri
        span.set_attributes(attrs)
        try:
            yield span
        except Exception as e:
            record_span_error(span, e)
            raise


__all__ = ["client_span"]

src/fastmcp/client/mixins/resources.py:180:        """Send a resources/read request and return the complete MCP protocol result.
src/fastmcp/client/mixins/resources.py:196:            "resources/read",
src/fastmcp/client/mixins/resources.py:197:            "resources/read",
src/fastmcp/server/server.py:1329:                    method="resources/read",
src/fastmcp/server/server.py:1344:                "resources/read",
src/fastmcp/server/server.py:1345:                "resources/read",
src/fastmcp/server/providers/proxy.py:238:            "resources/read",
src/fastmcp/server/providers/proxy.py:239:            "resources/read",

Raises:
            RuntimeError: If called while the client is not connected.
            McpError: If the tool call requests results in a TimeoutError | JSONRPCError
        """
        with client_span(
            f"tools/call {name}",
            "tools/call",
            name,
            session_id=self.transport.get_session_id(),
        ) as span:
            logger.debug(f"[{self.name}] called call_tool: {name}")

            # Inject trace context into meta for propagation to server
            propagated_meta = inject_trace_context(meta)

            result = await self._await_with_session_monitoring(
                self.session.call_tool(
                    name=name,
                    arguments=arguments,
                    read_timeout_seconds=normalize_timeout_to_timedelta(timeout),
                    progress_callback=progress_handler or self._progress_h
…[216 chars omitted]…
lt.content[0], mcp.types.TextContent
                ):
                    message = result.content[0].text
                else:
                    message = f"Tool '{name}' returned an error"
                record_span_error(span, ToolError(message))
            return result

    async def _parse_call_tool_result(
        self: Client,
        name: str,
        result: mcp.types.CallToolResult,

2045	        """
  2046	        if server is self:
  2047	            raise ValueError("Cannot mount a server onto itself")
  2048	
  2049	        import warnings
  2050	
  2051	        from fastmcp.server.providers.fastmcp_provider import FastMCPProvider
  2052	
  2053	        # Handle deprecated prefix parameter
  2054	        if prefix is not None:
  2055	            warnings.warn(
  2056	                "The 'prefix' parameter is deprecated, use 'namespace' instead",

  2057	                FastMCPDeprecationWarning,
  2058	                stacklevel=2,
  2059	            )
  2060	            if namespace is None:
  2061	                namespace = prefix
  2062	            else:
  2063	                raise ValueError("Cannot specify both 'prefix' and 'namespace'")
  2064	
  2065	        if as_proxy is not None:
  2066	            warnings.warn(
  2067	                "as_proxy 
…[120 chars omitted]…
ifespan and middleware invoked. "
  2069	                "To create a proxy server, use create_proxy() explicitly.",
  2070	                FastMCPDeprecationWarning,
  2071	                stacklevel=2,
  2072	            )
  2073	            # Still honor the flag for backward compatibility
  2074	            if as_proxy:
  2075	                from fastmcp.server.providers.proxy import FastMCPProxy

ValueError Cannot mount a server onto itself

goodtool raised ToolError Error calling tool 'failing_tool': Something went wrong
goodtool SPAN tools/call failing_tool SpanKind.SERVER StatusCode.ERROR | ToolError: Error calling tool 'failing_tool': Something went wrong
   attrs {'mcp.method.name': 'tools/call', 'fastmcp.server.name': 'test-server', 'mcp.session.id': '24fb279c-e80b-4a6e-8900-3fca1f6ffffc', 'gen_ai.tool.name': 'failing_tool', 'fastmcp.component.key': 'tool:failing_tool@', 'fastmcp.component.type': 'tool', 'fastmcp.provider.type': 'LocalProvider', 'error.type': 'tool_error'}
goodtool SPAN tools/call failing_tool SpanKind.CLIENT StatusCode.ERROR | Error calling tool 'failing_tool': Something went wrong
   attrs {'mcp.method.name': 'tools/call', 'fastmcp.component.key': 'failing_tool', 'gen_ai.tool.name': 'failing_tool', 'error.type': 'tool_error'}
badres raised McpError Resource not found: Unknown resource: 'nonexistent://resource'
badprompt raised McpError Error rendering prompt 'failing_prompt': Prompt broke
serverbadtool raised ToolError Error calling tool 'failing_tool': Something went wrong
serverbadres raised NotFoundError Unknown resource: 'nonexistent://resource'
serverbadprompt raised PromptError Error rendering prompt 'failing_prompt': Prompt broke

badres raised McpError Resource not found: Unknown resource: 'nonexistent://resource'
badres SPAN resources/read SpanKind.SERVER StatusCode.ERROR | NotFoundError: Unknown resource: 'nonexistent://resource'
   attrs {'mcp.method.name': 'resources/read', 'fastmcp.server.name': 'test-server', 'fastmcp.component.type': 'resource', 'fastmcp.component.key': 'nonexistent://resource', 'mcp.session.id': '153002ec-d5cc-4ac2-9a3b-4a762d50de1b', 'mcp.resource.uri': 'nonexistent://resource', 'error.type': 'NotFoundError'}
badres SPAN resources/read SpanKind.CLIENT StatusCode.ERROR | McpError: Resource not found: Unknown resource: 'nonexistent://resource'
   attrs {'mcp.method.name': 'resources/read', 'fastmcp.component.key': 'nonexistent://resource', 'mcp.resource.uri': 'nonexistent://resource', 'error.type': 'McpError'}
badprompt raised McpError Error rendering prompt 'failing_prompt': Prompt bro
…[2395 chars omitted]…
pts/get failing_prompt SpanKind.SERVER StatusCode.ERROR | PromptError: Error rendering prompt 'failing_prompt': Prompt broke
   attrs {'mcp.method.name': 'prompts/get', 'fastmcp.server.name': 'test-server', 'gen_ai.prompt.name': 'failing_prompt', 'fastmcp.component.key': 'prompt:failing_prompt@', 'fastmcp.component.type': 'prompt', 'fastmcp.provider.type': 'LocalProvider', 'error.type': 'PromptError'}

ERR ToolError Error calling tool 'failing': Something went wrong
SPAN tools/call echo SpanKind.SERVER server? True StatusCode.UNSET
    {'mcp.method.name': 'tools/call', 'fastmcp.server.name': 'backend', 'mcp.session.id': 'c2844708-2d70-4e85-9ec3-ba80654691a9', 'gen_ai.tool.name': 'echo', 'fastmcp.component.key': 'tool:echo@', 'fastmcp.component.type': 'tool', 'fastmcp.provider.type': 'LocalProvider'}
SPAN tools/call echo SpanKind.CLIENT server? False StatusCode.UNSET
    {'mcp.method.name': 'tools/call', 'fastmcp.component.key': 'echo', 'gen_ai.tool.name': 'echo'}
SPAN tools/call echo SpanKind.CLIENT server? False StatusCode.UNSET
    {'mcp.method.name': 'tools/call', 'fastmcp.component.key': 'echo', 'gen_ai.tool.name': 'echo', 'fastmcp.provider.type': 'ProxyProvider'}
SPAN tools/call echo SpanKind.SERVER server? True StatusCode.UNSET
    {'mcp.method.name': 'tools/call', 'fastmcp.se
…[4104 chars omitted]…
fd23d34f-53f1-4335-b816-3ed83d403513', 'gen_ai.prompt.name': 'prompt', 'fastmcp.component.key': 'prompt:prompt@', 'fastmcp.component.type': 'prompt', 'fastmcp.provider.type': 'ProxyProvider', 'fastmcp.proxy.backend_name': None}
SPAN prompts/get prompt SpanKind.CLIENT server? False StatusCode.UNSET

    {'mcp.method.name': 'prompts/get', 'fastmcp.component.key': 'prompt', 'gen_ai.prompt.name': 'prompt'}

35:from fastmcp.client.telemetry import client_span
121:        with client_span(
237:        with client_span(
452:        with client_span(
"""ProxyProvider for proxying to remote MCP servers.

This module provides the `ProxyProvider` class that proxies components from
a remote MCP server via a client factory. It also provides proxy component
classes that forward execution to remote servers.
"""

from __future__ import annotations

import base64
import inspect
import time
from collections.abc import Awaitable, Callable, Sequence
from typing import TYPE_CHECKING, Any, cast
from urllib.parse import quote

import mcp.types
from mcp import ServerSession
from mcp.client.session import ClientSession
from mcp.server.lowlevel.server import request_ctx
from mcp.shared.context import LifespanContextT, RequestContext
from mcp.shared.exceptions import McpError
from mcp.types import (
    METHOD
…[8628 chars omitted]…

   461	            # Convert PromptMessages to Messages
   462	            messages = [
   463	                Message(content=m.content, role=m.role) for m in result.messages
   464	            ]
   465	            return PromptResult(
   466	                messages=messages,
   467	                description=result.description,
   468	                meta=result.meta,
   469	            )
   470

total 12
drwxr-xr-x 3 root root 4096 Nov  5 18:43 .
drwx------ 1 root root 4096 Nov  5 18:43 ..
drwxr-xr-x 4 root root 4096 Nov  5 18:43 pip

No locally built wheels cached.
/root/.cache/pip/selfcheck/fe300af6f7d708c14827daac3afc81fbb8306b73de8dd6e3f1f8ea3b
/root/.cache/pip/http-v2/1/1/2/7/e/1127e3d2d646b8b978b6f86221cfed3abb713e990a117406d3ce6b47
/root/.cache/pip/http-v2/1/1/2/7/e/1127e3d2d646b8b978b6f86221cfed3abb713e990a117406d3ce6b47.body
/root/.cache/pip/http-v2/1/b/1/2/1/1b121906158ba2d12abc2c30cfac9ca37bf57e7f25d46922f9e3a0b2
/root/.cache/pip/http-v2/1/b/1/2/1/1b121906158ba2d12abc2c30cfac9ca37bf57e7f25d46922f9e3a0b2.body
/root/.cache/pip/http-v2/1/4/a/a/f/14aaf7643dce3f389cfaa2f24beba9e2d02071e4624c02c288b2a440
/root/.cache/pip/http-v2/1/4/a/a/f/14aaf7643dce3f389cfaa2f24beba9e2d02071e4624c02c288b2a440.body
/root/.cache/pip/http-v2/1/5/9/c/5/159c56e4ec3c8e71dacef647c600365ad192876d095dd29b5b5c8ace.body
/root/.cache/pip/http-v2/1/5/9/c/5/159c56e4ec3c8e71dacef647c600365ad192876d095dd29b5b5c8ace
/root/.cache/pip/http-v2/
…[612 chars omitted]…

f6ae8cf0ea650598f8f49
/root/.cache/pip/http-v2/1/e/6/7/2/1e6725a5c9f97f063c4824b49960543c349f6ae8cf0ea650598f8f49.body
/root/.cache/pip/http-v2/1/d/3/5/6/1d35689f38065a2bc2b39f9d9854abf2dad854e8d71ea7ebb054c576.body
/root/.cache/pip/http-v2/1/d/3/5/6/1d35689f38065a2bc2b39f9d9854abf2dad854e8d71ea7ebb054c576
/root/.cache/pip/http-v2/1/f/d/9/a/1fd9ade2b751542e96db097082f121ecac23098b3cd95c8a877f0716.body

---
title: "Changelog"
icon: "list-check"
rss: true
tag: NEW
---

<Update label="v3.1.1" description="2026-03-14">

**[v3.1.1: 'Tis But a Patch](https://github.com/PrefectHQ/fastmcp/releases/tag/v3.1.1)**

Pins `pydantic-monty` below 0.0.8 to fix a breaking change in Monty that affects code mode. Monty 0.0.8 removed the `external_functions` constructor parameter, causing `MontySandboxProvider` to fail. This patch caps the version so existing installs work correctly.

### Fixes 🐞
* Pin pydantic-monty below 0.0.8 to fix code mode by [@jlowin](https://github.com/jlowin) in [#3497](https://github.com/PrefectHQ/fastmcp/pull/3497)

**Full Changelog**: [v3.1.0...v3.1.1](https://github.com/PrefectHQ/fastmcp/compare/v3.1.0...v3.1.1)

</Update>

<Update label="v3.1.0" description="2026-03-03">

**[v3.1.0: Code to Joy](https://github.com/PrefectHQ/fastmcp/releases/tag/v3.1.0)**

FastMCP 3.1 is t
…[8629 chars omitted]…
n, and runtime detection. The full Apps experience lands in 3.1.

---

If you hit 3.0 because you didn't pin your dependencies and something breaks — the [upgrade guides](https://gofastmcp.com/getting-started/upgrading/from-fastmcp-2) will get you sorted. We minimized breaking changes, but a major version is a major version.

```bash
pip install fastmcp -U
```

📖 [Documentation](https://gofastmcp.com)

# Generated by Docker Engine.
# This file can be edited; Docker Engine will not make further changes once it
# has been modified.

nameserver 192.168.65.7

# Based on host file: '/etc/resolv.conf' (legacy)
# Overrides: []

WARNING: Retrying (Retry(total=4, connect=None, read=None, redirect=None, status=None)) after connection broken by 'NameResolutionError("HTTPSConnection(host='pypi.org', port=443): Failed to resolve 'pypi.org' ([Errno -3] Temporary failure in name resolution)")': /simple/fastmcp/
WARNING: Retrying (Retry(total=3, connect=None, read=None, redirect=None, status=None)) after connection broken by 'NameResolutionError("HTTPSConnection(host='pypi.org', port=443): Failed to resolve 'pypi.org' ([Errno -3] Temporary failure in name resolution)")': /simple/fastmcp/
WARNING: Retrying (Retry(total=2, connect=None, read=None, redirect=None, status=None)) after connection broken by 'NameResolutionError("HTTPSConnection(host='pypi.org', port=443): Failed to resolve 'pypi.org' ([Errno -3] Temporary failure in name resolution)")': /simple/fastmcp/
WARNING: Retrying (Retry(total=1, connect=None, read=N
…[260 chars omitted]…
 connect=None, read=None, redirect=None, status=None)) after connection broken by 'NameResolutionError("HTTPSConnection(host='pypi.org', port=443): Failed to resolve 'pypi.org' ([Errno -3] Temporary failure in name resolution)")': /simple/fastmcp/
ERROR: Could not find a version that satisfies the requirement fastmcp==3.1.2 (from versions: none)
ERROR: No matching distribution found for fastmcp==3.1.2

114	    async def run(
   115	        self,
   116	        arguments: dict[str, Any],
   117	        context: Context | None = None,
   118	    ) -> ToolResult:
   119	        """Executes the tool by making a call through the client."""
   120	        backend_name = self._backend_name or self.name
   121	        with client_span(
   122	            f"tools/call {backend_name}", "tools/call", backend_name
   123	        ) as span:
   124	            span.set_attribute("fastmcp.provider.type", "ProxyProvider")
   125	            client = await self._get_client()

   126	            async with client:
   127	                ctx = context or get_context()
   128	                # StatefulProxyClient reuses sessions across requests, so
   129	                # its receive-loop task has stale ContextVars from the first
   130	                # request. Stash the current RequestContext in 
…[5940 chars omitted]…
age(content=m.content, role=m.role) for m in result.messages
   464	            ]
   465	            return PromptResult(
   466	                messages=messages,
   467	                description=result.description,
   468	                meta=result.meta,
   469	            )
   470	
   471	    def get_span_attributes(self) -> dict[str, Any]:
   472	        return super().get_span_attributes() | {

self,
        arguments: dict[str, Any],
        context: Context | None = None,
    ) -> ToolResult:
        """Executes the tool by making a call through the client."""
        backend_name = self._backend_name or self.name
        client = await self._get_client()
        async with client:
            ctx = context or get_context()
            # StatefulProxyClient reuses sessions across requests, so
            # its receive-loop task has stale ContextVars from the first
            # request. Stash the current RequestContext in the shared

            # ref so handlers can restore it before forwarding.
            if isinstance(client, StatefulProxyClient):
                client._proxy_rc_ref[0] = (
                    ctx.request_context,
                    ctx._fastmcp,  # weakref to FastMCP, not the Context
                )
            # Build meta dict from request
…[1203 chars omitted]…
ground tasks)
        return ToolResult(
            content=result.content,
            structured_content=result.structuredContent,
            meta=result.meta,
        )

    def get_span_attributes(self) -> dict[str, Any]:
        return super().get_span_attributes() | {
            "fastmcp.provider.type": "ProxyProvider",
            "fastmcp.proxy.backend_name": self._backend_name,
        }

SPAN tools/call echo SpanKind.SERVER server? True StatusCode.UNSET
SPAN tools/call echo SpanKind.CLIENT server? False StatusCode.UNSET
SPAN tools/call echo SpanKind.SERVER server? True StatusCode.UNSET
SPAN tools/call echo SpanKind.CLIENT server? False StatusCode.UNSET
SPAN tools/call failing SpanKind.SERVER server? True StatusCode.ERROR
SPAN tools/call failing SpanKind.CLIENT server? False StatusCode.ERROR
SPAN tools/call failing SpanKind.SERVER server? True StatusCode.ERROR
SPAN tools/call failing SpanKind.CLIENT server? False StatusCode.ERROR
SPAN resources/read SpanKind.SERVER server? True StatusCode.UNSET
SPAN resources/read SpanKind.CLIENT server? False StatusCode.UNSET
SPAN resources/read SpanKind.SERVER server? True StatusCode.UNSET
SPAN resources/read SpanKind.CLIENT server? False StatusCode.UNSET

SPAN prompts/get prompt SpanKind.SERVER server? True StatusCode.UNSET
SPAN prompts/get prompt SpanKind.CLIENT server? False StatusCode.UNSET
SPAN prompts/get prompt SpanKind.SERVER server? True StatusCode.UNSET
SPAN prompts/get prompt SpanKind.CLIENT server? False StatusCode.UNSET

bash: line 862: ruff: command not found

assert "app_config_data" in str(result)
    
        spans = trace_exporter.get_finished_spans()
        assert len(spans) == 1
    
        span = spans[0]
>       assert span.name == "resources/read config://app"
E       AssertionError: assert 'resources/read' == 'resources/read config://app'
E         
E         - resources/read config://app
E         + resources/read

tests/server/telemetry/test_server_tracing.py:98: AssertionError
_________ TestResourceTracing.test_read_resource_template_creates_span _________

self = <tests.server.telemetry.test_server_tracing.TestResourceTracing object at 0x7b6edc9d0650>
trace_exporter = <opentelemetry.sdk.trace.export.in_memory_span_exporter.InMemorySpanExporter object at 0x7b6edc996de0>

    async def test_read_resource_template_creates_span(
        self, trace_exporter: InMemorySpanExporter
    ):
        mcp = FastMCP("test-server"
…[4415 chars omitted]…
ing::test_read_resource_creates_span
FAILED tests/server/telemetry/test_server_tracing.py::TestResourceTracing::test_read_resource_template_creates_span
FAILED tests/server/telemetry/test_server_tracing.py::TestResourceTracing::test_read_nonexistent_resource_sets_error
FAILED tests/server/telemetry/test_server_tracing.py::TestPromptTracing::test_render_prompt_creates_span
11 failed, 28 passed in 2.39s

/repo/tests/server/mount/test_mount.py:275: FastMCPDeprecationWarning: FastMCP.as_proxy() is deprecated. Use create_proxy() from fastmcp.server instead: `from fastmcp.server import create_proxy`
    unreachable_proxy = FastMCP.as_proxy(

tests/server/mount/test_proxy.py::TestProxyServer::test_mount_proxy_server
  /repo/tests/server/mount/test_proxy.py:28: FastMCPDeprecationWarning: FastMCP.as_proxy() is deprecated. Use create_proxy() from fastmcp.server instead: `from fastmcp.server import create_proxy`
    proxy_server = FastMCP.as_proxy(FastMCPTransport(original_server))

tests/server/mount/test_proxy.py::TestProxyServer::test_dynamically_adding_to_proxied_server
  /repo/tests/server/mount/test_proxy.py:48: FastMCPDeprecationWarning: FastMCP.as_proxy() is deprecated. Use create_proxy() from fastmcp.server instead: `from fastmcp.server import create_proxy`
    proxy_server = FastMC
…[6012 chars omitted]…
ILED tests/server/providers/proxy/test_stateful_proxy_client.py::TestStatefulProxyClient::test_concurrent_log_requests_no_mixing

FAILED tests/server/providers/proxy/test_stateful_proxy_client.py::TestStatefulProxyClient::test_stateful_proxy
FAILED tests/server/providers/proxy/test_stateful_proxy_client.py::TestStatefulProxyClient::test_multi_proxies_no_mixing
4 failed, 155 passed, 33 warnings in 4.77s

ERROR    fastmcp.server.server:server.py:1242 Error calling tool 'stateful_get'
Traceback (most recent call last):
  File "/repo/tests/server/providers/proxy/test_stateful_proxy_client.py", line 41, in stateful_get
    return states[key]
           ~~~~~~^^^^^
KeyError: 138440008900704

During handling of the above exception, another exception occurred:

Traceback (most recent call last):
  File "/repo/src/fastmcp/server/server.py", line 1240, in call_tool
    return await tool._run(arguments or {}, task_meta=task_meta)

           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  File "/repo/src/fastmcp/tools/base.py", line 377, in _run
    return await self.run(arguments)
           ^^^^^^^^^^^^^^^^^^^^^^^^^
  File "/repo/src/fastmcp/tools/function_tool.py", line 278, in run
    result = await type_adapter.validate_python(arguments)
             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
…[5426 chars omitted]…
ion '_trigger_docket')

src/fastmcp/server/dependencies.py:170: ImportError
=========================== short test summary info ============================
FAILED tests/server/providers/proxy/test_stateful_proxy_client.py::TestStatefulProxyClient::test_stateful_proxy
FAILED tests/server/mount/test_advanced.py::TestMountedServerDocketBehavior::test_mounted_server_does_not_have_docket
2 failed in 1.31s

exc_type = <class 'asyncio.exceptions.CancelledError'>
exc_val = CancelledError("Cancelled via cancel scope 7a144f6f2490 by <Task pending name='Task-3' coro=<Client._session_runner() running at /repo/src/fastmcp/client/client.py:689> cb=[Task.task_wakeup()]>")

    def __exit__(
        self,
        exc_type: type[BaseException] | None,
        exc_val: BaseException | None,
        exc_tb: TracebackType | None,
    ) -> bool:
        del exc_tb
    
        if not self._active:

            raise RuntimeError("This cancel scope is not active")
        if current_task() is not self._host_task:
            raise RuntimeError(
                "Attempted to exit cancel scope in a different task than it was "
                "entered in"
            )
    
        assert self._host_task is not None
        host_task_state = _task_states.get(self._host_task)
        if host_task_state is N
…[5761 chars omitted]…
                    task_meta=task_meta)                                        
                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
                    ^^^^                                                        
                      File "/repo/src/fastmcp/tools/base.py", line 377, in _run 
                        return await self.run(arguments)

return await self.run(arguments)
           ^^^^^^^^^^^^^^^^^^^^^^^^^
  File "/tmp/base/src/fastmcp/server/providers/proxy.py", line 161, in run
    raise ToolError(cast(mcp.types.TextContent, result.content[0]).text)
fastmcp.exceptions.ToolError: Value not found
DEBUG    fastmcp.client.mixins.tools:tools.py:148 [Client-adc3] called call_tool: stateful_put
DEBUG    fastmcp.server.mixins.mcp_operations:mcp_operations.py:211 [FastMCPProxy-fe59] Handler called: call_tool stateful_put with {'value': 1}
DEBUG    fastmcp.client.mixins.tools:tools.py:148 [StatefulProxyClient-f62f:ea88] called call_tool: stateful_put
DEBUG    fastmcp.server.mixins.mcp_operations:mcp_operations.py:211 [TestServer] Handler called: call_tool stateful_put with {'value': 1}
DEBUG    fastmcp.server.mixins.mcp_operations:mcp_operations.py:108 [FastMCPProxy-fe59] Handler called: list_tools
DEBUG    fastmcp.client
…[612 chars omitted]…

ler called: call_tool stateful_get with {}
DEBUG    fastmcp.server.providers.proxy:proxy.py:1091 <fastmcp.server.providers.proxy.StatefulProxyClient object at 0x752b5bfbf1d0> will be disconnect
=========================== short test summary info ============================
FAILED tests/server/providers/proxy/test_stateful_proxy_client.py::TestStatefulProxyClient::test_stateful_proxy
1 failed in 0.17s

........................................................................ [ 86%]
...........                                                              [100%]
83 passed in 2.69s

grep: src/fastmcp/server/mixins/__pycache__/mcp_operations.cpython-312.pyc: binary file matches
grep: src/fastmcp/server/providers/skills/__pycache__/directory_provider.cpython-312.pyc: binary file matches
grep: src/fastmcp/server/providers/skills/__pycache__/skill_provider.cpython-312.pyc: binary file matches
grep: src/fastmcp/server/providers/__pycache__/aggregate.cpython-312.pyc: binary file matches
grep: src/fastmcp/server/__pycache__/dependencies.cpython-312.pyc: binary file matches
grep: src/fastmcp/server/__pycache__/server.cpython-312.pyc: binary file matches
src/fastmcp/server/dependencies.py:138:        except (importlib.metadata.PackageNotFoundError, ImportError):
src/fastmcp/server/dependencies.py:155:    except importlib.metadata.PackageNotFoundError:
src/fastmcp/server/middleware/error_handling.py:13:from fastmcp.exceptions import NotFoundError
src/fastmcp/server/middlew
…[3854 chars omitted]…
                    "Received McpError but responder is already completed. "

src/fastmcp/server/server.py:31:from mcp.shared.exceptions import McpError
src/fastmcp/server/server.py:1371:                    except (FastMCPError, McpError):
src/fastmcp/server/server.py:1410:                except (FastMCPError, McpError):
src/fastmcp/server/server.py:1519:                except (FastMCPError, McpError):

230	                    task_meta = TaskMeta(ttl=task_meta_dict.get("ttl"))
   231	            except (AttributeError, LookupError):
   232	                pass
   233	
   234	            version = VersionSpec(eq=version_str) if version_str else None
   235	            result = await server.call_tool(
   236	                key, arguments, version=version, task_meta=task_meta
   237	            )
   238	
   239	            if isinstance(result, mcp.types.CreateTaskResult):
   240	                return result
   241	            return result.to_mcp_result()

   242	
   243	        except DisabledError as e:
   244	            raise NotFoundError(f"Unknown tool: {key!r}") from e
   245	        except NotFoundError as e:
   246	            raise NotFoundError(f"Unknown tool: {key!r}") from e
   247	
   248	    async def _read_resource_mcp(
   249	        self, uri: AnyUrl | str
   250
…[4512 chars omitted]…
	        from fastmcp.server.low_level import MiddlewareServerSession
   364	
   365	        server = cast("FastMCP", self)
   366	        logger.debug(f"[{server.name}] Handler called: set_logging_level %s", level)
   367	        try:
   368	            ctx = server._mcp_server.request_context
   369	            session = ctx.session
   370	            if isinstance(session, MiddlewareServerSession):

src/fastmcp/client/mixins/resources.py |   2 +-
 src/fastmcp/client/mixins/tools.py     |  12 ++-
 src/fastmcp/client/telemetry.py        |  14 +--
 src/fastmcp/server/providers/proxy.py  | 178 +++++++++++++++------------------
 src/fastmcp/server/server.py           |   5 +-
 src/fastmcp/server/telemetry.py        |  18 ++--
 src/fastmcp/telemetry.py               |  17 +++-
 7 files changed, 126 insertions(+), 120 deletions(-)
diff --git a/src/fastmcp/client/mixins/resources.py b/src/fastmcp/client/mixins/resources.py
index c0dc27f..c97fbe9 100644
--- a/src/fastmcp/client/mixins/resources.py
+++ b/src/fastmcp/client/mixins/resources.py

@@ -193,7 +193,7 @@ class ClientResourcesMixin:
         """
         uri_str = str(uri)
         with client_span(
-            f"resources/read {uri_str}",
+            "resources/read",
             "resources/read",
             uri_str,
        
…[6087 chars omitted]…
  span.set_attribute("error.type", get_error_type(exception))
+    span.set_status(Status(StatusCode.ERROR, str(exception)))
 
 
 def extract_trace_context(meta: dict[str, Any] | None) -> Context:
@@ -116,6 +130,7 @@ __all__ = [
     "TRACE_PARENT_KEY",
     "TRACE_STATE_KEY",
     "extract_trace_context",
+    "get_error_type",
     "get_tracer",
     "inject_trace_context",
     "record_span_error",

OK

ALL CONTRACT CHECKS PASSED

M src/fastmcp/client/mixins/resources.py
 M src/fastmcp/client/mixins/tools.py
 M src/fastmcp/client/telemetry.py
 M src/fastmcp/server/providers/proxy.py
 M src/fastmcp/server/server.py
 M src/fastmcp/server/telemetry.py
 M src/fastmcp/telemetry.py
 src/fastmcp/client/mixins/resources.py |   2 +-
 src/fastmcp/client/mixins/tools.py     |  12 ++-
 src/fastmcp/client/telemetry.py        |  14 +--
 src/fastmcp/server/providers/proxy.py  | 178 +++++++++++++++------------------
 src/fastmcp/server/server.py           |   5 +-

 src/fastmcp/server/telemetry.py        |  18 ++--
 src/fastmcp/telemetry.py               |  17 +++-
 7 files changed, 126 insertions(+), 120 deletions(-)

diff --git a/src/fastmcp/server/providers/proxy.py b/src/fastmcp/server/providers/proxy.py
index b59024c..53d005c 100644
--- a/src/fastmcp/server/providers/proxy.py
+++ b/src/fastmcp/server/providers/proxy.py
@@ -32,7 +32,6 @@ from fastmcp.client.client import Client, FastMCP1Server
 from fastmcp.client.elicitation import ElicitResult
 from fastmcp.client.logging import LogMessage
 from fastmcp.client.roots import RootsList
-from fastmcp.client.telemetry import client_span
 from fastmcp.client.transports import ClientTransportT
 from fastmcp.exceptions import ResourceError, ToolError
 from fastmcp.mcp_config import MCPConfig

@@ -118,53 +117,49 @@ class ProxyTool(Tool):
     ) -> ToolResult:
         """Executes the tool by making a call through the client."""
         backend_name = self._backend_name or self.name
-        with client_span(
-            f"tools/call {backend_name}", "
…[8629 chars omitted]…
ead",
                 self.name,
                 "resource",
@@ -2043,6 +2043,9 @@ class FastMCP(
                 mounted server.
             prefix: Deprecated. Use namespace instead.
         """
+        if server is self:
+            raise ValueError("Cannot mount a server onto itself")
+
         import warnings
 
         from fastmcp.server.providers.fastmcp_provider import FastMCPProvider

(command exceeded 600s)

status StatusCode.ERROR ToolError: Error calling tool 't': Something went wrong
events 2
exception fastmcp.exceptions.ToolError False
exception fastmcp.exceptions.ToolError False
rc=0

tests/server/middleware/test_caching.py:563:        parent.mount(child, namespace="child")
tests/server/middleware/test_middleware_nested.py:218:        mcp_server.mount(nested_mcp_server, namespace="nested")
tests/server/middleware/test_middleware_nested.py:238:        mcp_server.mount(nested_mcp_server, namespace="nested")
tests/server/middleware/test_middleware_nested.py:262:        mcp_server.mount(nested_mcp_server, namespace="nested")
tests/server/middleware/test_middleware_nested.py:282:        mcp_server.mount(nested_mcp_server, namespace="nested")
tests/server/middleware/test_middleware_nested.py:306:        mcp_server.mount(nested_mcp_server, namespace="nested")
tests/server/middleware/test_middleware_nested.py:326:        mcp_server.mount(nested_mcp_server, namespace="nested")
tests/server/middleware/test_middleware_nested.py:350:        mcp_server.mount(nested_mcp_server, 
…[6840 chars omitted]…
ests/server/mount/test_proxy.py:297:        mcp.mount(sub, as_proxy=True)
tests/server/mount/test_resources.py:21:        main_app.mount(data_app, "data")
tests/server/mount/test_resources.py:44:        main_app.mount(user_app, "api")

tests/server/mount/test_resources.py:66:        main_app.mount(sub_app, namespace="sub")
tests/server/mount/test_resources.py:80:        main_app.mount(data_app, "data")

155	        if result.isError:
   156	            raise ToolError(cast(mcp.types.TextContent, result.content[0]).text)
   157	        # Preserve backend's meta (includes task metadata for background tasks)
   158	        return ToolResult(
   159	            content=result.content,
   160	            structured_content=result.structuredContent,
   161	            meta=result.meta,
   162	        )
   163	
   164	    def get_span_attributes(self) -> dict[str, Any]:
   165	        return super().get_span_attributes() | {
   166	            "fastmcp.provider.type": "ProxyProvider",

   167	            "fastmcp.proxy.backend_name": self._backend_name,
   168	        }
   169	
   170	
   171	class ProxyResource(Resource):
   172	    """A Resource that represents and reads a resource from a remote server."""
   173	
   174	    task_config: TaskConfig = TaskConfig(mode="forbidden")
   175	
…[3375 chars omitted]…
 {
   455	            "fastmcp.provider.type": "ProxyProvider",
   456	            "fastmcp.proxy.backend_name": self._backend_name,
   457	        }
   458	
   459	
   460	# -----------------------------------------------------------------------------
   461	# ProxyProvider
   462	# -----------------------------------------------------------------------------
   463	
   464	
   465	class _CacheEntry:

...                                                                      [100%]
3 passed in 0.48s

isError True
tools/call t StatusCode.ERROR Error calling tool 't': Something went wrong {'mcp.method.name': 'tools/call', 'fastmcp.component.key': 't', 'gen_ai.tool.name': 't', 'error.type': 'tool_error'}
rc=0

src/fastmcp/server/auth/middleware.py:45:        # Enhance error descriptions based on error type
src/fastmcp/server/middleware/error_handling.py:60:        error_type = type(error).__name__
src/fastmcp/server/middleware/error_handling.py:64:        error_key = f"{error_type}:{method}"
src/fastmcp/server/middleware/error_handling.py:67:        base_message = f"Error in {method}: {error_type}: {error!s}"
src/fastmcp/server/middleware/error_handling.py:92:        error_type = type(error.__cause__) if error.__cause__ else type(error)
src/fastmcp/server/middleware/error_handling.py:94:        if error_type in (ValueError, TypeError):
src/fastmcp/server/middleware/error_handling.py:98:        elif error_type in (FileNotFoundError, KeyError, NotFoundError):
src/fastmcp/server/middleware/error_handling.py:106:        elif error_type is PermissionError:
src/fastmcp/server/middleware/error_han
…[147 chars omitted]…
on) -> str:
src/fastmcp/telemetry.py:77:    """Return the semantic-convention error type for an exception.

src/fastmcp/telemetry.py:91:    span.record_exception(exception)
src/fastmcp/telemetry.py:92:    span.set_attribute("error.type", get_error_type(exception))
src/fastmcp/telemetry.py:93:    span.set_status(Status(StatusCode.ERROR, str(exception)))
src/fastmcp/telemetry.py:133:    "get_error_type",

.....................................                                    [100%]
=============================== warnings summary ===============================
tests/server/mount/test_mount.py::TestMultipleServerMount::test_mount_with_unreachable_proxy_servers
  /repo/tests/server/mount/test_mount.py:275: FastMCPDeprecationWarning: FastMCP.as_proxy() is deprecated. Use create_proxy() from fastmcp.server instead: `from fastmcp.server import create_proxy`
    unreachable_proxy = FastMCP.as_proxy(

-- Docs: https://docs.pytest.org/en/stable/how-to/capture-warnings.html
37 passed, 1 warning in 0.68s

CLEAN

...........                                                              [100%]
11 passed in 0.37s

NONE
NO_URI_IN_RESOURCE_SPAN_NAME

# Standard RPC semantic conventions
>       assert span.attributes["rpc.system"] == "mcp"
               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

tests/server/telemetry/test_server_tracing.py:37: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = {'mcp.method.name': 'tools/call', 'fastmcp.server.name': 'test-server', 'gen_ai.tool.name': 'greet', 'fastmcp.component.key': 'tool:greet@', 'fastmcp.component.type': 'tool', 'fastmcp.provider.type': 'LocalProvider'}
key = 'rpc.system'

    def __getitem__(self, key: str) -> types.AnyValue:
>       return self._dict[key]

               ^^^^^^^^^^^^^^^
E       KeyError: 'rpc.system'

/usr/local/lib/python3.12/site-packages/opentelemetry/attributes/__init__.py:166: KeyError
=========================== short test summary info ============================
FAILED tests/client/telemetry/test_client_tracing.py::TestClientErrorTracing::test_read_resource_error_creates_spans
FAILED tests/server/telemetry/test_server_tracing.py::TestToolTracing::test_call_tool_creates_span
2 failed, 5 passed in 1.26s

no-sdk ok
rc=0

tests/client
tests/client/__pycache__
tests/client/auth
tests/client/client
tests/client/client/__pycache__
tests/client/sampling
tests/client/sampling/handlers
tests/client/tasks
tests/client/telemetry
tests/client/telemetry/__pycache__
tests/client/transports

…[807 chars omitted]…
y tests pass; the visible telemetry tests that still assert the old RPC attributes/URI-bearing span names fail by design because they encode the superseded behavior."}
submitted.

/repo
total 620
drwxr-xr-x 1 root root   4096 Nov  3 08:09 .
drwxr-xr-x 1 root root   4096 Nov  3 08:10 ..
-rw-r--r-- 1 root root    115 Nov  3 08:09 .ccignore
drwxr-xr-x 1 root root   4096 Nov  3 08:09 .claude
-rw-r--r-- 1 root root     53 Nov  3 08:09 .coderabbit.yaml
drwxr-xr-x 1 root root   4096 Nov  3 08:09 .cursor
drwxr-xr-x 1 root root   4096 Nov  3 08:11 .git
drwxr-xr-x 1 root root   4096 Nov  3 08:09 .github
-rw-r--r-- 1 root root    819 Nov  3 08:09 .gitignore
-rw-r--r-- 1 root root   1369 Nov  3 08:09 .pre-commit-config.yaml

-rw-r--r-- 1 root root      5 Nov  3 08:09 .python-version
lrwxrwxrwx 1 root root      9 Nov  3 08:09 AGENTS.md -> CLAUDE.md
-rw-r--r-- 1 root root  12079 Nov  3 08:09 CLAUDE.md
-rw-r--r-- 1 root root   5218 Nov  3 08:09 CODE_OF_CONDUCT.md
-rw-r--r-- 1 root root   5633 Nov  3 08:09 CONTRIBUTING.md
-rw-r--r-- 1 root root  11356 Nov  3 08:09 LICENSE
-rw-r
…[2037 chars omitted]…
apps.py
./tests/test_apps_prefab.py
./tests/test_fastmcp_app.py
./tests/test_json_schema_generation.py
./tests/test_mcp_config.py
./tests/__init__.py
./uv.lock
./v3-notes/get-methods-consolidation.md
./v3-notes/prompt-internal-types.md
./v3-notes/provider-architecture.md
./v3-notes/provider-test-pattern.md
./v3-notes/resource-internal-types.md
./v3-notes/task-meta-parameter.md
./v3-notes/visibility.md

src/fastmcp/client/telemetry.py:6:from opentelemetry.trace import Span, SpanKind, Status, StatusCode
src/fastmcp/client/telemetry.py:24:    with tracer.start_as_current_span(name, kind=SpanKind.CLIENT) as span:
src/fastmcp/client/telemetry.py:27:            "rpc.system": "mcp",
src/fastmcp/client/telemetry.py:30:            "mcp.method.name": method,
src/fastmcp/server/telemetry.py:7:from opentelemetry.context import Context
src/fastmcp/server/telemetry.py:8:from opentelemetry.trace import Span, SpanKind, Status, StatusCode
src/fastmcp/server/telemetry.py:69:    with tracer.start_as_current_span(
src/fastmcp/server/telemetry.py:76:            "rpc.system": "mcp",
src/fastmcp/server/telemetry.py:80:            "mcp.method.name": method,
src/fastmcp/server/telemetry.py:111:    with tracer.start_as_current_span(f"delegate {name}") as span:
src/fastmcp/telemetry.py:4:It uses only the open
…[3101 chars omitted]…

sert span.attributes["rpc.system"] == "mcp"
tests/telemetry/test_module.py:5:from opentelemetry import trace
tests/telemetry/test_module.py:6:from opentelemetry.sdk.trace.export.in_memory_span_exporter import InMemorySpanExporter
tests/telemetry/test_module.py:23:        with tracer.start_as_current_span("test-span"):
tests/telemetry/test_module.py:46:        with tracer.start_as_current_span("test"):

src/fastmcp/client/mixins/prompts.py:17:from fastmcp.client.telemetry import client_span
src/fastmcp/client/mixins/prompts.py:128:        with client_span(
src/fastmcp/client/mixins/resources.py:16:from fastmcp.client.telemetry import client_span
src/fastmcp/client/mixins/resources.py:195:        with client_span(
src/fastmcp/client/mixins/tools.py:18:from fastmcp.client.telemetry import client_span
src/fastmcp/client/mixins/tools.py:142:        with client_span(
src/fastmcp/client/telemetry.py:8:from fastmcp.telemetry import get_tracer
src/fastmcp/client/telemetry.py:12:def client_span(
src/fastmcp/client/telemetry.py:23:    tracer = get_tracer()
src/fastmcp/client/telemetry.py:24:    with tracer.start_as_current_span(name, kind=SpanKind.CLIENT) as span:
src/fastmcp/client/telemetry.py:47:__all__ = ["client_span"]
src/fastmcp/server/providers/proxy.py:35:from fastmcp.client.telemetry

…[8619 chars omitted]…
c/fastmcp/client/tasks.py:380:                mcp_result = mcp.types.CallToolResult.model_validate(raw_result)
src/fastmcp/client/tasks.py:384:            elif isinstance(raw_result, mcp.types.CallToolResult):
src/fastmcp/client/tasks.py:385:                # Already a CallToolResult from MCP protocol - parse it
src/fastmcp/client/tasks.py:394:                    mcp_result = mcp.types.CallToolResult(

"""Tests for server-level OpenTelemetry tracing."""

from __future__ import annotations

from unittest.mock import patch

import pytest
from opentelemetry.sdk.trace.export.in_memory_span_exporter import InMemorySpanExporter
from opentelemetry.trace import SpanKind, StatusCode

from fastmcp import FastMCP
from fastmcp.exceptions import NotFoundError, ToolError

from fastmcp.server.auth import AccessToken


class TestToolTracing:
    async def test_call_tool_creates_span(self, trace_exporter: InMemorySpanExporter):
        mcp = FastMCP("test-server")

        @mcp.tool()
        def greet(name: str) -> str:
            return f"Hello, {name}!"

        result = await mcp.call_tool("greet", {"name": "World"})
        assert "Hello, World!" in str(result)

        spans = trace_exporter.get_finished_spans()
        assert len(spans) == 1

        span = spans[0]
        assert span.name =
…[8629 chars omitted]…
 kind"
        assert server_span.kind == SpanKind.SERVER, "Server span should be SERVER kind"

        # Verify the spans have different characteristics
        assert client_span.attributes["rpc.method"] == "tools/call"
        assert server_span.attributes["fastmcp.server.name"] == "test-server"

    async def test_trace_context_propagation(
        self, trace_exporter: InMemorySpanExporter
    ):

src/fastmcp/server/low_level.py:261:    def read_resource(
src/fastmcp/server/context.py:158:        data = await ctx.read_resource("resource://data")
src/fastmcp/server/context.py:522:        result = await self.fastmcp.render_prompt(name, arguments)
src/fastmcp/server/context.py:529:    async def read_resource(self, uri: str | AnyUrl) -> ResourceResult:
src/fastmcp/server/context.py:538:        result = await self.fastmcp.read_resource(str(uri))
src/fastmcp/server/low_level.py:261:    def read_resource(
src/fastmcp/server/middleware/authorization.py:113:    async def on_call_tool(
src/fastmcp/server/middleware/authorization.py:183:    async def on_read_resource(
src/fastmcp/server/middleware/caching.py:406:    async def on_call_tool(
src/fastmcp/server/middleware/caching.py:439:    async def on_read_resource(
src/fastmcp/server/middleware/middleware.py:156:    async def on_call_tool
…[8629 chars omitted]…

r subscription tasks (SEP-1686)
                session._subscription_task_group = tg

                async for message in session.incoming_messages:
                    tg.start_soon(
                        self._handle_message,
                        message,
                        session,
                        lifespan_context,
                        raise_exceptions,
                    )

src/fastmcp/tools/base.py:457:    def get_span_attributes(self) -> dict[str, Any]:
src/fastmcp/tools/base.py:458:        return super().get_span_attributes() | {
src/fastmcp/prompts/base.py:404:    def get_span_attributes(self) -> dict[str, Any]:
src/fastmcp/prompts/base.py:405:        return super().get_span_attributes() | {
src/fastmcp/resources/base.py:460:    def get_span_attributes(self) -> dict[str, Any]:
src/fastmcp/resources/base.py:461:        return super().get_span_attributes() | {
src/fastmcp/resources/template.py:362:    def get_span_attributes(self) -> dict[str, Any]:
src/fastmcp/resources/template.py:363:        return super().get_span_attributes() | {
src/fastmcp/server/providers/fastmcp_provider.py:140:    def get_span_attributes(self) -> dict[str, Any]:
src/fastmcp/server/providers/fastmcp_provider.py:141:        return super().get_span_attributes() | {
src/fastmcp/s
…[8629 chars omitted]…

lt.
        """
        normalized = self._normalize_contents(contents)
        super().__init__(contents=normalized, meta=meta)

    @staticmethod
    def _normalize_contents(
        contents: str | bytes | list[ResourceContent],
    ) -> list[ResourceContent]:
        """Normalize input to list[ResourceContent]."""
        if isinstance(contents, str):
            return [ResourceContent(contents)]

"""Tests for provider-level OpenTelemetry tracing."""

from __future__ import annotations

from opentelemetry.sdk.trace.export.in_memory_span_exporter import InMemorySpanExporter

from fastmcp import FastMCP


class TestFastMCPProviderTracing:
    """Tests for FastMCPProvider delegation tracing."""

    async def test_mounted_tool_creates_delegate_span(
        self, trace_exporter: InMemorySpanExporter
    ):
        # Create a child server with a tool
        child = FastMCP("child-server")

        @child.tool()
        def child_tool() -> str:
            return "child result"

        # Create parent server and mount child with namespace
        parent = FastMCP("parent-server")
        parent.mount(child, namespace="child")

        # Call the tool through the parent (namespace uses underscore, not slash)
        result = await parent.call_tool("child_child_tool", {})
        as
…[8630 chars omitted]…
.id"] is not None
tests/client/telemetry/test_client_tracing.py:599:        client_span = next(
tests/client/telemetry/test_client_tracing.py:620:        assert client_span is not None
tests/client/telemetry/test_client_tracing.py:621:        assert client_span.attributes is not None
tests/client/telemetry/test_client_tracing.py:626:        client_session = client_span.attributes.get("mcp.session.id")

./docs/python-sdk/fastmcp-telemetry.mdx:67:### `record_span_error` <sup><a href="https://github.com/PrefectHQ/fastmcp/blob/main/src/fastmcp/telemetry.py#L76" target="_blank"><Icon icon="github" style="width: 14px; height: 14px;" /></a></sup>
./docs/python-sdk/fastmcp-telemetry.mdx:70:record_span_error(span: Span, exception: BaseException) -> None
./src/fastmcp/telemetry.py:76:def record_span_error(span: Span, exception: BaseException) -> None:
./src/fastmcp/telemetry.py:121:    "record_span_error",
    ) -> mcp.types.ReadResourceResult | mcp.types.CreateTaskResult:
        """Handle MCP 'readResource' requests.

        Extracts task metadata from MCP request context and passes it explicitly
        to read_resource(). The resource's _read() method handles the backgrounding
        decision, ensuring middleware runs before Docket.

        Args:

            uri: The resource URI

    
…[8629 chars omitted]…
            " Use list_resource_templates_mcp() with cursor for manual pagination,"
                " or increase max_pages."
            )

        return all_templates

    async def read_resource_mcp(
        self: Client, uri: AnyUrl | str, meta: dict[str, Any] | None = None
    ) -> mcp.types.ReadResourceResult:
        """Send a resources/read request and return the complete MCP protocol result.

async def _parse_call_tool_result(
    name: str,
    result: mcp.types.CallToolResult,
    tool_output_schemas: dict[str, dict[str, Any] | None],
    list_tools_fn: Any,  # Callable[[], Awaitable[None]]
    client_name: str | None = None,
    raise_on_error: bool = False,
) -> CallToolResult:
    """Parse an mcp.types.CallToolResult into our CallToolResult dataclass.

    Args:
        name: Tool name (for schema lookup)

        result: Raw MCP protocol result
        tool_output_schemas: Dictionary mapping tool names to their output schemas
        list_tools_fn: Async function to refresh tool schemas if needed
        client_name: Optional client name for logging
        raise_on_error: Whether to raise ToolError on errors

    Returns:
        CallToolResult: Parsed result with structured data
    """
    # Local import: CallToolResult is under TYPE_CHECKING at module level to
  
…[8629 chars omitted]…
r rendering prompt {name!r}: {e}") from e

    def add_tool(self, tool: Tool | Callable[..., Any]) -> Tool:
        """Add a tool to the server.

        The tool function can optionally request a Context object by adding a parameter
        with the Context type annotation. See the @tool decorator for examples.

        Args:
            tool: The Tool instance or @tool-decorated function to register

class TestClientErrorTracing:
    """Tests for client span creation during errors.

    Note: MCP protocol errors are returned as successful responses with error content,
    so client spans may not have ERROR status even when the operation fails. This is
    different from server-side where exceptions happen inside the span.

    The server-side span WILL have ERROR status because the exception occurs within
    the server's span context. The client span represents the successful MCP protocol
    round-trip, while application-level errors are communicated via the response.
    """

    async def test_call_tool_error_creates_spans(
        self, trace_exporter: InMemorySpanExporter
    ):
        """Both client and server spans should be created when tool fails."""
        server = FastMCP("test-server")

        @server.tool()
        def failing_tool() -> str:
            raise Va
…[8629 chars omitted]…
_spans()
tests/client/telemetry/test_client_tracing.py:553:        trace_exporter: InMemorySpanExporter,
tests/client/telemetry/test_client_tracing.py:564:        spans = trace_exporter.get_finished_spans()
tests/client/telemetry/test_client_tracing.py:585:        trace_exporter: InMemorySpanExporter,
tests/client/telemetry/test_client_tracing.py:596:        spans = trace_exporter.get_finished_spans()

import asyncio
import logging
import secrets
import socket
import sys
from collections.abc import Callable, Generator
from datetime import timedelta
from pathlib import Path
from typing import Any

import pytest
from opentelemetry import trace

from opentelemetry.sdk.trace import TracerProvider
from opentelemetry.sdk.trace.export import SimpleSpanProcessor
from opentelemetry.sdk.trace.export.in_memory_span_exporter import InMemorySpanExporter

from fastmcp.utilities.tests import temporary_settings

# Use SelectorEventLoop on Windows to avoid ProactorEventLoop crashes
# See: https://github.com/python/cpython/issues/116773
if sys.platform == "win32":
    asyncio.set_event_loop_policy(asyncio.WindowsSelectorEventLoopPolicy())


def pytest_collection_modifyitems(items):
    """Automatically mark tests in integration_tests folder with 'integration' marker."""
    for item in items:
        
…[8629 chars omitted]…
ository = "https://github.com/PrefectHQ/fastmcp"
Documentation = "https://gofastmcp.com"

[build-system]
requires = ["hatchling", "uv-dynamic-versioning>=0.7.0"]
build-backend = "hatchling.build"

[tool.hatch.version]
source = "uv-dynamic-versioning"

[tool.hatch.metadata]
allow-direct-references = true


[tool.uv-dynamic-versioning]
vcs = "git"
style = "pep440"
bump = true
fallback-version = "0.0.0"

async def call_tool(
        self: Client,
        name: str,
        arguments: dict[str, Any] | None = None,
        *,
        version: str | None = None,
        timeout: datetime.timedelta | float | int | None = None,
        progress_handler: ProgressHandler | None = None,
        raise_on_error: bool = True,
        meta: dict[str, Any] | None = None,
        task: bool = False,
        task_id: str | None = None,

        ttl: int = 60000,
    ) -> CallToolResult | ToolTask:
        """Call a tool on the server.

        Unlike call_tool_mcp, this method raises a ToolError if the tool call results in an error.

        Args:
            name (str): The name of the tool to call.
            arguments (dict[str, Any] | None, optional): Arguments to pass to the tool. Defaults to None.
            version (str | None, optional): Specific tool version to call. If None, calls hig
…[8629 chars omitted]…
/client/mixins/prompts.py:247:    async def _get_prompt_as_task(
src/fastmcp/client/mixins/resources.py:294:            return await self._read_resource_as_task(
src/fastmcp/client/mixins/resources.py:308:    async def _read_resource_as_task(
src/fastmcp/client/mixins/tools.py:276:            return await self._call_tool_as_task(
src/fastmcp/client/mixins/tools.py:291:    async def _call_tool_as_task(

Python 3.12.13
/usr/local/bin/pytest
['', '/usr/local/lib/python312.zip', '/usr/local/lib/python3.12', '/usr/local/lib/python3.12/lib-dynload']
fastmcp /repo/src/fastmcp/__init__.py

Traceback (most recent call last):
  File "<stdin>", line 4, in <module>
ImportError: cannot import name 'InMemorySpanExporter' from 'opentelemetry.sdk.trace.export' (/usr/local/lib/python3.12/site-packages/opentelemetry/sdk/trace/export/__init__.py). Did you mean: 'ConsoleSpanExporter'?

(command exceeded 600s)

self mount accepted
[11/03/26 08:31:18] Error calling tool 'fails'                                  
                    ╭─────────── Traceback (most recent call last) ────────────╮
                    │ /repo/src/fastmcp/server/server.py:1240 in call_tool     │
                    │                                                          │
                    │ /repo/src/fastmcp/tools/base.py:377 in _run              │
                    │                                                          │
                    │                 ... 5 frames hidden ...                  │
                    │                                                          │
                    │ /usr/local/lib/python3.12/site-packages/pydantic/type_ad │
                    │ apter.py:410 in validate_python                          │
                    │ in fails:15                                  

…[342 chars omitted]…
call', 'mcp.method.name': 'tools/call', 'fastmcp.server.name': 'remote', 'mcp.session.id': 'c9b836fe-ad1a-4cdb-8899-690544eafe76', 'fastmcp.component.key': 'tool:fails@', 'fastmcp.component.type': 'tool', 'fastmcp.provider.type': 'LocalProvider'}
span: tools/call fails CLIENT UNSET None {'rpc.system': 'mcp', 'rpc.method': 'tools/call', 'mcp.method.name': 'tools/call', 'fastmcp.component.key': 'fails'}

uri (AnyUrl | str): The URI of the resource to read. Can be a string or an AnyUrl object.
            version (str | None): Specific version to read. If None, reads highest version.
            meta (dict[str, Any] | None): Optional request-level metadata.
            task (bool): If True, execute as background task (SEP-1686). Defaults to False.
            task_id (str | None): Optional client-provided task ID (auto-generated if not provided).
            ttl (int): Time to keep results available in milliseconds (default 60s).

        Returns:
            list[mcp.types.TextResourceContents | mcp.types.BlobResourceContents] | ResourceTask:
                A list of content objects if task=False, or a ResourceTask object if task=True.

        Raises:

            RuntimeError: If called while the client is not connected.
            McpError: If the request results in a 
…[8629 chars omitted]…
ewareServerSession

        server = cast("FastMCP", self)
        logger.debug(f"[{server.name}] Handler called: set_logging_level %s", level)
        try:
            ctx = server._mcp_server.request_context
            session = ctx.session
            if isinstance(session, MiddlewareServerSession):
                session._minimum_logging_level = level
        except LookupError:
            pass

)

    @classmethod
    def _ensure_tool(cls, tool: Tool | Callable[..., Any]) -> Tool:
        """Coerce a callable into a Tool, respecting @tool decorator metadata."""
        if isinstance(tool, Tool):
            return tool

        from fastmcp.decorators import get_fastmcp_meta
        from fastmcp.tools.function_tool import FunctionTool, ToolMeta

        fmeta = get_fastmcp_meta(tool)

        if isinstance(fmeta, ToolMeta):
            return FunctionTool.from_function(tool, metadata=fmeta)

        return cls.from_function(tool)

    def get_span_attributes(self) -> dict[str, Any]:
        return super().get_span_attributes() | {
            "fastmcp.component.type": "tool",
            "fastmcp.provider.type": "LocalProvider",
        }


def _serialize_with_fallback(
    result: Any, serializer: ToolResultSerializerType | None = None
) -> str:
    if serializer is 
…[8628 chars omitted]…
   """
        Import the MCP objects from another FastMCP server into this one,
        optionally with a given prefix.

        .. deprecated::
            Use :meth:`mount` instead. ``import_server`` will be removed in a
            future version.

        Note that when a server is *imported*, its objects are immediately
        registered to the importing server. This is a one-time operation and

tests/server/providers/proxy/test_proxy_client.py:91:    return FastMCP.as_proxy(ProxyClient(fastmcp_server))
tests/server/providers/proxy/test_proxy_client.py:380:        proxy_server = FastMCP.as_proxy(ProxyClient(fastmcp_server))
tests/server/providers/proxy/test_proxy_client.py:410:        # Test both as_proxy convenience method and direct client_factory usage
tests/server/providers/proxy/test_proxy_client.py:411:        proxy_via_as_proxy = FastMCP.as_proxy(base_client)
tests/server/providers/proxy/test_proxy_client.py:415:        assert proxy_via_as_proxy is not None
tests/server/providers/proxy/test_proxy_client.py:419:        assert hasattr(proxy_via_as_proxy, "_local_provider")
tests/server/providers/proxy/test_proxy_server.py:20:from fastmcp.server import create_proxy
tests/server/providers/proxy/test_proxy_server.py:24:    ProxyProvider,
tests/server/providers/proxy/test_pr
…[8629 chars omitted]…
 list caching."""
tests/server/providers/proxy/test_proxy_server.py:780:        provider = ProxyProvider(

tests/server/providers/proxy/test_proxy_server.py:798:        provider = ProxyProvider(
tests/server/providers/proxy/test_proxy_server.py:808:        provider = ProxyProvider(
src/fastmcp/server/providers/proxy.py:805:class FastMCPProxy(FastMCP):
src/fastmcp/server/server.py:2307:    def as_proxy(

) -> (
        list[ContentBlock]
        | tuple[list[ContentBlock], dict[str, Any]]
        | mcp.types.CallToolResult
        | mcp.types.CreateTaskResult
    ):
        """
        Handle MCP 'callTool' requests.

        Extracts task metadata from MCP request context and passes it explicitly
        to call_tool(). The tool's _run() method handles the backgrounding decision,
        ensuring middleware runs before Docket.

        Args:
            key: The name of the tool to call
            arguments: Arguments to pass to the tool

        Returns:
            Tool result or CreateTaskResult for background execution
        """
        server = cast("FastMCP", self)
        logger.debug(
            f"[{server.name}] Handler called: call_tool %s with %s", key, arguments
        )

        try:
            # Extract version and task metadata from request context.
         
…[8629 chars omitted]…
attempt)
                self.logger.warning(
                    f"Request {context.method} failed (attempt {attempt + 1}/{self.max_retries + 1}): "
                    f"{type(error).__name__}: {error!s}. Retrying in {delay:.1f}s..."
                )

                await anyio.sleep(delay)

        # Re-raise the last error if all retries failed
        if last_error:
            raise last_error

ToolResultSerializerType: TypeAlias = Callable[[Any], str]


def default_serializer(data: Any) -> str:
    return pydantic_core.to_json(data, fallback=str).decode()


class ToolResult(BaseModel):
    content: list[ContentBlock] = Field(
        description="List of content blocks for the tool result"
    )
    structured_content: dict[str, Any] | None = Field(

        default=None, description="Structured content matching the tool's output schema"
    )
    meta: dict[str, Any] | None = Field(
        default=None, description="Runtime metadata about the tool execution"
    )

    def __init__(
        self,
        content: list[ContentBlock] | Any | None = None,
        structured_content: dict[str, Any] | Any | None = None,
        meta: dict[str, Any] | None = None,
    ):
        if content is None and structured_content is None:
            raise ValueError("Either content or 
…[8629 chars omitted]…
dupe_with_versions(
            list(await server.list_resources()), lambda r: str(r.uri)
        )
        sdk_resources = [
            resource.to_mcp_resource(uri=str(resource.uri)) for resource in resources
        ]

        cursor = request.params.cursor if request.params else None
        page, next_cursor = _apply_pagination(
            sdk_resources, cursor, server._list_page_size
        )

src/fastmcp/client/mixins/prompts.py:107:    async def get_prompt_mcp(
src/fastmcp/client/mixins/resources.py:177:    async def read_resource_mcp(
src/fastmcp/client/mixins/tools.py:111:    async def call_tool_mcp(

            def reuse_client_factory() -> Client:
                return client

            return reuse_client_factory

        def fresh_client_factory() -> Client:
            return client.new()

        return fresh_client_factory
    else:
        # target is not a Client, so it's compatible with ProxyClient.__init__
        base_client = ProxyClient(cast(Any, target))

        def proxy_client_factory() -> Client:
            return base_client.new()

        return proxy_client_factory


# -----------------------------------------------------------------------------
# FastMCPProxy - Convenience Wrapper
# ------------------------------------------------------------
…[4195 chars omitted]…
ages to fetch before raising. Defaults to 250.

        Returns:
            list[mcp.types.Prompt]: A list of all Prompt objects.

        Raises:
            RuntimeError: If the page limit is reached before pagination completes.
            McpError: If the request results in a TimeoutError | JSONRPCError
        """
        all_prompts: list[mcp.types.Prompt] = []
        cursor: str | None = None

328:    async def _run(
335:    async def _run(
341:    async def _run(
    def convert_result(self, raw_value: Any) -> ToolResult:
        """Convert a raw result to ToolResult.

        Handles ToolResult passthrough and converts raw values using the tool's
        attributes (serializer, output_schema) for proper conversion.
        """
        if isinstance(raw_value, ToolResult):
            return raw_value

        if _HAS_PREFAB:
            if isinstance(raw_value, _PrefabApp):
                return _prefab_to_tool_result(
                    raw_value,
                    fastmcp_app_name=_get_fastmcp_app_name(self),
                )
            if isinstance(raw_value, _PrefabComponent):
                return _prefab_to_tool_result(
                    _PrefabApp(view=raw_value),
                    fastmcp_app_name=_get_fastmcp_app_name(self),
                )

       
…[8629 chars omitted]…
quence[Resource]:
        return await call_next(context)

    async def on_list_resource_templates(
        self,
        context: MiddlewareContext[mt.ListResourceTemplatesRequest],
        call_next: CallNext[
            mt.ListResourceTemplatesRequest, Sequence[ResourceTemplate]
        ],
    ) -> Sequence[ResourceTemplate]:
        return await call_next(context)

    async def on_list_prompts(

tools/call hi SERVER {'rpc.system': 'mcp', 'rpc.service': 'remote', 'rpc.method': 'tools/call', 'mcp.method.name': 'tools/call', 'fastmcp.server.name': 'remote', 'mcp.session.id': 'c90715ff-f3a3-44d2-9e41-109845f47105', 'fastmcp.component.key': 'tool:hi@', 'fastmcp.component.type': 'tool', 'fastmcp.provider.type': 'LocalProvider'}
tools/call hi CLIENT {'rpc.system': 'mcp', 'rpc.method': 'tools/call', 'mcp.method.name': 'tools/call', 'fastmcp.component.key': 'hi'}
tools/call hi CLIENT {'rpc.system': 'mcp', 'rpc.method': 'tools/call', 'mcp.method.name': 'tools/call', 'fastmcp.component.key': 'hi', 'fastmcp.provider.type': 'ProxyProvider'}
tools/call hi SERVER {'rpc.system': 'mcp', 'rpc.service': 'FastMCPProxy-1a52', 'rpc.method': 'tools/call', 'mcp.method.name': 'tools/call', 'fastmcp.server.name': 'FastMCPProxy-1a52', 'mcp.session.id': '43d7b271-25a2-4e91-846a-f5b53a00bd0a', 'fastmcp.component.key': 'tool:hi@', 'fastmcp.component.type': 'tool', 'fastmcp.provider.type': 'ProxyProvider', 'fastmcp.proxy.backend_name': None}
tools/call hi CLIENT {'rpc.system': 'mcp', 'rpc.method': 'tools/call', 'mcp.method.name': 'tools/call', 'fastmcp.component.key': 'hi'}

"""Client-side telemetry helpers."""

from collections.abc import Generator
from contextlib import contextmanager

from opentelemetry.trace import Span, SpanKind

from fastmcp.telemetry import get_tracer, record_span_error


@contextmanager
def client_span(

    name: str,
    method: str,
    component_key: str,
    session_id: str | None = None,
    resource_uri: str | None = None,
) -> Generator[Span, None, None]:
    """Create a CLIENT span with standard MCP attributes.

    Automatically records any exception on the span and sets error status.
    """
    tracer = get_tracer()
    with tracer.start_as_current_span(name, kind=SpanKind.CLIENT) as span:
        attrs: dict[str, str] = {
            # MCP semantic conventions
            "mcp.method.name": method,
            # FastMCP-specific attributes
            "fastmcp.component.key": component_key,
        }
        if method 
…[6283 chars omitted]…
error.type", error_type)
    description = str(exception) or type(exception).__name__
    span.set_status(Status(StatusCode.ERROR, description))


def extract_trace_context(meta: dict[str, Any] | None) -> Context:
    """Extract trace context from an MCP request meta dict.

    If already in a valid trace (e.g., from HTTP propagation), the existing
    trace context is preserved and meta is not used.

return cls(
            client_factory=client_factory,
            name=mcp_tool.name,
            title=mcp_tool.title,
            description=mcp_tool.description,
            parameters=mcp_tool.inputSchema,
            annotations=mcp_tool.annotations,
            output_schema=mcp_tool.outputSchema,
            icons=mcp_tool.icons,
            meta=mcp_tool.meta,
            tags=get_fastmcp_metadata(mcp_tool.meta).get("tags", []),
            execution=mcp_tool.execution,

        )

    async def run(
        self,
        arguments: dict[str, Any],
        context: Context | None = None,
    ) -> ToolResult:
        """Executes the tool by making a call through the client."""
        backend_name = self._backend_name or self.name
        with client_span(
            f"tools/call {backend_name}", "tools/call", backend_name
        ) as span:
            span.set_attri
…[8076 chars omitted]…
y]:
        return super().get_span_attributes() | {
            "fastmcp.provider.type": "ProxyProvider",
            "fastmcp.proxy.backend_name": self._backend_name,
        }


# -----------------------------------------------------------------------------
# ProxyProvider
# -----------------------------------------------------------------------------
231:    async def read(self) -> ResourceResult:

bash: line 389: ruff: command not found
 src/fastmcp/client/mixins/resources.py |   2 +-
 src/fastmcp/client/mixins/tools.py     |  12 ++-
 src/fastmcp/client/telemetry.py        |  16 +--
 src/fastmcp/server/providers/proxy.py  | 183 +++++++++++++++------------------
 src/fastmcp/server/server.py           |   5 +-
 src/fastmcp/server/telemetry.py        |  18 ++--
 src/fastmcp/telemetry.py               |   9 +-
 7 files changed, 120 insertions(+), 125 deletions(-)
diff --git a/src/fastmcp/client/mixins/resources.py b/src/fastmcp/client/mixins/resources.py
index c0dc27f..c97fbe9 100644
--- a/src/fastmcp/client/mixins/resources.py

+++ b/src/fastmcp/client/mixins/resources.py
@@ -193,7 +193,7 @@ class ClientResourcesMixin:
         """
         uri_str = str(uri)
         with client_span(
-            f"resources/read {uri_str}",
+            "resources/read",
             "resources
…[8629 chars omitted]…
ption(exception)
-    span.set_status(Status(StatusCode.ERROR))
+    error_type = "tool_error" if isinstance(exception, ToolError) else type(exception).__name__
+    span.set_attribute("error.type", error_type)
+    description = str(exception) or type(exception).__name__
+    span.set_status(Status(StatusCode.ERROR, description))
 
 
 def extract_trace_context(meta: dict[str, Any] | None) -> Context:

[11/03/26 08:45:01] Error calling tool 'fails'                                  
                    ╭─────────── Traceback (most recent call last) ────────────╮
                    │ /repo/src/fastmcp/server/server.py:1240 in call_tool     │
                    │                                                          │
                    │ /repo/src/fastmcp/tools/base.py:377 in _run              │
                    │                                                          │
                    │                 ... 5 frames hidden ...                  │
                    │                                                          │
                    │ /usr/local/lib/python3.12/site-packages/pydantic/type_ad │
                    │ apter.py:410 in validate_python                          │
                    │ in fails:26                                              │
      

…[1431 chars omitted]…
301', 'mcp.resource.uri': 'data://hello', 'fastmcp.component.key': 'resource:data://hello@', 'fastmcp.component.type': 'resource', 'fastmcp.provider.type': 'LocalProvider'}
resources/read CLIENT UNSET None {'mcp.method.name': 'resources/read', 'fastmcp.component.key': 'data://hello', 'mcp.resource.uri': 'data://hello'}
server read error: NotFoundError: Unknown resource: 'nope://resource' NotFoundError

122:[tool.pytest.ini_options]
        raise_on_error: Whether to raise ToolError on errors

    Returns:
        CallToolResult: Parsed result with structured data
    """
    # Local import: CallToolResult is under TYPE_CHECKING at module level to
    # avoid a circular import (client.client -> mixins.tools -> client.client),
    # but we need the concrete class here to construct the return value.
    from fastmcp.client.client import CallToolResult

    data = None

    if result.isError and raise_on_error:
        if result.content and isinstance(result.content[0], mcp.types.TextContent):
            msg = result.content[0].text
        else:
            msg = f"Tool '{name}' returned an error"
        raise ToolError(msg)
    elif result.structuredContent and not result.isError:
        try:
            raw_fastmcp_meta = (result.meta or {}).get("fastmcp")
            fastmcp_meta 
…[5910 chars omitted]…
  mcp = FastMCP("my-server")
    ```
"""

from typing import Any

from opentelemetry import context as otel_context
from opentelemetry import propagate, trace
from opentelemetry.context import Context
from opentelemetry.trace import Span, Status, StatusCode, Tracer

from fastmcp.exceptions import ToolError
from opentelemetry.trace import get_tracer as otel_get_tracer

INSTRUMENTATION_NAME = "fastmcp"

include_traceback: bool = False,
        error_callback: Callable[[Exception, MiddlewareContext], None] | None = None,
        transform_errors: bool = True,
    ):
        """Initialize error handling middleware.

        Args:
            logger: Logger instance for error logging. If None, uses 'fastmcp.errors'
            include_traceback: Whether to include full traceback in error logs
            error_callback: Optional callback function called for each error
            transform_errors: Whether to transform non-MCP errors to McpError
        """

        self.logger = logger or logging.getLogger("fastmcp.errors")
        self.include_traceback = include_traceback
        self.error_callback = error_callback
        self.transform_errors = transform_errors
        self.error_counts = {}

    def _log_error(self, error: Exception, context: MiddlewareContext) -> None:
   
…[6630 chars omitted]…
 clients like VS Code Copilot 1.107+.
        """
        from fastmcp.server.tasks.capabilities import get_task_capabilities

        # Get base capabilities from SDK (pass empty dict for experimental)
        # since we'll set tasks as a first-class field instead
        capabilities = super().get_capabilities(
            notification_options,
            experimental_capabilities or {},
        )

src/fastmcp/client/mixins/prompts.py:128:        with client_span(
src/fastmcp/client/mixins/resources.py:195:        with client_span(
src/fastmcp/client/mixins/tools.py:142:        with client_span(
src/fastmcp/client/telemetry.py:12:def client_span(
src/fastmcp/client/mixins/tools.py:20:from fastmcp.telemetry import inject_trace_context, record_span_error
src/fastmcp/client/mixins/tools.py:169:                record_span_error(span, ToolError(message))
src/fastmcp/client/telemetry.py:8:from fastmcp.telemetry import get_tracer, record_span_error
src/fastmcp/client/telemetry.py:43:            record_span_error(span, e)
src/fastmcp/server/telemetry.py:10:from fastmcp.telemetry import extract_trace_context, get_tracer, record_span_error
src/fastmcp/server/telemetry.py:94:            record_span_error(span, e)
src/fastmcp/server/telemetry.py:120:            record_span_error(span, e)
src/fastmcp/telemetry.py:78:def record_span_error(span: Span, exception: BaseException) -> None:

src/fastmcp/telemetry.py:126:    "record_span_error",

[tool.uv-dynamic-versioning]
vcs = "git"
style = "pep440"
bump = true
fallback-version = "0.0.0"


[tool.pytest.ini_options]
asyncio_mode = "auto"
asyncio_default_fixture_loop_scope = "function"
# filterwarnings = ["error::DeprecationWarning"]
filterwarnings = [

    # Suppress OAuth in-memory token storage warnings in tests
    # Tests intentionally use ephemeral storage; this warning is for end users
    "ignore:Using in-memory token storage:UserWarning",
    # Treat unawaited coroutine warnings as errors - these are almost always bugs
    "error:coroutine .* was never awaited:RuntimeWarning",
    "error:Exception ignored in.*coroutine:pytest.PytestUnraisableExceptionWarning",
]
timeout = 5
env = [
    "FASTMCP_TEST_MODE=1",
    'D:FASTMCP_LOG_LEVEL=DEBUG',
    'D:FASTMCP_ENABLE_RICH_TRACEBACKS=0',

]
markers = [
    "integration: marks tests as integration tests (deselect with '-m \
…[8629 chars omitted]…
uri_template when uri_template changes."""
        update = kwargs.get("update", {})
        if "uri_template" in update and self._backend_uri_template is None:
            # First time uri_template is being changed, preserve original for backend
            update = {**update, "_backend_uri_template": self.uri_template}
            kwargs["update"] = update
        return super().model_copy(**kwargs)

136:def trace_exporter(
137-    otel_trace_provider: tuple[TracerProvider, InMemorySpanExporter],
138-) -> Generator[InMemorySpanExporter, None, None]:
139-    """Get the span exporter and clear it between tests."""
140-    _, exporter = otel_trace_provider
141-    exporter.clear()
142-    yield exporter
143-    exporter.clear()
144-
145-
146-@pytest.fixture
147-def fastmcp_server():

148-    """Fixture that creates a FastMCP server with tools, resources, and prompts."""
149-    import asyncio
150-    import json
151-
152-    from fastmcp import FastMCP
153-
154-    server = FastMCP("TestServer")
155-
156-    # Add a tool
157-    @server.tool
158-    def greet(name: str) -> str:
159-        """Greet someone by name."""
160-        return f"Hello, {name}!"
161-
    def __init__(
        self,
        *,
        client_factory: ClientFactoryT,
        **kwargs,
    ):
        """Initiali
…[479 chars omitted]…
tings for the FastMCP server.
        """
        super().__init__(**kwargs)
        self.client_factory = client_factory
        provider: Provider = ProxyProvider(client_factory)
        self.add_provider(provider)


# -----------------------------------------------------------------------------
# ProxyClient and Related
# -----------------------------------------------------------------------------

return port

    return get_port


@pytest.fixture(scope="session")
def otel_trace_provider() -> Generator[
    tuple[TracerProvider, InMemorySpanExporter], None, None
]:
    """Configure OTEL SDK with in-memory span exporter for testing.

    Session-scoped because TracerProvider can only be set once per process.

    """
    exporter = InMemorySpanExporter()
    provider = TracerProvider()
    provider.add_span_processor(SimpleSpanProcessor(exporter))
    trace.set_tracer_provider(provider)
    yield provider, exporter


@pytest.fixture
def trace_exporter(
    otel_trace_provider: tuple[TracerProvider, InMemorySpanExporter],
) -> Generator[InMemorySpanExporter, None, None]:
    """Get the span exporter and clear it between tests."""
    _, exporter = otel_trace_provider
    exporter.clear()
    yield exporter
    exporter.clear()


src/fastmcp/server/server.py:2361:def create_proxy(

if name is None:
            return f"{class_name}-{secrets.token_hex(2)}"
        else:
            return f"{class_name}-{name}-{secrets.token_hex(2)}"


# -----------------------------------------------------------------------------
# Module-level Factory Functions
# -----------------------------------------------------------------------------


def create_proxy(

    target: (
        Client[ClientTransportT]
        | ClientTransport
        | FastMCP[Any]
        | FastMCP1Server
        | AnyUrl
        | Path
        | MCPConfig
        | dict[str, Any]
        | str
    ),
    **settings: Any,
) -> FastMCPProxy:
    """Create a FastMCP proxy server for the given target.

    This is the recommended way to create a proxy server. For lower-level control,
    use `FastMCPProxy` or `ProxyProvider` directly from `fastmcp.server.providers.proxy`.

    Args:
        target: T
…[5226 chars omitted]…
y[server_task_id] = weakref.ref(task_obj)
            return task_obj
        else:
            # Graceful degradation - server returned ReadResourceResult
            synthetic_task_id = task_id or str(uuid.uuid4())
            return ResourceTask(
                self,
                synthetic_task_id,
                uri=str(uri),
                immediate_result=raw_result.contents,
            )

.FFF.FF
=================================== FAILURES ===================================
_____________ TestClientToolTracing.test_call_tool_span_attributes _____________

self = <tests.client.telemetry.test_client_tracing.TestClientToolTracing object at 0x74f624447230>
trace_exporter = <opentelemetry.sdk.trace.export.in_memory_span_exporter.InMemorySpanExporter object at 0x74f62459f740>

    async def test_call_tool_span_attributes(
        self, trace_exporter: InMemorySpanExporter
    ):
        server = FastMCP("test-server")
    

        @server.tool()
        def add(a: int, b: int) -> int:
            return a + b
    
        client = Client(server)
        async with client:
            await client.call_tool("add", {"a": 1, "b": 2})
    
        spans = trace_exporter.get_finished_spans()
    
        # Find client-side span (doesn't have fastmcp.server.name)
        client_s
…[8629 chars omitted]…
:TestClientResourceTracing::test_read_resource_span_attributes
FAILED tests/client/telemetry/test_client_tracing.py::TestClientPromptTracing::test_get_prompt_span_attributes
FAILED tests/client/telemetry/test_client_tracing.py::TestClientServerSpanHierarchy::test_client_and_server_spans_created
!!!!!!!!!!!!!!!!!!!!!!!!!! stopping after 5 failures !!!!!!!!!!!!!!!!!!!!!!!!!!!
5 failed, 2 passed in 1.82s

F..FFFF.............................F................................... [ 76%]
......................                                                   [100%]
=================================== FAILURES ===================================
_________________ TestToolTracing.test_call_tool_creates_span __________________

self = <tests.server.telemetry.test_server_tracing.TestToolTracing object at 0x703482f280e0>
trace_exporter = <opentelemetry.sdk.trace.export.in_memory_span_exporter.InMemorySpanExporter object at 0x7034822056a0>

    async def test_call_tool_creates_span(self, trace_exporter: InMemorySpanExporter):
        mcp = FastMCP("test-server")
    
        @mcp.tool()

        def greet(name: str) -> str:
            return f"Hello, {name}!"
    
        result = await mcp.call_tool("greet", {"name": "World"})
        assert "Hello, World!" in str(result)
    
        spans = 
…[8628 chars omitted]…
_template_creates_span
FAILED tests/server/telemetry/test_server_tracing.py::TestResourceTracing::test_read_nonexistent_resource_sets_error
FAILED tests/server/telemetry/test_server_tracing.py::TestPromptTracing::test_render_prompt_creates_span
FAILED tests/server/mount/test_advanced.py::TestMountedServerDocketBehavior::test_mounted_server_does_not_have_docket
6 failed, 88 passed, 18 warnings in 4.57s

18:    async def test_call_tool_creates_span(self, trace_exporter: InMemorySpanExporter):
36:    async def test_call_tool_span_attributes(
76:    async def test_read_resource_creates_span(
96:    async def test_read_resource_span_attributes(
138:    async def test_get_prompt_creates_span(self, trace_exporter: InMemorySpanExporter):
156:    async def test_get_prompt_span_attributes(
196:    async def test_client_and_server_spans_created(
248:    async def test_trace_context_propagation(
314:    async def test_call_tool_error_creates_spans(
361:    async def test_read_resource_error_creates_spans(
408:    async def test_get_prompt_error_creates_spans(
455:    async def test_call_nonexistent_tool_creates_spans(

519:    async def test_client_span_includes_session_id(
551:    async def test_server_span_includes_session_id(
583:    async def test_client_and_server_share_same_session_id(
17:
…[8697 chars omitted]…
sources.py:159:    async def test_mounted_template_with_query_param(self):
tests/server/mount/test_resources.py:173:    async def test_mounted_template_with_query_param_default(self):
tests/server/mount/test_resources.py:187:    async def test_mounted_template_with_multiple_query_params(self):
tests/server/mount/test_resources.py:203:    async def test_mounted_template_with_partial_query_params(self):

)

        result = await self.call_tool_mcp(
            name=name,
            arguments=arguments or {},
            timeout=timeout,
            progress_handler=progress_handler,
            meta=request_meta or None,
        )
        return await self._parse_call_tool_result(
            name, result, raise_on_error=raise_on_error
        )

    async def _call_tool_as_task(
        self: Client,
        name: str,
        arguments: dict[str, Any] | None = None,
        task_id: str | None = None,
        ttl: int = 60000,
        meta: dict[str, Any] | None = None,
    ) -> ToolTask:
        """Call a tool for background execution (SEP-1686).

        Returns a ToolTask object that handles both background and immediate execution.
        If the server accepts background execution, ToolTask will poll for results.
        If the server declines (graceful degradation
…[8368 chars omitted]…
te_result=None
            )
            self._task_registry[server_task_id] = weakref.ref(task_obj)
            return task_obj
        else:
            # Graceful degradation - server returned GetPromptResult
            synthetic_task_id = task_id or str(uuid.uuid4())
            return PromptTask(
                self, synthetic_task_id, prompt_name=name, immediate_result=raw_result
            )

tools/call hi SERVER {'mcp.method.name': 'tools/call', 'fastmcp.server.name': 'remote', 'mcp.session.id': '8e8646c7-28bb-418f-97b4-bec9deda7339', 'gen_ai.tool.name': 'hi', 'fastmcp.component.key': 'tool:hi@', 'fastmcp.component.type': 'tool', 'fastmcp.provider.type': 'LocalProvider'}
tools/call hi CLIENT {'mcp.method.name': 'tools/call', 'fastmcp.component.key': 'hi', 'gen_ai.tool.name': 'hi'}
tools/call hi SERVER {'mcp.method.name': 'tools/call', 'fastmcp.server.name': 'FastMCPProxy-73d4', 'mcp.session.id': '80a95f2c-5a81-4998-95ac-d841b55f8659', 'gen_ai.tool.name': 'hi', 'fastmcp.component.key': 'tool:hi@', 'fastmcp.component.type': 'tool', 'fastmcp.provider.type': 'ProxyProvider', 'fastmcp.proxy.backend_name': None}
tools/call hi CLIENT {'mcp.method.name': 'tools/call', 'fastmcp.component.key': 'hi', 'gen_ai.tool.name': 'hi'}
client operation spans: 2

Note: MCP protocol errors are returned as successful responses with error content,
    so client spans may not have ERROR status even when the operation fails. This is
    different from server-side where exceptions happen inside the span.

    The server-side span WILL have ERROR status because the exception occurs within
    the server's span context. The client span represents the successful MCP protocol
    round-trip, while application-level errors are communicated via the response.
    """

    async def test_call_tool_error_creates_spans(
        self, trace_exporter: InMemorySpanExporter
    ):

        """Both client and server spans should be created when tool fails."""
        server = FastMCP("test-server")

        @server.tool()
        def failing_tool() -> str:
            raise ValueError("Something went wrong")

        client = Client(server)
        async with c
…[8629 chars omitted]…
f result.nextCursor in seen_cursors:
                logger.warning(
                    f"[{self.name}] Server returned duplicate pagination cursor"
                    f" {result.nextCursor!r} for list_tools; stopping pagination"
                )
                break
            seen_cursors.add(result.nextCursor)
            cursor = result.nextCursor
        else:
            raise RuntimeError(

if task:
            return await self._call_tool_as_task(
                name, arguments, task_id, ttl, meta=request_meta or None
            )

        result = await self.call_tool_mcp(
            name=name,
            arguments=arguments or {},
            timeout=timeout,
            progress_handler=progress_handler,
            meta=request_meta or None,
        )

        return await self._parse_call_tool_result(
            name, result, raise_on_error=raise_on_error
        )

    async def _call_tool_as_task(
        self: Client,
        name: str,
        arguments: dict[str, Any] | None = None,
        task_id: str | None = None,
        ttl: int = 60000,
        meta: dict[str, Any] | None = None,
    ) -> ToolTask:
        """Call a tool for background execution (SEP-1686).

        Returns a ToolTask object that handles both background and immediate executi
…[8629 chars omitted]…
            synthetic_task_id = task_id or str(uuid.uuid4())
                return ResourceTask(
                    self,
                    synthetic_task_id,
                    uri=str(uri),
                    immediate_result=raw_result.contents,
                )
*** Error compiling 'src/fastmcp/client/mixins/resources.py'...
Sorry: IndentationError: unexpected indent (resources.py, line 329)

result = await self.call_tool_mcp(
            name=name,
            arguments=arguments or {},
            timeout=timeout,
            progress_handler=progress_handler,
            meta=request_meta or None,
        )
        return await self._parse_call_tool_result(
            name, result, raise_on_error=raise_on_error
        )

    async def _call_tool_as_task(

        self: Client,
        name: str,
        arguments: dict[str, Any] | None = None,
        task_id: str | None = None,
        ttl: int = 60000,
        meta: dict[str, Any] | None = None,
    ) -> ToolTask:
        """Call a tool for background execution (SEP-1686).

        Returns a ToolTask object that handles both background and immediate execution.
        If the server accepts background execution, ToolTask will poll for results.
        If the server declines (graceful degradation), ToolTask wra
…[8628 chars omitted]…
ult
                synthetic_task_id = task_id or str(uuid.uuid4())
                return ResourceTask(
                    self,
                    synthetic_task_id,
                    uri=str(uri),
                    immediate_result=raw_result.contents,
                )
*** Error compiling 'src/fastmcp/client/mixins/tools.py'...
Sorry: IndentationError: unexpected indent (tools.py, line 356)

src/fastmcp/client/mixins/resources.py |   2 +-
 src/fastmcp/client/mixins/tools.py     |  14 ++-
 src/fastmcp/client/telemetry.py        |  16 +--
 src/fastmcp/server/providers/proxy.py  | 183 +++++++++++++++------------------
 src/fastmcp/server/server.py           |   5 +-
 src/fastmcp/server/telemetry.py        |  18 ++--
 src/fastmcp/telemetry.py               |  11 +-
 7 files changed, 124 insertions(+), 125 deletions(-)
diff --git a/src/fastmcp/server/providers/proxy.py b/src/fastmcp/server/providers/proxy.py
index b59024c..4664dad 100644
--- a/src/fastmcp/server/providers/proxy.py
+++ b/src/fastmcp/server/providers/proxy.py

@@ -32,7 +32,6 @@ from fastmcp.client.client import Client, FastMCP1Server
 from fastmcp.client.elicitation import ElicitResult
 from fastmcp.client.logging import LogMessage
 from fastmcp.client.roots import RootsList
-from fastmcp.client.telemetry import
…[8629 chars omitted]…
    # (not the static prompt meta which includes fastmcp tags)
+        messages = [Message(content=m.content, role=m.role) for m in result.messages]
+        return PromptResult(
+            messages=messages,
+            description=result.description,
+            meta=result.meta,
+        )
 
     def get_span_attributes(self) -> dict[str, Any]:
         return super().get_span_attributes() | {

await self._client.cancel_task(self._task_id)
        # Invalidate cache to force fresh status fetch
        self._status_cache = None

    def __await__(self):
        """Allow 'await task' to get result."""
        return self.result().__await__()


class ToolTask(Task["CallToolResult"]):
    """
    Represents a tool call that may execute in background or immediately.

    Provides a uniform API whether the server accepts background execution
    or executes synchronously (graceful degradation per SEP-1686).

    Usage:
        task = await client.call_tool_as_task("analyze", args)

        # Check status
        status = await task.status()

        # Wait for completion
        await task.wait()

        # Get result (waits if needed)
        result = await task.result()  # Returns CallToolResult

        # Or just await the task directly
        result = await task
    "
…[8629 chars omitted]…
t | PromptTask: The complete response object if task=False,
                or a PromptTask object if task=True.

        Raises:
            RuntimeError: If called while the client is not connected.
            McpError: If the request results in a TimeoutError | JSONRPCError
        """
        # Merge version into request-level meta (not arguments)
        request_meta = dict(meta) if meta else {}

arguments=arguments or {},
            timeout=timeout,
            progress_handler=progress_handler,
            meta=request_meta or None,
        )
        return await self._parse_call_tool_result(
            name, result, raise_on_error=raise_on_error
        )

    async def _call_tool_as_task(
        self: Client,
        name: str,

        arguments: dict[str, Any] | None = None,
        task_id: str | None = None,
        ttl: int = 60000,
        meta: dict[str, Any] | None = None,
    ) -> ToolTask:
        """Call a tool for background execution (SEP-1686).

        Returns a ToolTask object that handles both background and immediate execution.
        If the server accepts background execution, ToolTask will poll for results.
        If the server declines (graceful degradation), ToolTask wraps the immediate result.

        Args:
            name: Tool nam
…[6867 chars omitted]…
y[server_task_id] = weakref.ref(task_obj)
            return task_obj
        else:
            # Graceful degradation - server returned ReadResourceResult
            synthetic_task_id = task_id or str(uuid.uuid4())
            return ResourceTask(
                self,
                synthetic_task_id,
                uri=str(uri),
                immediate_result=raw_result.contents,
            )

async def _call_tool_as_task(
        self: Client,
        name: str,
        arguments: dict[str, Any] | None = None,
        task_id: str | None = None,
        ttl: int = 60000,
        meta: dict[str, Any] | None = None,
    ) -> ToolTask:
        """Call a tool for background execution (SEP-1686).

        Returns a ToolTask object that handles both background and immediate execution.
        If the server accepts background execution, ToolTask will poll for results.

        If the server declines (graceful degradation), ToolTask wraps the immediate result.

        Args:
            name: Tool name to call
            arguments: Tool arguments
            task_id: Optional client-provided task ID (ignored, for backward compatibility)
            ttl: Time to keep results available in milliseconds (default 60s)
            meta: Optional request metadata (e.g., version info
…[8628 chars omitted]…
)
                return task_obj
            else:
                # Graceful degradation - server returned ReadResourceResult
                synthetic_task_id = task_id or str(uuid.uuid4())
                return ResourceTask(
                    self,
                    synthetic_task_id,
                    uri=str(uri),
                    immediate_result=raw_result.contents,
                )

request_meta = dict(meta) if meta else {}
        if version is not None:
            request_meta["fastmcp"] = {
                **request_meta.get("fastmcp", {}),
                "version": version,
            }

        if task:
            return await self._get_prompt_as_task(
                name, arguments, task_id, ttl, meta=request_meta or None
            )

        result = await self.get_prompt_mcp(
            name=name, arguments=arguments, meta=request_meta or None
        )
        return result

    async def _get_prompt_as_task(
        self: Client,
        name: str,
        arguments: dict[str, Any] | None = None,
        task_id: str | None = None,
        ttl: int = 60000,
        meta: dict[str, Any] | None = None,
    ) -> PromptTask:
        """Get a prompt for background execution (SEP-1686).

        Returns a PromptTask object that handles both ba
…[4023 chars omitted]…
----
 src/fastmcp/client/mixins/tools.py     | 109 ++++++++++++--------
 src/fastmcp/client/telemetry.py        |  16 +--
 src/fastmcp/server/providers/proxy.py  | 183 +++++++++++++++------------------
 src/fastmcp/server/server.py           |   5 +-
 src/fastmcp/server/telemetry.py        |  18 ++--
 src/fastmcp/telemetry.py               |  11 +-
 8 files changed, 274 insertions(+), 244 deletions(-)

diff --git a/src/fastmcp/client/mixins/tools.py b/src/fastmcp/client/mixins/tools.py
index aec5950..577e7c8 100644
--- a/src/fastmcp/client/mixins/tools.py
+++ b/src/fastmcp/client/mixins/tools.py
@@ -17,7 +17,7 @@ from fastmcp.client.progress import ProgressHandler
 from fastmcp.client.tasks import ToolTask
 from fastmcp.client.telemetry import client_span
 from fastmcp.exceptions import ToolError
-from fastmcp.telemetry import inject_trace_context
+from fastmcp.telemetry import inject_trace_context, record_span_error
 from fastmcp.utilities.json_schema_type import json_schema_to_type
 from fastmcp.utilities.logging import get_logger

 from fastmcp.utilities.timeout import normalize_timeout_to_timedelta
@@ -144,7 +144,7 @@ class ClientToolsMixin:
             "tools/call",
             name,
             session_id=self.transport.get_session_id(),
-        ):
+        ) as span:
     
…[8629 chars omitted]…
         return task_obj
+            else:
+                # Graceful degradation - server returned ReadResourceResult
+                synthetic_task_id = task_id or str(uuid.uuid4())
+                return ResourceTask(
+                    self,
+                    synthetic_task_id,
+                    uri=str(uri),
+                    immediate_result=raw_result.contents,
+                )

........................................................................ [ 62%]
...........................................                              [100%]
115 passed, 17 warnings in 3.16s

Traceback (most recent call last):
  File "<stdin>", line 2, in <module>
ImportError: cannot import name '_Span' from 'opentelemetry.trace' (/usr/local/lib/python3.12/site-packages/opentelemetry/trace/__init__.py). Did you mean: 'Span'?

@_agnosticcontextmanager
def use_span(
    span: Span,
    end_on_exit: bool = False,
    record_exception: bool = True,
    set_status_on_exception: bool = True,
) -> Iterator[Span]:
    """Takes a non-active span and activates it in the current context.

    Args:
        span: The span that should be activated in the current context.
        end_on_exit: Whether to end the span automatically when leaving the

            context manager scope.
        record_exception: Whether to record any exceptions raised within the
            context as error event on the span.
        set_status_on_exception: Only relevant if the returned span is used
            in a with/context manager. Defines whether the span status will
            be automatically set to ERROR when an uncaught exception is
            raised in the span with block. The span status won't be set by
            this mechan
…[1015 chars omitted]…
",
                    )
                )

        # This causes parent spans to set their status to ERROR and to record
        # an exception as an event if a child span raises an exception even if
        # such child span was started with both record_exception and
        # set_status_on_exception attributes set to False.
        raise

    finally:
        if end_on_exit:
            span.end()

diff --git a/src/fastmcp/client/mixins/prompts.py b/src/fastmcp/client/mixins/prompts.py
index 4b87bf2..fc4255f 100644
--- a/src/fastmcp/client/mixins/prompts.py
+++ b/src/fastmcp/client/mixins/prompts.py
@@ -266,53 +266,59 @@ class ClientPromptsMixin:
         Returns:
             PromptTask: Future-like object for accessing task status and results
         """
-        # Per SEP-1686 final spec: client sends only ttl, server generates taskId
-        # Inject trace context into meta for propagation to server
-        propagated_meta = inject_trace_context(meta)
-

-        # Serialize arguments for MCP protocol
-        serialized_arguments: dict[str, str] | None = None
-        if arguments:
-            serialized_arguments = {}
-            for key, value in arguments.items():
-                if isinstance(value, str):
-                    serialized_arguments[key] = value
-    
…[8630 chars omitted]…
    span.set_status(Status(StatusCode.ERROR))
+    error_type = (
+        "tool_error" if isinstance(exception, ToolError) else type(exception).__name__
+    )
+    span.set_attribute("error.type", error_type)
+    description = str(exception) or type(exception).__name__
+    span.set_status(Status(StatusCode.ERROR, description))
 
 
 def extract_trace_context(meta: dict[str, Any] | None) -> Context:

) -> Generator[Span, None, None]:
    """Create a CLIENT span with standard MCP attributes.

    Automatically records any exception on the span and sets error status.
    """
    tracer = get_tracer()
    with tracer.start_as_current_span(
        name,
        kind=SpanKind.CLIENT,
        record_exception=False,
        set_status_on_exception=False,
    ) as span:

        attrs: dict[str, str] = {
            # MCP semantic conventions
            "mcp.method.name": method,
            # FastMCP-specific attributes
            "fastmcp.component.key": component_key,
        }
        if method == "tools/call":
            attrs["gen_ai.tool.name"] = component_key
        elif method == "prompts/get":
            attrs["gen_ai.prompt.name"] = component_key
        if session_id:
            attrs["mcp.session.id"] = session_id
        if resource_uri is not None:
            attrs[
…[1996 chars omitted]…
ibutes(
            {
                "fastmcp.provider.type": provider_type,
                "fastmcp.component.key": component_key,
            }
        )
        try:
            yield span
        except Exception as e:
            record_span_error(span, e)
            raise


__all__ = [
    "delegate_span",
    "get_auth_span_attributes",
    "get_session_span_attributes",
    "server_span",
]

WARNING: Package(s) not found: ruff

.FFF.FF..F.....                                                          [100%]
=================================== FAILURES ===================================
_____________ TestClientToolTracing.test_call_tool_span_attributes _____________

self = <tests.client.telemetry.test_client_tracing.TestClientToolTracing object at 0x75f8612a0e60>
trace_exporter = <opentelemetry.sdk.trace.export.in_memory_span_exporter.InMemorySpanExporter object at 0x75f8612a1940>

    async def test_call_tool_span_attributes(
        self, trace_exporter: InMemorySpanExporter
    ):
        server = FastMCP("test-server")
    

        @server.tool()
        def add(a: int, b: int) -> int:
            return a + b
    
        client = Client(server)
        async with client:
            await client.call_tool("add", {"a": 1, "b": 2})
    
        spans = trace_exporter.get_finished_spans()
    
        # F
…[8630 chars omitted]…
d_resource_span_attributes
FAILED tests/client/telemetry/test_client_tracing.py::TestClientPromptTracing::test_get_prompt_span_attributes
FAILED tests/client/telemetry/test_client_tracing.py::TestClientServerSpanHierarchy::test_client_and_server_spans_created
FAILED tests/client/telemetry/test_client_tracing.py::TestClientErrorTracing::test_read_resource_error_creates_spans
6 failed, 9 passed in 2.52s

M src/fastmcp/client/mixins/prompts.py
 M src/fastmcp/client/mixins/resources.py
 M src/fastmcp/client/mixins/tools.py
 M src/fastmcp/client/telemetry.py
 M src/fastmcp/server/providers/proxy.py
 M src/fastmcp/server/server.py
 M src/fastmcp/server/telemetry.py
 M src/fastmcp/telemetry.py

src/fastmcp/server/providers/proxy.py:152:            result = await client.call_tool_mcp(
src/fastmcp/server/providers/proxy.py:1000:class StatefulProxyClient(ProxyClient[ClientTransportT]):
src/fastmcp/client/mixins/tools.py:111:    async def call_tool_mcp(
src/fastmcp/client/mixins/tools.py:246:        Unlike call_tool_mcp, this method raises a ToolError if the tool call results in an error.
src/fastmcp/client/mixins/tools.py:269:                unstructured outputs, use call_tool_mcp instead and access the
src/fastmcp/client/mixins/tools.py:290:        result = await self.call_tool_mcp(

src/fastmcp/server/providers/proxy.py:155:        if result.isError:
src/fastmcp/server/sampling/run.py:295:                isError=True,
src/fastmcp/server/sampling/run.py:312:                isError=True,
src/fastmcp/server/sampling/run.py:325:                isError=True,
src/fastmcp/server/sampling/run.py:694:                                        isError=True,
src/fastmcp/server/tasks/requests.py:299:                isError=True,
src/fastmcp/client/mixins/tools.py:171:                record_span_error(span, ToolError(message))
src/fastmcp/client/mixins/tools.py:185:            raise_on_error: Whether to raise ToolError on errors
src/fastmcp/client/mixins/tools.py:364:                record_span_error(span, ToolError(message))
src/fastmcp/client/mixins/tools.py:404:        raise_on_error: Whether to raise ToolError on errors
src/fastmcp/client/mixins/tools.py:420:        raise To
…[2768 chars omitted]…

sMiddleware,
            )

            self.middleware.append(DereferenceRefsMiddleware())

        # Set up MCP protocol handlers
        self._setup_handlers()

        self.sampling_handler: SamplingHandler | None = sampling_handler
        self.sampling_handler_behavior: Literal["always", "fallback"] = (
            sampling_handler_behavior or "fallback"
        )

    def __repr__(self) -> str:

179:[tool.ruff.lint]
210:[tool.ruff.lint.isort]
213:[tool.ruff.lint.per-file-ignores]

......                                                                   [100%]
6 passed, 9 deselected in 0.77s

_backend_uri_template: str | None = None

    def __init__(self, client_factory: ClientFactoryT, **kwargs: Any):
        super().__init__(**kwargs)
        self._client_factory = client_factory

    async def _get_client(self) -> Client:
        """Gets a client instance by calling the sync or async factory."""
        client = self._client_factory()
        if inspect.isawaitable(client):
            client = cast(Client, await client)
        return client

    def model_copy(self, **kwargs: Any) -> ProxyTemplate:
        """Override to preserve _backend_uri_template when uri_template changes."""
        update = kwargs.get("update", {})
        if "uri_template" in update and self._backend_uri_template is None:
            # First time uri_template is being changed, preserve original for backend
            update = {**update, "_backend_uri_template": self.uri_template}
       
…[7317 chars omitted]…
ate.original_uri_template": self._original_uri_template,
        }


# -----------------------------------------------------------------------------
# FastMCPProvider
# -----------------------------------------------------------------------------


class FastMCPProvider(Provider):
    """Provider that wraps a FastMCP server.

    This provider enables mounting one FastMCP server onto another, exposing

# Factory Functions
# -----------------------------------------------------------------------------


def _create_client_factory(
    target: (
        Client[ClientTransportT]
        | ClientTransport
        | FastMCP[Any]
        | FastMCP1Server
        | AnyUrl
        | Path

        | MCPConfig
        | dict[str, Any]
        | str
    ),
) -> ClientFactoryT:
    """Create a client factory from the given target.

    Internal helper that handles the session strategy based on the target type:
    - Connected Client: reuses existing session (with warning about context mixing)
    - Disconnected Client: creates fresh sessions per request
    - Other targets: creates ProxyClient and fresh sessions per request
    """
    if isinstance(target, Client):
        client = target

        # Plain Clients used as proxy backends also need header forwarding,
        # same as ProxyClient 
…[5582 chars omitted]…
vider
480:class ProxyProvider(Provider):
502:        from fastmcp.server.providers.proxy import ProxyProvider, ProxyClient
505:        proxy = ProxyProvider(lambda: ProxyClient("http://localhost:8000/mcp"))
520:        """Initialize a ProxyProvider.
790:    ProxyProvider. For more control, use FastMCP with add_provider(ProxyProvider(...)).
824:        provider: Provider = ProxyProvider(client_factory)

src/fastmcp/client/mixins/prompts.py:67:91:        large result sets incrementally), use list_prompts_mcp() with the cursor parameter.
src/fastmcp/client/mixins/prompts.py:117:107:            arguments (dict[str, Any] | None, optional): Arguments to pass to the prompt. Defaults to None.
src/fastmcp/client/mixins/prompts.py:118:114:            meta (dict[str, Any] | None, optional): Request metadata (e.g., for SEP-1686 tasks). Defaults to None.
src/fastmcp/client/mixins/prompts.py:160:129:                        _meta=propagated_meta,  # type: ignore[unknown-argument]  # pydantic alias  # ty:ignore[unknown-argument]
src/fastmcp/client/mixins/prompts.py:165:102:                        request=request,  # type: ignore[arg-type]  # ty:ignore[invalid-argument-type]
src/fastmcp/client/mixins/prompts.py:214:107:            arguments (dict[str, Any] | None, optional): Arguments to pass to the
…[8629 chars omitted]…
er/server.py:2133:89:          Example: If server has a prompt named "weather_prompt", it will be available as
src/fastmcp/server/server.py:2191:128:                message="When importing from a server with a lifespan, the lifespan from the imported server will not be used.",
src/fastmcp/server/server.py:2378:89:    use `FastMCPProxy` or `ProxyProvider` directly from `fastmcp.server.providers.proxy`.

125                     _meta=propagated_meta,  # type: ignore[unknown-argument]  # pydantic alias  # ty:ignore[unknown-argument]
103             # Server returns CreateTaskResult (task accepted) or GetPromptResult (graceful degradation)
98                     request=request,  # type: ignore[arg-type]  # ty:ignore[invalid-argument-type]
90                     self, synthetic_task_id, prompt_name=name, immediate_result=raw_result
125                     _meta=propagated_meta,  # type: ignore[unknown-argument]  # pydantic alias  # ty:ignore[unknown-argument]
106             # Server returns CreateTaskResult (task accepted) or ReadResourceResult (graceful degradation)
98                     request=request,  # type: ignore[arg-type]  # ty:ignore[invalid-argument-type]
125                     _meta=propagated_meta,  # type: ignore[unknown-argument]  # pydantic alias  # ty:ignore[unknown-
…[1298 chars omitted]…
resource'
E         
E         - resources/read nonexistent://resource

E         + resources/read

tests/server/telemetry/test_server_tracing.py:156: AssertionError
=========================== short test summary info ============================
FAILED tests/server/telemetry/test_server_tracing.py::TestResourceTracing::test_read_nonexistent_resource_sets_error
1 failed, 3 passed, 9 deselected in 1.08s

[11/03/26 09:19:15] Error calling tool 'failing_tool'                           
                    ╭─────────── Traceback (most recent call last) ────────────╮
                    │ /repo/src/fastmcp/server/server.py:1240 in call_tool     │
                    │                                                          │
                    │ /repo/src/fastmcp/tools/base.py:377 in _run              │
                    │                                                          │
                    │                 ... 5 frames hidden ...                  │
                    │                                                          │
                    │ /usr/local/lib/python3.12/site-packages/pydantic/type_ad │
                    │ apter.py:410 in validate_python                          │
                    │ in failing_tool:15                                       │
                    ╰──────────────────────────────────────────────────────────╯

                    ValueError: Something went wrong                            
reproducer assertions passed

diff --git a/src/fastmcp/server/providers/proxy.py b/src/fastmcp/server/providers/proxy.py
index b59024c..4664dad 100644
--- a/src/fastmcp/server/providers/proxy.py
+++ b/src/fastmcp/server/providers/proxy.py
@@ -32,7 +32,6 @@ from fastmcp.client.client import Client, FastMCP1Server
 from fastmcp.client.elicitation import ElicitResult
 from fastmcp.client.logging import LogMessage
 from fastmcp.client.roots import RootsList
-from fastmcp.client.telemetry import client_span
 from fastmcp.client.transports import ClientTransportT
 from fastmcp.exceptions import ResourceError, ToolError
 from fastmcp.mcp_config import MCPConfig

@@ -116,55 +115,51 @@ class ProxyTool(Tool):
         arguments: dict[str, Any],
         context: Context | None = None,
     ) -> ToolResult:
-        """Executes the tool by making a call through the client."""
+        """Execute the tool through the proxied M
…[8629 chars omitted]…

 src/fastmcp/client/mixins/tools.py     | 109 ++++++++++++--------
 src/fastmcp/client/telemetry.py        |  25 +++--
 src/fastmcp/server/providers/proxy.py  | 183 +++++++++++++++------------------
 src/fastmcp/server/server.py           |   5 +-
 src/fastmcp/server/telemetry.py        |  30 +++---
 src/fastmcp/telemetry.py               |  11 +-
 8 files changed, 290 insertions(+), 249 deletions(-)

[11/03/26 09:21:28] Error calling tool 'failing_tool'                           
                    ╭─────────── Traceback (most recent call last) ────────────╮
                    │ /repo/src/fastmcp/server/server.py:1240 in call_tool     │
                    │                                                          │
                    │ /repo/src/fastmcp/tools/base.py:377 in _run              │
                    │                                                          │
                    │                 ... 5 frames hidden ...                  │
                    │                                                          │
                    │ /usr/local/lib/python3.12/site-packages/pydantic/type_ad │
                    │ apter.py:410 in validate_python                          │
                    │ in failing_tool:16                                       │
      

…[3481 chars omitted]…
      ^^^^^^^^^^^^^^^^
  File "/usr/local/lib/python3.12/asyncio/runners.py", line 118, in run
    return self._loop.run_until_complete(task)
           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  File "/usr/local/lib/python3.12/asyncio/base_events.py", line 691, in run_until_complete
    return future.result()
           ^^^^^^^^^^^^^^^
  File "<stdin>", line 27, in main
AssertionError: ('working_tool', 2)

........................................................................ [ 62%]
...........................................                              [100%]
115 passed, 17 warnings in 2.58s

src/fastmcp/client/mixins/prompts.py   |  64 ++++++------
 src/fastmcp/client/mixins/resources.py |  46 +++++----
 src/fastmcp/client/mixins/tools.py     |  70 +++++++++----
 src/fastmcp/client/telemetry.py        |  25 +++--
 src/fastmcp/server/providers/proxy.py  | 183 +++++++++++++++------------------
 src/fastmcp/server/server.py           |   5 +-
 src/fastmcp/server/telemetry.py        |  30 +++---
 src/fastmcp/telemetry.py               |  11 +-
 8 files changed, 237 insertions(+), 197 deletions(-)

[11/03/26 09:25:03] Error calling tool 'failing_tool'                           
                    ╭─────────── Traceback (most recent call last) ────────────╮
                    │ /repo/src/fastmcp/server/server.py:1240 in call_tool     │
                    │                                                          │
                    │ /repo/src/fastmcp/tools/base.py:377 in _run              │
                    │                                                          │
                    │                 ... 5 frames hidden ...                  │
                    │                                                          │
                    │ /usr/local/lib/python3.12/site-packages/pydantic/type_ad │
                    │ apter.py:410 in validate_python                          │
                    │ in failing_tool:15                                       │
      

…[3229 chars omitted]…
      ^^^^^^^^^^^^^^^^
  File "/usr/local/lib/python3.12/asyncio/runners.py", line 118, in run
    return self._loop.run_until_complete(task)
           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  File "/usr/local/lib/python3.12/asyncio/base_events.py", line 691, in run_until_complete
    return future.result()
           ^^^^^^^^^^^^^^^
  File "<stdin>", line 25, in main
AssertionError: ('working_tool', 2)

True False

1000:class StatefulProxyClient(ProxyClient[ClientTransportT]):
1001-    """A proxy client that provides a stateful client factory for the proxy server.
1002-
1003-    The stateful proxy client bound its copy to the server session.
1004-    And it will be disconnected when the session is exited.
1005-
1006-    This is useful to proxy a stateful mcp server such as the Playwright MCP server.
1007-    Note that it is essential to ensure that the proxy server itself is also stateful.
1008-
1009-    Because session reuse means the receive-loop task inherits a stale
1010-    ``request_ctx`` ContextVar snapshot, the default proxy handlers are
1011-    replaced with versions that restore the ContextVar before forwarding.

1012-    ``ProxyTool.run`` stashes the current ``RequestContext`` in
1013-    ``_proxy_rc_ref`` before each backend call, and the handlers consult
1014-    it to detect (and c
…[5778 chars omitted]…
factory()
        if inspect.isawaitable(client):
            client = cast(Client, await client)
        return client

    # -------------------------------------------------------------------------
    # Tool methods
    # -------------------------------------------------------------------------

    async def _list_tools(self) -> Sequence[Tool]:
        """List all tools from the remote server."""

........                                                                 [100%]
8 passed, 5 deselected in 0.45s

[11/03/26 09:27:03] Error calling tool 'fail'                                   
                    ╭─────────── Traceback (most recent call last) ────────────╮
                    │ /repo/src/fastmcp/server/server.py:1240 in call_tool     │
                    │                                                          │
                    │ /repo/src/fastmcp/tools/base.py:377 in _run              │
                    │                                                          │
                    │                 ... 5 frames hidden ...                  │
                    │                                                          │
                    │ /usr/local/lib/python3.12/site-packages/pydantic/type_ad │
                    │ apter.py:410 in validate_python                          │
                    │ in fail:14                                               │
                    ╰──────────────────────────────────────────────────────────╯

                    ValueError: Something went wrong                            
behavioral reproducer passed

"""Tests for the core telemetry module."""

from __future__ import annotations

from opentelemetry import trace
from opentelemetry.sdk.trace.export.in_memory_span_exporter import InMemorySpanExporter

from fastmcp.server.telemetry import get_auth_span_attributes
from fastmcp.telemetry import (
    INSTRUMENTATION_NAME,
    TRACE_PARENT_KEY,
    extract_trace_context,

    get_tracer,
    inject_trace_context,
)


class TestGetTracer:
    def test_tracer_uses_instrumentation_name(
        self, trace_exporter: InMemorySpanExporter
    ):
        tracer = get_tracer()
        with tracer.start_as_current_span("test-span"):
            pass

        spans = trace_exporter.get_finished_spans()
        assert len(spans) == 1
        scope = spans[0].instrumentation_scope
        assert scope is not None
        assert scope.name == INSTRUMENTATION_NAME


class TestGetAuthSpanAttributes:
   
…[3659 chars omitted]…
== "ToolError"
tests/server/middleware/test_error_handling.py:550:        assert captured_errors[1]["error_type"] == "ToolError"
tests/server/middleware/test_error_handling.py:564:                await client.call_tool("failing_operation", {"error_type": "value"})
tests/server/middleware/test_error_handling.py:652:                    await client.call_tool("failing_operation", {"error_type": "value"})

........................................................................ [ 94%]
....                                                                     [100%]
76 passed, 1 deselected, 18 warnings in 1.19s
.........                                                                [100%]
9 passed, 6 deselected in 1.00s
........                                                                 [100%]
8 passed, 5 deselected in 0.40s

35	29	src/fastmcp/client/mixins/prompts.py
27	19	src/fastmcp/client/mixins/resources.py
48	22	src/fastmcp/client/mixins/tools.py
15	10	src/fastmcp/client/telemetry.py
82	101	src/fastmcp/server/providers/proxy.py
4	1	src/fastmcp/server/server.py
17	13	src/fastmcp/server/telemetry.py
9	2	src/fastmcp/telemetry.py
diff --git a/src/fastmcp/client/mixins/tools.py b/src/fastmcp/client/mixins/tools.py
index aec5950..d93c08f 100644
--- a/src/fastmcp/client/mixins/tools.py
+++ b/src/fastmcp/client/mixins/tools.py

@@ -17,7 +17,7 @@ from fastmcp.client.progress import ProgressHandler
 from fastmcp.client.tasks import ToolTask
 from fastmcp.client.telemetry import client_span
 from fastmcp.exceptions import ToolError
-from fastmcp.telemetry import inject_trace_context
+from fastmcp.telemetry import inject_trace_context, record_span_error
 from fastmcp.utilities.json_schema_type import json_schema_
…[8629 chars omitted]…
request,  # type: ignore[arg-type]  # ty:ignore[invalid-argument-type]
+                    result_type=ResourceTaskResponseUnion,
+                )
             )
-        )
-        raw_result = wrapped_result.root
+            raw_result = wrapped_result.root
 
         if isinstance(raw_result, mcp.types.CreateTaskResult):
             # Task was accepted - extract task info from CreateTaskResult

task_id: str | None = None,
        ttl: int = 60000,
        meta: dict[str, Any] | None = None,
    ) -> ToolTask:
        """Call a tool for background execution (SEP-1686).

        Returns a ToolTask object that handles both background and immediate execution.
        If the server accepts background execution, ToolTask will poll for results.
        If the server declines (graceful degradation), ToolTask wraps the immediate result.

        Args:
            name: Tool name to call

            arguments: Tool arguments
            task_id: Optional client-provided task ID (ignored, for backward compatibility)
            ttl: Time to keep results available in milliseconds (default 60s)
            meta: Optional request metadata (e.g., version info)

        Returns:
            ToolTask: Future-like object for accessing task status and results
        """
        with c
…[7475 chars omitted]…
y[server_task_id] = weakref.ref(task_obj)
            return task_obj
        else:
            # Graceful degradation - server returned ReadResourceResult
            synthetic_task_id = task_id or str(uuid.uuid4())
            return ResourceTask(
                self,
                synthetic_task_id,
                uri=str(uri),
                immediate_result=raw_result.contents,
            )

[('tools/call tool', 'SERVER'), ('tools/call tool', 'CLIENT'), ('tools/call tool', 'SERVER')]
proxy-generated client spans are not duplicated

........................................................................ [ 67%]
..................................                                       [100%]
106 passed in 2.14s
.........                                                                [100%]
9 passed, 6 deselected in 0.97s
........................................................................ [ 51%]
.....................................................................    [100%]
141 passed, 1 deselected, 18 warnings in 2.83s
........                                                                 [100%]
8 passed, 5 deselected in 0.39s
.......                                                                  [100%]
7 passed in 0.17s

StatusCode.ERROR "Unknown resource: 'missing://x'" {'mcp.method.name': 'resources/read', 'fastmcp.server.name': 'err', 'fastmcp.component.type': 'resource', 'fastmcp.component.key': 'missing://x', 'mcp.resource.uri': 'missing://x', 'error.type': 'NotFoundError'}

possibly-missing-import = "warn"
possibly-unresolved-reference = "warn"
unsupported-dynamic-base = "warn"
unsupported-operator = "warn"
unused-ignore-comment = "warn"

[tool.ty.terminal]
error-on-warning = true

[tool.ruff.lint]
fixable = ["ALL"]
ignore = [

    "COM812",
    "PERF203", # try-except in loop — all existing hits are intentional (retry loops, error skipping)
    "PLR0913", # Too many arguments, MCP Servers have a lot of arguments, OKAY?!
    "SIM102",  # Dont require combining if statements
]
extend-select = [
    "B",    # flake8-bugbear: Catches actual bugs like mutable default arguments
    "C4",   # flake8-comprehensions: More efficient/readable comprehensions
    "DTZ",  # flake8-datetimez: Enforce timezone-aware datetime usage
    "ERA",  # eradicate: Detect commented-out code
    "FA",   # flake8-future-annotations: Enforce from __future__ import annotations
    "F
…[2330 chars omitted]…
pagated_meta,  # type: ignore[unknown-argument]  # pydantic alias  # ty:ignore[unknown-argument]
102             # Server returns CreateTaskResult (task accepted) or CallToolResult (graceful degradation)
95             # Use RootModel with Union to handle both response types (SDK calls model_validate)
98                     request=request,  # type: ignore[arg-type]  # ty:ignore[invalid-argument-type]

/usr/local/bin/pytest
 M src/fastmcp/client/mixins/prompts.py
 M src/fastmcp/client/mixins/resources.py
 M src/fastmcp/client/mixins/tools.py
 M src/fastmcp/client/telemetry.py
 M src/fastmcp/server/providers/proxy.py
 M src/fastmcp/server/server.py
 M src/fastmcp/server/telemetry.py
 M src/fastmcp/telemetry.py

257:    def get_span_attributes(self) -> dict[str, Any]:
        No-ops if task_config.mode is "forbidden". Subclasses override to
        register their callable (self.run, self.read, self.render, or self.fn).
        """
        # Base implementation: no-op (subclasses override)

    async def add_to_docket(
        self, docket: Docket, *args: Any, **kwargs: Any
    ) -> Execution:
        """Schedule this component for background execution via docket.

        Subclasses override this to handle their specific calling conventions:

        - Tool: add_to_docket(docket, arguments: dict, **kwargs)
        - Resource: add_to_docket(docket, **kwargs)
        - ResourceTemplate: add_to_docket(docket, params: dict, **kwargs)
        - Prompt: add_to_docket(docket, arguments: dict | None, **kwargs)

        The **kwargs are passed through to docket.add() (e.g., key=task_key).
        """
 
…[3821 chars omitted]…
arg-type]  # ty:ignore[invalid-argument-type]
270 101             uri (AnyUrl | str): The URI of the resource to read. Can be a string or an AnyUrl object.
347 125                     _meta=propagated_meta,  # type: ignore[unknown-argument]  # pydantic alias  # ty:ignore[unknown-argument]
351 106             # Server returns CreateTaskResult (task accepted) or ReadResourceResult (graceful degradation)

diff --git a/src/fastmcp/client/telemetry.py b/src/fastmcp/client/telemetry.py
index 10d6d82..7472b32 100644
--- a/src/fastmcp/client/telemetry.py
+++ b/src/fastmcp/client/telemetry.py
@@ -3,9 +3,9 @@
 from collections.abc import Generator
 from contextlib import contextmanager
 
-from opentelemetry.trace import Span, SpanKind, Status, StatusCode
+from opentelemetry.trace import Span, SpanKind
 
-from fastmcp.telemetry import get_tracer

+from fastmcp.telemetry import get_tracer, record_span_error
 
 
 @contextmanager
@@ -18,29 +18,34 @@ def client_span(
 ) -> Generator[Span, None, None]:
     """Create a CLIENT span with standard MCP attributes.
 
-    Automatically records any exception on the span and sets error status.
+    Records failures with an exception event, error type, and useful description.
     """
     tracer = get_tracer()
-    with tracer.start_as_current_span(name, k
…[8630 chars omitted]…
result.content
+                        if isinstance(content, mcp.types.TextContent) and content.text
+                    ),
+                    f"Tool '{name}' returned an error",
+                )
+                record_span_error(span, ToolError(message))
 
         if isinstance(raw_result, mcp.types.CreateTaskResult):
             # Task was accepted - extract task info from CreateTaskResult

session_id: str | None = None,
    resource_uri: str | None = None,
) -> Generator[Span, None, None]:
    """Create a CLIENT span with standard MCP attributes.

    Records failures with an exception event, error type, and useful description.
    """
    tracer = get_tracer()
    with tracer.start_as_current_span(
        name,
        kind=SpanKind.CLIENT,
        record_exception=False,

        set_status_on_exception=False,
    ) as span:
        try:
            attrs: dict[str, str] = {
                # MCP semantic conventions
                "mcp.method.name": method,
                # FastMCP-specific attributes
                "fastmcp.component.key": component_key,
            }
            if method == "tools/call":
                attrs["gen_ai.tool.name"] = component_key
            elif method == "prompts/get":
                attrs["gen_ai.prompt.name"] = component
…[2400 chars omitted]…

                {
                    "fastmcp.provider.type": provider_type,
                    "fastmcp.component.key": component_key,
                }
            )
            yield span
        except Exception as e:
            record_span_error(span, e)
            raise


__all__ = [
    "delegate_span",
    "get_auth_span_attributes",
    "get_session_span_attributes",
    "server_span",
]

[11/03/26 09:39:02] Error calling tool 'tool'                                   
                    ╭─────────── Traceback (most recent call last) ────────────╮
                    │ /repo/src/fastmcp/server/server.py:1240 in call_tool     │
                    │                                                          │
                    │ /repo/src/fastmcp/tools/base.py:368 in _run              │
                    │                                                          │
                    │ /repo/src/fastmcp/server/tasks/routing.py:63 in          │
                    │ check_background_task                                    │
                    ╰──────────────────────────────────────────────────────────╯
                    McpError: FunctionTool 'tool:tool@' does not support        
                    task-augmented execution                                    
      

…[1802 chars omitted]…
^^^^^^^
  File "/repo/src/fastmcp/client/client.py", line 757, in _await_with_session_monitoring
    return call_task.result()
           ^^^^^^^^^^^^^^^^^^
  File "/usr/local/lib/python3.12/site-packages/mcp/shared/session.py", line 306, in send_request
    raise McpError(response_or_error.error)
mcp.shared.exceptions.McpError: FunctionPrompt 'prompt:prompt@' does not support task-augmented execution

diff --git a/src/fastmcp/client/mixins/prompts.py b/src/fastmcp/client/mixins/prompts.py
index 4b87bf2..4604e90 100644
--- a/src/fastmcp/client/mixins/prompts.py
+++ b/src/fastmcp/client/mixins/prompts.py
@@ -266,39 +266,45 @@ class ClientPromptsMixin:
         Returns:
             PromptTask: Future-like object for accessing task status and results
         """
-        # Per SEP-1686 final spec: client sends only ttl, server generates taskId
-        # Inject trace context into meta for propagation to server
-        propagated_meta = inject_trace_context(meta)
-

-        # Serialize arguments for MCP protocol
-        serialized_arguments: dict[str, str] | None = None
-        if arguments:
-            serialized_arguments = {}
-            for key, value in arguments.items():
-                if isinstance(value, str):
-                    serialized_arguments[key] = value
-    
…[8629 chars omitted]…
result.content
+                        if isinstance(content, mcp.types.TextContent) and content.text
+                    ),
+                    f"Tool '{name}' returned an error",
+                )
+                record_span_error(span, ToolError(message))
 
         if isinstance(raw_result, mcp.types.CreateTaskResult):
             # Task was accepted - extract task info from CreateTaskResult

120:        # The Client call creates the outbound CLIENT span for this request.
233:        # The Client call creates the outbound CLIENT span for this request.
442:        # The Client call creates the outbound CLIENT span for this request.

...............                                                          [100%]
15 passed, 5 deselected in 0.43s

# Add task metadata if this is a task request
                if (
                    hasattr(req_ctx, "experimental")
                    and hasattr(req_ctx.experimental, "is_task")
                    and req_ctx.experimental.is_task
                ):
                    task_metadata = req_ctx.experimental.task_metadata
                    if task_metadata:
                        meta = meta or {}
                        meta["modelcontextprotocol.io/task"] = (
                            task_metadata.model_dump(exclude_none=True)
                        )

            result = await client.call_tool_mcp(
                name=backend_name, arguments=arguments, meta=meta
            )
        if result.isError:
            raise ToolError(cast(mcp.types.TextContent, result.content[0]).text)
        # Preserve backend's meta (includes task metadata for background
…[251 chars omitted]…
an_attributes() | {
            "fastmcp.provider.type": "ProxyProvider",
            "fastmcp.proxy.backend_name": self._backend_name,
        }


class ProxyResource(Resource):
    """A Resource that represents and reads a resource from a remote server."""

    task_config: TaskConfig = TaskConfig(mode="forbidden")
    _cached_content: ResourceResult | None = None
    _backend_uri: str | None = None

…[21 chars omitted]…
, plus telemetry subsets). Legacy telemetry assertions still expect rpc.* attributes and URI-bearing resource span names, which conflict with the requested contract."}
submitted.