prefecthq-fastmcp-3899-3889

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

lrwxrwxrwx 1 root root      9 Nov  5 11:28 AGENTS.md -> CLAUDE.md
-rw-r--r-- 1 root root  12079 Nov  5 11:28 CLAUDE.md
-rw-r--r-- 1 root root   5218 Nov  5 11:28 CODE_OF_CONDUCT.md
-rw-r--r-- 1 root root   5633 Nov  5 11:28 CONTRIBUTING.md
-rw-r--r-- 1 root root  11356 Nov  5 11:28 LICENSE
-rw-r--r-- 
…[1072 chars omitted]…

./examples/tags_example.py
./examples/task_elicitation.py
./examples/text_me.py
./examples/tool_result_echo.py
./logo.py
./scripts/auto_close_duplicates.py
./scripts/auto_close_needs_mre.py
./scripts/benchmark_imports.py
./tests/conftest.py
./tests/test_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

tests/cli/test_client_commands.py
tests/cli/test_mcp_server_config_integration.py
tests/cli/test_mcp_server_config_schema.py
tests/cli/test_server_args.py
tests/client/__init__.py
tests/client/auth/__init__.py
tests/client/auth/test_oauth_cimd.py
tests/client/auth/test_oauth_client.py
tests/client/auth/test_oauth_static_client.py
tests/client/client/__init__.py
tests/client/client/test_auth.py
tests/client/client/test_client.py

tests/client/client/test_error_handling.py
tests/client/client/test_initialize.py
tests/client/client/test_session.py
tests/client/client/test_timeout.py
tests/client/client/test_transport.py
tests/client/sampling/__init__.py
tests/client/sampling/handlers/__init__.py
tests/client/sampling/handlers/test_anthropic_handler.py
tests/client/sampling/handlers/test_google_genai_handler.py
tests/client/sampling/handlers/test_openai_handler.py
tests/client/tasks/confte
…[2776 chars omitted]…
/server/auth/providers/test_workos.py
tests/server/auth/test_auth_provider.py
tests/server/auth/test_authorization.py
tests/server/auth/test_cimd.py
tests/server/auth/test_cimd_validators.py
tests/server/auth/test_debug_verifier.py
tests/server/auth/test_enhanced_error_responses.py
tests/server/auth/test_jwt_issuer.py
tests/server/auth/test_jwt_provider.py
tests/server/auth/test_jwt_provider_bearer.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
…[4022 chars omitted]…
der.type": provider_type,
                "fastmcp.component.key": component_key,
            }
        )
        try:
            yield span
        except Exception as e:
            span.record_exception(e)
            span.set_status(Status(StatusCode.ERROR))
            raise


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

"""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:
            return f"Hello, {name}!"

        client = Client(server)
        async with client:
            result = await client.call_tool("greet", {"name": "World"})
            assert "Hello, World!" in str(result)

        spans = trace_exporter.get_finished_spans()
…[8628 chars omitted]…
id == client_span.context.trace_id, (
            "Server and client spans should share the same trace_id"
        )

        # Server span's parent should be the client span
        assert server_span.parent is not None, "Server span should have a parent"
        assert server_span.parent.span_id == client_span.context.span_id, (
            "Server span's parent should be the client span"
        )

" 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
…[8628 chars omitted]…
   Returns:
            CallToolResult: Parsed result with structured data
        """

        return await _parse_call_tool_result(
            name=name,
            result=result,
            tool_output_schemas=self.session._tool_output_schemas,
            list_tools_fn=self.session.list_tools,
            client_name=self.name,
            raise_on_error=raise_on_error,
        )

    @overload

1194-                return await self._run_middleware(
1195-                    context=mw_context,
1196-                    call_next=lambda context: self.call_tool(
1197-                        context.message.name,
1198-                        context.message.arguments or {},
1199-                        version=version,
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 dispat
…[4944 chars omitted]…
rom e
1526-                    raise PromptError(f"Error rendering prompt {name!r}: {e}") from e
1527-
1528-    def add_tool(self, tool: Tool | Callable[..., Any]) -> Tool:
1529-        """Add a tool to the server.
1530-
1531-        The tool function can optionally request a Context object by adding a parameter
1532-        with the Context type annotation. See the @tool decorator for examples.
1533-

"""FastMCPProvider for wrapping FastMCP servers as providers.

This module provides the `FastMCPProvider` class that wraps a FastMCP server
and exposes its components through the Provider interface.

It also provides FastMCPProvider* component classes that delegate execution to
the wrapped server's middleware, ensuring middleware runs when components are
executed.
"""

from __future__ import annotations

import re
from collections.abc import AsyncIterator, Sequence
from contextlib import asynccontextmanager
from typing import TYPE_CHECKING, Any, overload
from urllib.parse import quote

import mcp.types
from mcp.types import AnyUrl

from fastmcp.prompts.base import Prompt, PromptResult
from fastmcp.resources.base import Resource, ResourceResult
from fastmcp.resources.template import ResourceTemplate
from fastmcp.server.providers.base import Provider
from fastmcp.server.tasks.config imp
…[8629 chars omitted]…
    ```python
        from fastmcp import FastMCP
        from fastmcp.server.providers import FastMCPProvider

        main = FastMCP("Main")
        sub = FastMCP("Sub")

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

        # Mount directly - tools accessible by original names
        main.add_provider(FastMCPProvider(sub))

        # Or with namespace

"""Namespace transform for prefixing component names."""

from __future__ import annotations

import re
from collections.abc import Sequence
from typing import TYPE_CHECKING

from fastmcp.server.transforms import (
    GetPromptNext,
    GetResourceNext,
    GetResourceTemplateNext,

    GetToolNext,
    Transform,
)
from fastmcp.utilities.versions import VersionSpec

if TYPE_CHECKING:
    from fastmcp.prompts.base import Prompt
    from fastmcp.resources.base import Resource
    from fastmcp.resources.template import ResourceTemplate
    from fastmcp.tools.base import Tool

# Pattern for matching URIs: protocol://path
_URI_PATTERN = re.compile(r"^([^:]+://)(.*?)$")


class Namespace(Transform):
    """Prefixes component names with a namespace.

    - Tools: name → namespace_name
    - Prompts: name → namespace_name
    - Resources: protocol://path → protocol://namespace/path
    - Res
…[5381 chars omitted]…
elf, name: str, call_next: GetPromptNext, *, version: VersionSpec | None = None
    ) -> Prompt | None:
        """Get prompt by namespaced name."""
        original = self._reverse_name(name)
        if original is None:
            return None
        prompt = await call_next(original, version=version)
        if prompt:
            return prompt.model_copy(update={"name": name})
        return None

import functools
from urllib.parse import quote

import pytest
from pydantic import BaseModel

from fastmcp import Context, FastMCP
from fastmcp.resources import ResourceTemplate
from fastmcp.resources.function_resource import FunctionResource
from fastmcp.resources.template import build_regex, match_uri_template

class TestResourceTemplate:
    """Test ResourceTemplate functionality."""

    def test_template_creation(self):
        """Test creating a template from a function."""

        def my_func(key: str, value: int) -> dict:
            return {"key": key, "value": value}

        template = ResourceTemplate.from_function(
            fn=my_func,
            uri_template="test://{key}/{value}",
            name="test",
        )
        assert template.uri_template == "test://{key}/{value}"
        assert template.name == "test"
        assert template.mime_type == "text/plain
…[7309 chars omitted]…
y, value=value)

        template = ResourceTemplate.from_function(
            fn=get_data,
            uri_template="test://{key}/{value}",
            name="test",
        )

        resource = await template.create_resource(
            "test://foo/123",
            {"key": "foo", "value": 123},
        )

        assert isinstance(resource, FunctionResource)
        # read() returns raw BaseModel

tests/resources/test_resource_template.py
tests/resources/test_resource_template_query_params.py
tests/server/auth/test_cimd.py
tests/server/auth/test_oauth_proxy_redirect_validation.py
tests/server/auth/test_redirect_validation.py
tests/server/middleware/test_caching.py
tests/server/middleware/test_middleware_nested.py
tests/server/mount/test_advanced.py
tests/server/mount/test_mount.py
tests/server/mount/test_resources.py
tests/server/providers/proxy/test_stateful_proxy_client.py
tests/server/providers/test_fastmcp_provider.py

tests/server/providers/test_local_provider_resources.py
tests/server/providers/test_prefab_roundtrip.py
tests/server/tasks/test_task_mount.py
tests/server/telemetry/test_provider_tracing.py

"""Tests for resource and template mounting."""

import json

from fastmcp import FastMCP


class TestResourcesAndTemplates:
    """Test mounting with resources and resource templates."""

    async def test_mount_with_resources(self):
        """Test mounting a server with resources."""

        main_app = FastMCP("MainApp")
        data_app = FastMCP("DataApp")

        @data_app.resource(uri="data://users")
        async def get_users() -> str:
            return "user1, user2"

        # Mount the data app
        main_app.mount(data_app, "data")

        # Resource should be accessible through main app
        resources = await main_app.list_resources()
        assert any(str(r.uri) == "data://data/users" for r in resources)

        # Check that resource can be accessed
        result = await main_app.read_resource("data://data/users")
        assert len(result.contents) == 1
   
…[6239 chars omitted]…
  @sub.resource("resource://data/{id}{?format,limit}")
        def get_data(id: str, format: str = "json", limit: int = 10) -> str:
            return f"id={id} format={format} limit={limit}"

        main = FastMCP("Main")
        main.mount(sub, "api")

        result = await main.read_resource("resource://api/data/42?limit=5")
        assert result.contents[0].content == "id=42 format=json limit=5"

resource://sub/multi/abc/def -> {extra*}
resource://sub/multi/abc -> {extra*}

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

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
…[246 chars omitted]…
Retry(total=0, 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 (from versions: none)
ERROR: No matching distribution found for fastmcp

tests/server/telemetry/test_provider_tracing.py
---
"""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
…[8629 chars omitted]…
  )

        with patch(
            "fastmcp.server.dependencies.get_access_token", return_value=test_token
        ):
            await mcp.read_resource("config://app")

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

        span = spans[0]
        assert span.attributes is not None
tests/server/telemetry/__init__.py
---
"""Tests for FastMCP server telemetry."""

total 20
drwxr-xr-x 1 root root  4096 Nov  5 11:28 .
drwxr-xr-x 1 root root  4096 Nov  5 11:28 ..
-rw-r--r-- 1 root root    42 Nov  5 11:28 __init__.py
-rw-r--r-- 1 root root  4957 Nov  5 11:28 test_provider_tracing.py
-rw-r--r-- 1 root root 11722 Nov  5 11:28 test_server_tracing.py
tests/server/telemetry/test_provider_tracing.py:10:class TestFastMCPProviderTracing:
tests/server/telemetry/test_provider_tracing.py:13:    async def test_mounted_tool_creates_delegate_span(
tests/server/telemetry/test_provider_tracing.py:48:    async def test_mounted_resource_creates_delegate_span(
tests/server/telemetry/test_provider_tracing.py:74:    async def test_mounted_prompt_creates_delegate_span(
tests/server/telemetry/test_provider_tracing.py:104:class TestProviderSpanHierarchy:
tests/server/telemetry/test_provider_tracing.py:107:    async def test_delegate_span_is_child_of_server_span(

tests/ser
…[1345 chars omitted]…
source_span_includes_auth_attributes_when_authenticated(
tests/server/telemetry/test_server_tracing.py:264:    async def test_prompt_span_includes_auth_attributes_when_authenticated(
tests/server/telemetry/test_server_tracing.py:292:    async def test_span_omits_auth_attributes_when_not_authenticated(
tests/server/telemetry/test_server_tracing.py:313:    async def test_span_omits_scope_when_no_scopes(

111:    async def call_tool_mcp(
191:    async def call_tool(
205:    async def call_tool(
220:    async def call_tool(

        return await _parse_call_tool_result(
            name=name,
            result=result,
            tool_output_schemas=self.session._tool_output_schemas,
            list_tools_fn=self.session.list_tools,
            client_name=self.name,
            raise_on_error=raise_on_error,

        )

    @overload
    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: Literal[False] = False,
    ) -> CallToolResult: ...

    @overload
    async de
…[8628 chars omitted]…
put_schemas:
                output_schema = tool_output_schemas.get(name)
                if output_schema and output_schema.get("x-fastmcp-wrap-result"):
                    structured_content = result.structuredContent.get("result")
                else:
                    structured_content = result.structuredContent
            else:
                structured_content = result.structuredContent

# First time name is being changed, preserve original for backend calls
            update = {**update, "_backend_name": self.name}
            kwargs["update"] = update
        return super().model_copy(**kwargs)

    @classmethod
    def from_mcp_tool(
        cls, client_factory: ClientFactoryT, mcp_tool: mcp.types.Tool
    ) -> ProxyTool:
        """Factory method to create a ProxyTool from a raw MCP tool schema."""
        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", []),
          
…[5578 chars omitted]…
          ]
            return PromptResult(
                messages=messages,
                description=result.description,
                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,
        }

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_attribute("fastmcp.provider.type", "ProxyProvider")
            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):
…[2993 chars omitted]…
uri is None:
            # First time uri is being changed, preserve original for backend calls
            update = {**update, "_backend_uri": str(self.uri)}
            kwargs["update"] = update
        return super().model_copy(**kwargs)

    @classmethod
    def from_mcp_resource(
        cls,
        client_factory: ClientFactoryT,
        mcp_resource: mcp.types.Resource,
    ) -> ProxyResource:

grep: src/fastmcp/__pycache__/telemetry.cpython-312.pyc: binary file matches
src/fastmcp/telemetry.py:76:def record_span_error(span: Span, exception: BaseException) -> None:
src/fastmcp/telemetry.py:121:    "record_span_error",

run_middleware=False,
                        task_meta=task_meta,
                    ),
                )

            # Core logic: find and execute tool
            with server_span(
                f"tools/call {name}", "tools/call", self.name, "tool", name
            ) as span:
                # Try normal display-name resolution first.
                tool: Tool | None = await self.get_tool(name, version=version)

                # If that fails, try hashed-name dispatch. This walks
                # the provider tree recursively (same pattern as the old
                # get_app_tool) looking for a tool whose stored hash
                # matches the parsed prefix.
                if tool is None:
                    hashed = parse_hashed_backend_name(name)
                    if hashed is not None:
                        digest, local_name = hashed
 
…[5219 chars omitted]…
                   str(context.message.uri),
                        version=version,
                        run_middleware=False,
                        task_meta=task_meta,
                    ),
                )

            # Core logic: find and read resource (providers queried in parallel)
            with server_span(
                f"resources/read {uri}",
                "resources/read",

18c1c22 base
* master

"""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

grep: src/fastmcp/resources/__pycache__/base.cpython-312.pyc: binary file matches
docs/development/v3-notes/v3-features.mdx:440:- Resource metadata (including CSP/permissions) is propagated to `resources/read` response content items so hosts can read it when rendering the iframe
docs/development/v3-notes/v3-features.mdx:1175:from opentelemetry.exporter.otlp.proto.grpc.trace_exporter import OTLPSpanExporter
docs/integrations/eunomia-authorization.mdx:37:The middleware behaves as a firewall for execution operations (`tools/call`, `resources/read`, `prompts/get`), blocking operations that are not authorized by the defined policies.
docs/integrations/permit.mdx:20:- **MCP server methods** (e.g., `tools/list`, `resources/read`):
docs/integrations/permit.mdx:61:The middleware behaves as an enforcement point for execution operations (`tools/call`, `resources/read`, `prompts/get`), blocking o
…[4928 chars omitted]…
rc/fastmcp/server/telemetry.py:76:            "rpc.system": "mcp",
src/fastmcp/server/telemetry.py:77:            "rpc.service": server_name,
src/fastmcp/server/telemetry.py:78:            "rpc.method": method,
src/fastmcp/server/telemetry.py:80:            "mcp.method.name": method,
src/fastmcp/server/transforms/resources_as_tools.py:8:operations exactly as it would for direct `resources/read` calls.

```bash
export OTEL_SERVICE_NAME=my-fastmcp-server
export OTEL_EXPORTER_OTLP_ENDPOINT=http://localhost:4317

opentelemetry-instrument fastmcp run server.py
```

This works with any OTLP-compatible backend (Jaeger, Zipkin, Grafana Tempo, Datadog, etc.) and requires no changes to your FastMCP code.

<Card title="OpenTelemetry Python Documentation" icon="book" href="https://opentelemetry.io/docs/languages/python/">
  Learn more about the OpenTelemetry Python SDK, auto-instrumentation, and available exporters.
</Card>

## Tracing

FastMCP creates spans for all MCP operations, providing end-to-end visibility into request handling.

### Server Spans

The server creates spans for each operation using [MCP semantic conventions](https://opentelemetry.io/docs/specs/semconv/gen-ai/mcp/):

| Span Name | Description |
|-----------|-------------|
| `tools/call {name}` | Tool execution (e.g., `tools
…[4935 chars omitted]…
entifier (e.g., `tool:greet`) |
| `fastmcp.provider.type` | Provider class (`LocalProvider`, `FastMCPProvider`, `ProxyProvider`) |

Provider-specific attributes for delegation context:

| Attribute | Description |
|-----------|-------------|
| `fastmcp.delegate.original_name` | Original tool/prompt name before namespacing |
| `fastmcp.delegate.original_uri` | Original resource URI before namespacing |

/repo/src/fastmcp/__init__.py
['', '/usr/local/lib/python312.zip', '/usr/local/lib/python3.12', '/usr/local/lib/python3.12/lib-dynload', '/usr/local/lib/python3.12/site-packages', '/repo/src']
Name: fastmcp
Version: 0.0.1.dev1+18c1c22
Summary: The fast, Pythonic way to build MCP servers and clients.
Home-page: https://gofastmcp.com
Author: Jeremiah Lowin
Author-email: 
License-Expression: Apache-2.0
Location: /usr/local/lib/python3.12/site-packages
Editable project location: /repo
Requires: authlib, cyclopts, exceptiongroup, griffelib, httpx, jsonref, jsonschema-path, mcp, openapi-pydantic, opentelemetry-api, packaging, platformdirs, py-key-value-aio, pydantic, pyperclip, python-dotenv, pyyaml, rich, uncalled-for, uvicorn, watchfiles, websockets

Required-by: 
_editable_impl_fastmcp.pth
fastmcp-0.0.1.dev1+18c1c22.dist-info

/root/.cache/pip:
http-v2
selfcheck

/root/.cache/pip/http-v2:
0
1
2
3
4
5
6

7
8
9
a
b
c
d
e
f

/root/.cache/pip/http-v2/0:
0
2
3
4
5
6
7
8
9
a
c

/root/.cache/pip/http-v2/0/0:
1
4

/root/.cache/pip/http-v2/0/0/1:

49:        result = re.sub(rf"\{{{key}\}}", str(value), result)
52:    def _expand_query_block(match: re.Match[str]) -> str:
57:                parts.append(f"{quote(name)}={quote(str(params[name]))}")
62:    result = re.sub(r"\{\?([^}]+)\}", _expand_query_block, result)

"""FastMCP - An ergonomic MCP interface."""

import importlib
import warnings
from importlib.metadata import version as _version
from typing import TYPE_CHECKING

from fastmcp.settings import Settings
from fastmcp.utilities.logging import configure_logging as _configure_logging

if TYPE_CHECKING:
    from fastmcp.client import Client as Client

    from fastmcp.apps.app import FastMCPApp as FastMCPApp

settings = Settings()
if settings.log_enabled:
    _configure_logging(
        level=settings.log_level,
        enable_rich_tracebacks=settings.enable_rich_tracebacks,
    )

from fastmcp.exceptions import FastMCPDeprecationWarning
from fastmcp.server.server import FastMCP
from fastmcp.server.context import Context
import fastmcp.server

__version__ = _version("fastmcp")

if settings.deprecation_warnings:
    warnings.simplefilter("default", FastMCPDeprecationWarning)


# --- Lazy impor
…[296 chars omitted]…
   return Client
    if name == "FastMCPApp":
        from fastmcp.apps.app import FastMCPApp

        return FastMCPApp
    if name == "client":
        return importlib.import_module("fastmcp.client")
    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")


__all__ = [
    "Client",
    "Context",
    "FastMCP",
    "FastMCPApp",
    "FastMCPDeprecationWarning",
    "settings",
]

None
(self, name: str, context: opentelemetry.context.context.Context | None = None, kind: opentelemetry.trace.SpanKind = <SpanKind.INTERNAL: 0>, attributes: collections.abc.Mapping[str, str | bool | int | float | bytes | collections.abc.Sequence['AnyValue'] | collections.abc.Mapping[str, 'AnyValue'] | None] | None = None, links: collections.abc.Sequence[opentelemetry.trace.Link] | None = None, start_time: int | None = None, record_exception: bool = True, set_status_on_exception: bool = True, end_on_exit: bool = True) -> collections.abc.Iterator['Span']

"""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:
   
…[1406 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

"""Resource template functionality."""

from __future__ import annotations

import functools
import inspect
import re
from collections.abc import Callable
from typing import TYPE_CHECKING, Any, ClassVar, overload
from urllib.parse import parse_qs, quote, unquote

import mcp.types

from mcp.types import Annotations, Icon
from pydantic.json_schema import SkipJsonSchema

if TYPE_CHECKING:
    from docket import Docket
    from docket.execution import Execution
from mcp.types import ResourceTemplate as SDKResourceTemplate
from pydantic import (
    Field,
    field_validator,
    validate_call,
)

from fastmcp.resources.base import Resource, ResourceResult
from fastmcp.server.auth.authorization import AuthCheck
from fastmcp.server.dependencies import (
    transform_context_annotations,
    without_injected_parameters,
    """Match URI against template and extract both path and query param
…[2967 chars omitted]…
r:
        return f"{self.__class__.__name__}(uri_template={self.uri_template!r}, name={self.name!r}, description={self.description!r}, tags={self.tags})"

    @staticmethod
    def from_function(
        fn: Callable[..., Any],
        uri_template: str,
        name: str | None = None,
        version: str | int | None = None,
        title: str | None = None,
        description: str | None = None,

"""FastMCPProvider for wrapping FastMCP servers as providers.

This module provides the `FastMCPProvider` class that wraps a FastMCP server
and exposes its components through the Provider interface.

It also provides FastMCPProvider* component classes that delegate execution to
the wrapped server's middleware, ensuring middleware runs when components are
executed.
"""

from __future__ import annotations

from collections.abc import AsyncIterator, Sequence
from contextlib import asynccontextmanager
from typing import TYPE_CHECKING, Any, overload

import mcp.types
from mcp.types import AnyUrl

from fastmcp.prompts.base import Prompt, PromptResult
from fastmcp.resources.base import Resource, ResourceResult
from fastmcp.resources.template import ResourceTemplate, expand_uri_template
from fastmcp.server.providers.base import Provider
from fastmcp.server.tasks.config import TaskMeta
from fa
…[879 chars omitted]…
port
    _original_name: str | None = None

    def __init__(
        self,
        server: Any,
22:from fastmcp.resources.template import ResourceTemplate, expand_uri_template
367:        original_uri = expand_uri_template(self._original_uri_template or "", params)
397:        original_uri = expand_uri_template(self._original_uri_template or "", params)
416:        original_uri = expand_uri_template(

if "tracestate" in carrier:
        trace_meta[TRACE_STATE_KEY] = carrier["tracestate"]

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


def record_span_error(span: Span, exception: BaseException) -> None:
    """Record an exception on a span and set error status.

    The status description is the exception message, and ``error.type`` is

    ``"tool_error"`` for :class:`~fastmcp.exceptions.ToolError` (or any
    subclass) and the exception class's qualified name otherwise.
    """
    from fastmcp.exceptions import ToolError

    if isinstance(exception, ToolError):
        error_type = "tool_error"
    else:
        error_type = type(exception).__qualname__

    span.record_exception(exception)
    span.set_attribute("error.type", error_type)
    span.set_status(Status(StatusCode.ERROR, str(exception)))


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.

"""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, record_span_error


def set_span_error(
    span: Span, error_type: str, description: str | None = None

) -> None:
    """Mark a span as failed with an ``error.type`` attribute."""
    span.set_attribute("error.type", error_type)
    span.set_status(Status(StatusCode.ERROR, description))


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

    Automatically records any exception on the span and s
…[561 chars omitted]…
urce.uri"] = resource_uri
        if tool_name is not None:
            attrs["gen_ai.tool.name"] = tool_name
        if prompt_name is not None:
            attrs["gen_ai.prompt.name"] = prompt_name
        span.set_attributes(attrs)
        try:
            yield span
        except Exception as e:
            record_span_error(span, e)
            raise


__all__ = ["client_span", "set_span_error"]

"""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[
…[2777 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",
]

src/fastmcp/client/mixins/tools.py:142:        with client_span(
src/fastmcp/client/mixins/tools.py-143-            f"tools/call {name}",
src/fastmcp/client/mixins/tools.py-144-            "tools/call",
src/fastmcp/client/mixins/tools.py-145-            name,
src/fastmcp/client/mixins/tools.py-146-            session_id=self.transport.get_session_id(),
src/fastmcp/client/mixins/tools.py-147-            tool_name=name,
src/fastmcp/client/mixins/tools.py-148-        ) as span:
src/fastmcp/client/mixins/tools.py-149-            logger.debug(f"[{self.name}] called call_tool: {name}")
src/fastmcp/client/mixins/tools.py-150-
src/fastmcp/client/mixins/tools.py-151-            # Inject trace context into meta for propagation to server
src/fastmcp/client/mixins/tools.py-152-            propagated_meta = inject_trace_context(meta)
--

src/fastmcp/client/mixins/prompts.py:128:        with client_
…[5373 chars omitted]…
f"prompts/get {name}",
1515-                "prompts/get",
1516-                self.name,
1517-                "prompt",
1518-                name,
1519-                prompt_name=name,
1520-            ) as span:
1521-                prompt = await self.get_prompt(name, version=version)
1522-                if prompt is None:
1523-                    raise NotFoundError(f"Unknown prompt: {name!r}")

resource://sub/multi/abc/def -> abc/def
resource://sub/multi/abc -> abc

test://{x}/{y} {'x': 'foo', 'y': 'bar'} => test://foo/bar OK
test://a/{x}/b {'x': 'mid'} => test://a/mid/b OK
test://{path*} {'path': 'a/b/c'} => test://a/b/c OK
test://{a*}/mid/{b*} {'a': 'x/y', 'b': 'p/q'} => test://x/y/mid/p/q OK
test://data{?format,verbose} {} => test://data OK
test://data{?format,verbose} {'format': 'json'} => test://data?format=json OK
test://data{?format,verbose} {'verbose': 'true'} => test://data?verbose=true OK
test://data{?format,verbose} {'format': 'json', 'verbose': 'true'} => test://data?format=json&verbose=true OK
test://{x} {'x': 'a', 'y': 'b'} => test://a OK
test://{x} {'x': '{y}', 'y': 'b'} => test://{y} OK
roundtrip test://{x}/{y} test://foo/bar {'x': 'foo', 'y': 'bar'} => test://foo/bar OK
roundtrip test://{path*} test://a/b/c {'path': 'a/b/c'} => test://a/b/c OK

roundtrip test://{a*}/mid/{b*} test://x/y/mid/p/q {'a': 'x/y', 'b': 'p/q'} => test://x/
…[44 chars omitted]…
erbose} test://data {} => test://data OK
roundtrip test://data{?format,verbose} test://data?format=json {'format': 'json'} => test://data?format=json OK
roundtrip test://data{?format,verbose} test://data?format=json&verbose=true {'format': 'json', 'verbose': 'true'} => test://data?format=json&verbose=true OK
roundtrip resource://{extra*} resource://abc/def {'extra': 'abc/def'} => resource://abc/def OK

[11/05/26 11:35:05] Error calling tool 'failing_tool'                           
                    ╭─────────── Traceback (most recent call last) ────────────╮
                    │ /repo/src/fastmcp/server/server.py:1245 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                          │
                    │                                                          │
      

…[3493 chars omitted]…
nown tool: 'nonexistent'"
{'mcp.method.name': 'tools/call', 'fastmcp.component.type': 'tool', 'mcp.session.id': '20ec160c-bb25-4e35-91ad-c036ccf52a59', 'gen_ai.tool.name': 'nonexistent', 'error.type': 'NotFoundError'}

 SpanKind.CLIENT 'tools/call nonexistent' StatusCode.ERROR "Unknown tool: 'nonexistent'"
{'mcp.method.name': 'tools/call', 'gen_ai.tool.name': 'nonexistent', 'error.type': 'tool_error'}

src/fastmcp/server/providers/local_provider/decorators/tools.py:152: in add_tool
    tool = Tool.from_function(
src/fastmcp/tools/base.py:240: in from_function
    return FunctionTool.from_function(
src/fastmcp/tools/function_tool.py:204: in from_function
    task_config.validate_function(fn, func_name)
src/fastmcp/server/tasks/config.py:126: in validate_function
    require_docket(f"`task=True` on function '{name}'")
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

feature = "`task=True` on function 'background_tool'"

    def require_docket(feature: str) -> None:
        """Raise ImportError with install instructions if docket not available.
    
        Args:
            feature: Description of what requires docket (e.g., "`task=True`",
                     "CurrentDocket()"). Will be included in the error message.
        """
        if is_docket_a
…[2660 chars omitted]…
ver/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
FAILED tests/server/providers/test_local_provider.py::TestLocalProviderTaskRegistration::test_get_tasks_returns_task_eligible_tools
15 failed, 786 passed, 3 skipped, 36 warnings in 14.78s

......s................................................................. [ 22%]
........................................................................ [ 44%]
........................................................................ [ 66%]
........................................................................ [ 89%]
...................................                                      [100%]
322 passed, 1 skipped, 2 warnings in 2.35s

):
        mcp = FastMCP("test-server")
    
        @mcp.resource("users://{user_id}/profile")
        def get_user_profile(user_id: str) -> str:
            return f"profile for {user_id}"
    
        result = await mcp.read_resource("users://123/profile")
        assert "profile for 123" in str(result)
    
        spans = trace_exporter.get_finished_spans()
        assert len(spans) == 1

    
        span = spans[0]
>       assert span.name == "resources/read users://123/profile"
E       AssertionError: assert 'resources/read' == 'resources/re...//123/profile'
E         
E         - resources/read users://123/profile
E         + resources/read

tests/server/telemetry/test_server_tracing.py:129: AssertionError
________ TestResourceTracing.test_read_nonexistent_resource_sets_error _________

self = <tests.server.telemetry.test_server_tracing.TestResourceTracing object at 0x7499
…[3571 chars omitted]…
ead_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, 1 warning in 2.93s

resource://sub/multi/one/x/two/three -> one|two/three|json
resource://sub/multi/one/x/two/three?format=xml -> one|two/three|xml

src/fastmcp/client/mixins/resources.py:180:        """Send a resources/read request and return the complete MCP protocol result.

bash: line 819: ruff: command not found

/usr/local/bin/python: No module named ruff

src/fastmcp/client/mixins/prompts.py             |  1 +
 src/fastmcp/client/mixins/resources.py           |  2 +-
 src/fastmcp/client/mixins/tools.py               | 12 ++++++--
 src/fastmcp/client/telemetry.py                  | 31 ++++++++++++++-----
 src/fastmcp/resources/template.py                | 37 ++++++++++++++++++++++-
 src/fastmcp/server/providers/fastmcp_provider.py | 38 +++---------------------
 src/fastmcp/server/providers/proxy.py            | 12 ++++++--
 src/fastmcp/server/server.py                     | 16 ++++++++--
 src/fastmcp/server/telemetry.py                  | 28 ++++++++++-------
 src/fastmcp/telemetry.py                         | 17 +++++++++--
 10 files changed, 129 insertions(+), 65 deletions(-)
diff --git a/src/fastmcp/client/telemetry.py b/src/fastmcp/client/telemetry.py

index 10d6d82..7720fde 100644
--- a/src/fastmcp/client/telemetry.py
+++ b/src/fas
…[8629 chars omitted]…
f isinstance(exception, ToolError):
+        error_type = "tool_error"
+    else:
+        error_type = type(exception).__qualname__
+
     span.record_exception(exception)
-    span.set_status(Status(StatusCode.ERROR))
+    span.set_attribute("error.type", error_type)
+    span.set_status(Status(StatusCode.ERROR, str(exception)))
 
 
 def extract_trace_context(meta: dict[str, Any] | None) -> Context:

import sys

from .function_resource import FunctionResource, resource
from .base import Resource, ResourceContent, ResourceResult
from .template import ResourceTemplate
from .types import (
    BinaryResource,
    DirectoryResource,
    FileResource,
    HttpResource,
    TextResource,
)

__all__ = [
    "BinaryResource",
    "DirectoryResource",
    "FileResource",
    "FunctionResource",
    "HttpResource",
    "Resource",
    "ResourceContent",
    "ResourceResult",
    "ResourceTemplate",
    "TextResource",
    "resource",
]

# Backward compat: resource.py was renamed to base.py to stop Pyright from resolving
# `from fastmcp.resources import resource` as the submodule instead of the decorator function.
# This shim keeps `from fastmcp.resources.resource import Resource` working at runtime.
# Safe to remove once we're confident no external code imports from the old path.
sys.modules[f"{__name__}.resource"] = sys.modules[f"{__name__}.base"]

73:    _backend_name: str | None = None
87:        """Override to preserve _backend_name when name changes."""
89:        if "name" in update and self._backend_name is None:
91:            update = {**update, "_backend_name": self.name}
120:        backend_name = self._backend_name or self.name
175:            "fastmcp.proxy.backend_name": self._backend_name,
184:    _backend_uri: str | None = None
205:        """Override to preserve _backend_uri when uri changes."""
207:        if "uri" in update and self._backend_uri is None:
209:            update = {**update, "_backend_uri": str(self.uri)}
239:        backend_uri = self._backend_uri or str(self.uri)
282:            "fastmcp.proxy.backend_uri": self._backend_uri,

290:    _backend_uri_template: str | None = None
304:        """Override to preserve _backend_uri_template when uri_template changes."""
306:        if "uri_template" in u
…[5797 chars omitted]…
 update and self._backend_name is None:
            # First time name is being changed, preserve original for backend calls
            update = {**update, "_backend_name": self.name}
            kwargs["update"] = update
        return super().model_copy(**kwargs)

    @classmethod
    def from_mcp_prompt(
        cls, client_factory: ClientFactoryT, mcp_prompt: mcp.types.Prompt
    ) -> ProxyPrompt:

grep: tests/server/providers/proxy/__pycache__/test_proxy_server.cpython-312-pytest-9.2.0.pyc: binary file matches
tests/server/providers/proxy/test_proxy_server.py:496:        templates = await proxy_server.list_resource_templates()
tests/server/providers/proxy/test_proxy_server.py:500:        templates = await proxy_server.list_resource_templates()
tests/server/providers/proxy/test_proxy_server.py:516:        proxy_result = await proxy_server._list_resource_templates_mcp(
tests/server/providers/proxy/test_proxy_server.py:537:    async def test_proxy_template_returns_all_resource_contents(
tests/server/providers/proxy/test_proxy_server.py:540:        """Test that proxy template correctly returns all resource contents."""
tests/server/providers/proxy/test_proxy_server.py:568:    async def test_proxy_can_overwrite_proxied_resource_template(self, proxy_server):
tests/server/providers/pr
…[563 chars omitted]…
:
tests/server/providers/test_local_provider_resources.py:207:        """If a wildcard template is defined first, it will take priority."""
tests/server/providers/test_local_provider_resources.py:225:        """If a wildcard template is defined second, it will *not* take priority."""

tests/server/providers/test_local_provider_resources.py:647:    async def test_template_decorator_wildcard_param(self):

assert isinstance(original, TextResourceContents)
            assert isinstance(proxied, TextResourceContents)
            assert original.text == proxied.text, f"Content {i} text mismatch"
            assert original.mimeType == proxied.mimeType, (
                f"Content {i} mimeType mismatch"
            )
            assert original.meta == proxied.meta, f"Content {i} meta mismatch"

        # Verify the contents are what we expect
        assert original_result[0].text == "First item"
        assert original_result[0].mimeType == "text/plain"
        assert original_result[1].text == '{"key": "value"}'

        assert original_result[1].mimeType == "application/json"
        assert original_result[2].text == "# Markdown\nContent"
        assert original_result[2].mimeType == "text/markdown"

    async def test_read_resource_returns_none_if_not_found(self, proxy_serve
…[6728 chars omitted]…
ef test_get_prompts_meta(self, proxy_server):
        prompts = await proxy_server.list_prompts()
        welcome_prompt = next(p for p in prompts if p.name == "welcome")
        assert welcome_prompt.title == "Welcome"
        assert welcome_prompt.meta == {"fastmcp": {"tags": ["welcome"]}}
        assert welcome_prompt.icons == [
            Icon(src="https://example.com/welcome-icon.png")
        ]

tests/server/mount/test_proxy.py:24:        def get_data(query: str) -> str:
tests/server/mount/test_proxy.py:25:            return f"Data for {query}"
tests/server/mount/test_proxy.py:39:        result = await main_app.call_tool("proxy_get_data", {"query": "test"})

src/fastmcp/server/providers/proxy.py:343:        parameterized_uri = backend_template.format(
src/fastmcp/server/providers/proxy.py:348:            result = await client.read_resource(parameterized_uri)
src/fastmcp/server/providers/proxy.py:352:                f"Remote server returned empty content for {parameterized_uri}"
src/fastmcp/server/providers/proxy.py:381:            uri=parameterized_uri,

344:            **{k: quote(v, safe="") for k, v in params.items()}
10:import base64
11:import inspect
12:import time
15:from urllib.parse import quote
17:import mcp.types

"""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_NOT_FOUND,
    BlobResourceContents,
    ElicitRequestFormParams,
    TextResourceContents,
)
from pydantic.networks import AnyUrl

from fast
…[1061 chars omitted]…
rsions import VersionSpec, version_sort_key

if TYPE_CHECKING:
    from pathlib import Path

    from fastmcp.client.transports import ClientTransport

logger = get_logger(__name__)

# Type alias for client factory functions
ClientFactoryT = Callable[[], Client] | Callable[[], Awaitable[Client]]


# -----------------------------------------------------------------------------
# Proxy Component Classes

src/fastmcp/resources/template.py:171:151:        return f"{self.__class__.__name__}(uri_template={self.uri_template!r}, name={self.name!r}, description={self.description!r}, tags={self.tags})"
src/fastmcp/resources/template.py:282:95:        # Call resource.read() not resource._read() to avoid task routing on ephemeral resource
src/fastmcp/resources/template.py:312:100:            _meta=overrides.get(  # type: ignore[call-arg]  # _meta is Pydantic alias for meta field
src/fastmcp/resources/template.py:320:94:        # Note: This creates a simple ResourceTemplate instance. For function-based templates,
src/fastmcp/resources/template.py:463:90:                                f"Invalid boolean value for {param_name}: {param_value!r}"
src/fastmcp/resources/template.py:572:119:                    f"Query parameters {invalid_query_params} must be optional function parameters with default v
…[3175 chars omitted]…
tmcp/client/mixins/tools.py:257:91:            task (bool): If True, execute as background task (SEP-1686). Defaults to False.
src/fastmcp/client/mixins/tools.py:258:100:            task_id (str | None): Optional client-provided task ID (auto-generated if not provided).
src/fastmcp/client/mixins/tools.py:311:91:        If the server declines (graceful degradation), ToolTask wraps the immediate result.

grep: tests/server/providers/proxy/conftest.py: No such file or directory
tests/server/providers/proxy/test_proxy_client.py:87:async def proxy_server(fastmcp_server: FastMCP):
tests/server/providers/proxy/test_proxy_client.py:405:        from fastmcp.server.providers.proxy import FastMCPProxy
tests/server/providers/proxy/test_proxy_client.py:412:        proxy_via_factory = FastMCPProxy(client_factory=base_client.new)
tests/server/providers/proxy/test_proxy_server.py:22:    FastMCPProxy,
tests/server/providers/proxy/test_proxy_server.py:159:async def proxy_server(fastmcp_server):
tests/server/providers/proxy/test_proxy_server.py:169:    assert isinstance(server, FastMCPProxy)
tests/server/providers/proxy/test_proxy_server.py:171:    assert server.name.startswith("FastMCPProxy-")
tests/server/providers/proxy/test_proxy_server.py:193:    assert isinstance(proxy, FastMCPProxy)
tests/serve
…[1524 chars omitted]…
rver/providers/proxy/test_stateful_proxy_client.py:51:    return FastMCPProxy(client_factory=client.new_stateful)

tests/server/providers/proxy/test_stateful_proxy_client.py:136:        proxy_mcp_a = FastMCPProxy(
tests/server/providers/proxy/test_stateful_proxy_client.py:139:        proxy_mcp_b = FastMCPProxy(
tests/server/providers/proxy/test_stateful_proxy_client.py:182:        proxy = FastMCPProxy(

[11/05/26 11:37:23] Error reading resource 'resource://multi/abc/def'           
                    ╭─────────── Traceback (most recent call last) ────────────╮
                    │ /repo/src/fastmcp/server/server.py:1414 in read_resource │
                    │                                                          │
                    │ /repo/src/fastmcp/resources/template.py:283 in _read     │
                    │                                                          │
                    │ /repo/src/fastmcp/server/providers/proxy.py:343 in       │
                    │ create_resource                                          │
                    ╰──────────────────────────────────────────────────────────╯
                    KeyError: 'extra*'                                          
                    Error reading resource 'resource://multi/abc'               
      

…[512 chars omitted]…
ource                                          │
                    ╰──────────────────────────────────────────────────────────╯
                    KeyError: 'extra*'                                          
resource://multi/abc/def FAILED McpError Error reading resource 'resource://multi/abc/def': 'extra*'
resource://multi/abc FAILED McpError Error reading resource 'resource://multi/abc': 'extra*'

resource://multi/abc/def -> abc/def
resource://multi/abc -> abc
DEBUG    fastmcp.server.mixins.mcp_operations:mcp_operations.py:108 [FastMCP-44c0] Handler called: list_tools
DEBUG    fastmcp.server.mixins.mcp_operations:mcp_operations.py:211 [FastMCP-9ffb] Handler called: call_tool a_tool_a with {}
DEBUG    fastmcp.client.mixins.tools:tools.py:149 [StatefulProxyClient-0583:01f0] called call_tool: tool_a
DEBUG    fastmcp.server.mixins.mcp_operations:mcp_operations.py:211 [FastMCP-20e4] Handler called: call_tool tool_a with {}
DEBUG    fastmcp.server.mixins.mcp_operations:mcp_operations.py:108 [FastMCP-9ffb] Handler called: list_tools
DEBUG    fastmcp.client.mixins.tools:tools.py:55 [StatefulProxyClient-0583:01f0] called list_tools
DEBUG    fastmcp.client.mixins.tools:tools.py:55 [StatefulProxyClient-239f:d665] called list_tools
DEBUG    fastmcp.server.mixins.mcp_operations:mcp_operatio
…[994 chars omitted]…
AILED 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
3 failed, 79 passed, 17 warnings in 5.29s

DEBUG    fastmcp.client.transports.inference:inference.py:153 Inferred transport: <FastMCPTransport(server='FastMCPProxy-471a')>
DEBUG    fastmcp.client.mixins.tools:tools.py:149 [Client-0806] called call_tool: stateful_get
DEBUG    fastmcp.server.mixins.mcp_operations:mcp_operations.py:108 [FastMCPProxy-471a] Handler called: list_tools
DEBUG    fastmcp.server.providers.proxy:proxy.py:1089 <fastmcp.server.providers.proxy.StatefulProxyClient object at 0x77805f728800> created for <fastmcp.server.low_level.MiddlewareServerSession object at 0x77805f6ff530>
DEBUG    fastmcp.client.mixins.tools:tools.py:55 [StatefulProxyClient-e6a4:c0d8] called list_tools
DEBUG    fastmcp.server.mixins.mcp_operations:mcp_operations.py:108 [TestServer] Handler called: list_tools
DEBUG    fastmcp.server.mixins.mcp_operations:mcp_operations.py:211 [FastMCPProxy-471a] Handler called: call_tool stateful_get with
…[3382 chars omitted]…
call_tool stateful_get with {}
DEBUG    fastmcp.server.providers.proxy:proxy.py:1094 <fastmcp.server.providers.proxy.StatefulProxyClient object at 0x77805f728800> will be disconnect
=========================== short test summary info ============================
FAILED tests/server/providers/proxy/test_stateful_proxy_client.py::TestStatefulProxyClient::test_stateful_proxy

1 failed, 2 warnings in 1.90s

src/fastmcp/server/providers/filesystem_discovery.py:310:                        uri_template=meta.uri,
src/fastmcp/server/providers/local_provider/decorators/resources.py:62:                        uri_template=meta.uri,
src/fastmcp/server/providers/local_provider/local_provider.py:123:            return (ResourceTemplate, component.uri_template)
src/fastmcp/server/providers/local_provider/local_provider.py:285:    def remove_template(self, uri_template: str, version: str | None = None) -> None:
src/fastmcp/server/providers/local_provider/local_provider.py:289:            uri_template: The template URI pattern.
src/fastmcp/server/providers/local_provider/local_provider.py:300:                if isinstance(c, ResourceTemplate) and c.uri_template == uri_template
src/fastmcp/server/providers/local_provider/local_provider.py:303:                raise KeyError(f"Template {uri_template!r} 
…[1211 chars omitted]…
in component_fn for template {uri_template_str}: {e}"
src/fastmcp/server/providers/openapi/provider.py:377:        self._templates[template.uri_template] = template
src/fastmcp/server/providers/skills/skill_provider.py:393:                uri_template=f"skill://{skill.name}/{{path*}}",
src/fastmcp/server/providers/skills/skill_provider.py:433:            uri_template=f"skill://{skill.name}/{{path*}}",

src/fastmcp/resources/template.py:39:def extract_query_params(uri_template: str) -> set[str]:
src/fastmcp/resources/template.py:101:        query_param_names = extract_query_params(uri_template)
src/fastmcp/resources/template.py:541:        query_params = extract_query_params(uri_template)

tests/resources/test_resource_template.py:10:from fastmcp.resources.template import build_regex, match_uri_template
tests/resources/test_resource_template.py:409:    """Test match_uri_template function."""
tests/resources/test_resource_template.py:421:    def test_match_uri_template_single_param(
tests/resources/test_resource_template.py:424:        """Test that match_uri_template uses the slash delimiter."""
tests/resources/test_resource_template.py:426:        result = match_uri_template(uri=uri, uri_template=uri_template)
tests/resources/test_resource_template.py:453:    def test_match_uri_template_simple_params(
tests/resources/test_resource_template.py:458:        result = match_uri_template(uri=uri, uri_template=uri_template)
tests/resources/test_resource_template.py:471:    def test_match_uri_template_params_and_literal_segments(
tests/resources/test_resource_template.py:476:  
…[2122 chars omitted]…
_template_embedded_param_with_prefix_and_suffix(
tests/resources/test_resource_template.py:610:        result = match_uri_template(uri=uri, uri_template=uri_template)

tests/resources/test_resource_template.py:789:    def test_match_uri_template_returns_none_for_malformed_templates(
tests/resources/test_resource_template.py:792:        assert match_uri_template("test://anything/path", template) is None

)

        assert isinstance(resource, FunctionResource)
        # read() returns raw string from __call__
        result = await resource.read()
        assert result == "X was foo"


class TestMatchUriTemplate:
    """Test match_uri_template function."""

    @pytest.mark.parametrize(

        "uri, expected_params",
        [
            ("test://a/b", None),
            ("test://a/b/c", None),
            ("test://a/x/b", {"x": "x"}),
            ("test://a/x/y/b", None),
            ("test://a/1-2/b", {"x": "1-2"}),
        ],
    )
    def test_match_uri_template_single_param(
        self, uri: str, expected_params: dict[str, str]
    ):
        """Test that match_uri_template uses the slash delimiter."""
        uri_template = "test://a/{x}/b"
        result = match_uri_template(uri=uri, uri_template=uri_template)
        assert result == expected_params

    @pytest.ma
…[8133 chars omitted]…
    name="test",
        )

        def template_without_context(x: int) -> str:
            return str(x)

        ResourceTemplate.from_function(
            fn=template_without_context,
            uri_template="test://{x}",
            name="test",
        )

    def test_parameterized_context_parameter_detection(self):
        """Test that parameterized context parameters are properly detected in

from fastmcp.prompts.base import Prompt, PromptResult
from fastmcp.resources.base import Resource, ResourceResult
from fastmcp.resources.template import ResourceTemplate, expand_uri_template
from fastmcp.server.providers.base import Provider
from fastmcp.server.tasks.config import TaskMeta
from fastmcp.server.telemetry import delegate_span
from fastmcp.tools.base import Tool, ToolResult
from fastmcp.utilities.components import FastMCPComponent
from fastmcp.utilities.versions import VersionSpec

if TYPE_CHECKING:
    from docket import Docket

    from docket.execution import Execution

    from fastmcp.server.server import FastMCP


# Backwards-compatible private alias for the URI template expansion helper.
_expand_uri_template = expand_uri_template

$
# Backwards-compatible private alias for the URI template expansion helper.$
_expand_uri_template = expand_uri_template$
$
$
# -----------------------------------------------------------------------------$
# FastMCPProvider component classes$
# -----------------------------------------------------------------------------$
$
$
class FastMCPProviderTool(Tool):$
    """Tool that delegates execution to a wrapped server's middleware.$

$
    When `run()` is called, this tool invokes the wrapped server's$
    `_call_tool_middleware()` method, ensuring the server's middleware$

grep: tests/server/providers/proxy/__pycache__/test_proxy_server.cpython-312-pytest-9.2.0.pyc: binary file matches
tests/client/auth/test_oauth_static_client.py:12:from fastmcp.client.auth.oauth import ClientNotFoundError
tests/client/auth/test_oauth_static_client.py:141:        # Make the parent auth flow raise ClientNotFoundError
tests/client/auth/test_oauth_static_client.py:143:            raise ClientNotFoundError("client not found")
tests/client/auth/test_oauth_static_client.py:150:            with pytest.raises(ClientNotFoundError, match="static client credentials"):
tests/client/auth/test_oauth_static_client.py:163:                raise ClientNotFoundError("client not found")
tests/server/providers/proxy/test_proxy_server.py:458:            McpError, match="Unknown resource: 'resource://nonexistent'"

[11/05/26 11:38:56] Error calling tool 'f'                                      
                    ╭─────────── Traceback (most recent call last) ────────────╮
                    │ /repo/src/fastmcp/server/server.py:1245 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 f:14                                                  │
                    ╰──────────────────────────────────────────────────────────╯

                    ValueError: boom                                            
SpanKind.SERVER tools/call f <opentelemetry.trace.status.Status object at 0x73d881390c80> 1 ['exception']
SpanKind.CLIENT tools/call f <opentelemetry.trace.status.Status object at 0x73d881a2acc0> 0 []

tests/client/sampling/handlers/test_anthropic_handler.py:5: in <module>
    from anthropic import AsyncAnthropic
E   ModuleNotFoundError: No module named 'anthropic'
____ ERROR collecting tests/client/sampling/handlers/test_openai_handler.py ____
ImportError while importing test module '/repo/tests/client/sampling/handlers/test_openai_handler.py'.
Hint: make sure your test modules/packages have valid Python names.
Traceback:
/usr/local/lib/python3.12/importlib/__init__.py:90: in import_module
    return _bootstrap._gcd_import(name[level:], package, level)
           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
tests/client/sampling/handlers/test_openai_handler.py:18: in <module>
    from openai import AsyncOpenAI

E   ModuleNotFoundError: No module named 'openai'
________________ ERROR collecting tests/client/test_openapi.py _________________
ImportError while importing test mo
…[976 chars omitted]…
module named 'psutil'
=========================== short test summary info ============================
ERROR tests/client/sampling/handlers/test_anthropic_handler.py
ERROR tests/client/sampling/handlers/test_openai_handler.py
ERROR tests/client/test_openapi.py
ERROR tests/client/test_stdio.py
!!!!!!!!!!!!!!!!!!! Interrupted: 4 errors during collection !!!!!!!!!!!!!!!!!!!!
4 warnings, 4 errors in 4.09s

tests/client/auth/test_oauth_cimd.py
tests/client/auth/test_oauth_client.py
tests/client/auth/test_oauth_static_client.py
tests/client/client/test_auth.py
tests/client/client/test_client.py
tests/client/client/test_error_handling.py
tests/client/client/test_initialize.py
tests/client/client/test_session.py
tests/client/client/test_timeout.py
tests/client/client/test_transport.py
tests/client/tasks/test_client_prompt_tasks.py
tests/client/tasks/test_client_resource_tasks.py

tests/client/tasks/test_client_task_notifications.py
tests/client/tasks/test_client_task_protocol.py
tests/client/tasks/test_client_tool_tasks.py
tests/client/tasks/test_task_context_validation.py
tests/client/tasks/test_task_result_caching.py
tests/client/telemetry/test_client_tracing.py
tests/client/test_elicitation.py
tests/client/test_elicitation_enums.py
tests/client/test_logs.py
tests/client/test_notifications
…[149 chars omitted]…
/client/test_roots.py
tests/client/test_sampling.py
tests/client/test_sampling_result_types.py
tests/client/test_sampling_tool_loop.py
tests/client/test_sse.py
tests/client/test_stdio.py
tests/client/test_streamable_http.py
tests/client/transports/test_memory_transport.py
tests/client/transports/test_no_redirect.py
tests/client/transports/test_transports.py
tests/client/transports/test_uv_transport.py

logger.debug(
                                    f"Error closing transport after cancellation: {e}"
                                )
    
                    raise
    
                if self._session_state.session_task.done():
                    exception = self._session_state.session_task.exception()
                    if exception is None:
                        raise RuntimeError(
                            "Session task completed without exception but connection failed"
                        )

                    # Preserve specific exception types that clients may want to handle
                    if isinstance(exception, httpx.HTTPStatusError | McpError):
                        raise exception
>                   raise RuntimeError(
                        f"Client failed to connect: {exception}"
                    ) from exception
E 
…[441 chars omitted]…
225 Stdio transport disconnected
=========================== short test summary info ============================
FAILED tests/client/transports/test_memory_transport.py::test_task_teardown_does_not_hang
FAILED tests/client/transports/test_uv_transport.py::test_uv_transport - Runt...
FAILED tests/client/transports/test_uv_transport.py::test_uv_transport_module
3 failed, 153 passed, 4 warnings in 5.73s

tests/server/auth/test_auth_provider.py
tests/server/auth/test_authorization.py
tests/server/auth/test_cimd.py
tests/server/auth/test_cimd_validators.py
tests/server/auth/test_debug_verifier.py
tests/server/auth/test_enhanced_error_responses.py
tests/server/auth/test_jwt_issuer.py
tests/server/auth/test_jwt_provider.py
tests/server/auth/test_jwt_provider_bearer.py
tests/server/auth/test_multi_auth.py
tests/server/auth/test_oauth_consent_flow.py
tests/server/auth/test_oauth_consent_page.py

tests/server/auth/test_oauth_mounting.py
tests/server/auth/test_oauth_proxy_redirect_validation.py
tests/server/auth/test_oauth_proxy_storage.py
tests/server/auth/test_oidc_proxy.py
tests/server/auth/test_oidc_proxy_token.py
tests/server/auth/test_redirect_validation.py
tests/server/auth/test_remote_auth_provider.py
tests/server/auth/test_ssrf_protection.py
tests/server/auth/test_static_token_verifie
…[3694 chars omitted]…
ests/server/transforms/test_prompts_as_tools.py
tests/server/transforms/test_resources_as_tools.py
tests/server/transforms/test_search.py
tests/server/transforms/test_visibility.py
tests/server/versioning/test_calls.py
tests/server/versioning/test_filtering.py
tests/server/versioning/test_mounting.py
tests/server/versioning/test_versioning.py
tests/server/versioning/test_visibility_version_fallback.py

feature: Description of what requires docket (e.g., "`task=True`",
                     "CurrentDocket()"). Will be included in the error message.
        """
        if is_docket_available():
            return
    
        try:
            installed = importlib.metadata.version("pydocket")
        except importlib.metadata.PackageNotFoundError:
            installed = None
    
        if installed is None:

            detail = (
                "FastMCP background tasks require the `tasks` extra. "
                "Install with: pip install 'fastmcp[tasks]'."
            )
        else:
            detail = (
                f"FastMCP background tasks require pydocket>={_MIN_DOCKET_VERSION}, "
                f"but pydocket {installed} is installed (likely pulled in by another "
                f"package). Upgrade with: pip install -U 'pydocket>={_MIN_DOCKET_VERSION}'."
…[149 chars omitted]…
 extra. Install with: pip install 'fastmcp[tasks]'. (Triggered by `task=True` on function '_trigger_docket')

src/fastmcp/server/dependencies.py:484: ImportError
=========================== short test summary info ============================
FAILED tests/server/mount/test_advanced.py::TestMountedServerDocketBehavior::test_mounted_server_does_not_have_docket
1 failed, 386 passed, 19 warnings in 11.29s

count: 1568
size: 28780
in-pack: 0
packs: 0
size-pack: 0
prune-packable: 0
garbage: 0
size-garbage: 0

/root/.cache/pip/http-v2/0/0/4/f/5/004f51e4cdaa64d7951a6294c47f410a2290cde6415bd52c394181fd.body
/root/.cache/pip/http-v2/0/4/7/9/c/0479ce859c7c6e6995bb29588985f020b02188d79a9e0a811760e423.body
/root/.cache/pip/http-v2/4/f/e/a/d/4fead7217500083ca3641c2057a71888973231e8de59b9a7e0e20bc9.body
/root/.cache/pip/http-v2/3/1/5/3/9/31539552f2303282ae40da968a51b4e53cadfeaff6b349f1c1a078d2.body
/root/.cache/pip/http-v2/5/a/0/e/8/5a0e822c64c6d1f33f153767105760052e23ef8293f8ec21cf53e92b.body
/root/.cache/pip/http-v2/c/0/7/5/e/c075eddd397d7476a35f6f456176a5e685398513c85b6de587a26888.body
/root/.cache/pip/http-v2/c/9/8/2/9/c9829d95c08e15277f201869ef58dcdddcdf5e7fd1cb31806eb27773.body
/root/.cache/pip/http-v2/8/9/0/e/1/890e1d8f8a3be739083459e9f440845c263cfa35fde3fed088e7b670.body

bash: line 977: file: command not found
bash: line 977: file: command not found
bash: line 977: file: command not found
bash: line 977: file: command not found
bash: line 977: file: command not found
bash: line 977: file: command not found
bash: line 977: file: command not found
bash: line 977: file: command not found
/root/.cache/pip/http-v2/0/0/4/f/5/004f51e4cdaa64d7951a6294c47f410a2290cde6415bd52c394181fd.body 
/root/.cache/pip/http-v2/0/4/7/9/c/0479ce859c7c6e6995bb29588985f020b02188d79a9e0a811760e423.body 
/root/.cache/pip/http-v2/4/f/e/a/d/4fead7217500083ca3641c2057a71888973231e8de59b9a7e0e20bc9.body 
/root/.cache/pip/http-v2/3/1/5/3/9/31539552f2303282ae40da968a51b4e53cadfeaff6b349f1c1a078d2.body 

/root/.cache/pip/http-v2/5/a/0/e/8/5a0e822c64c6d1f33f153767105760052e23ef8293f8ec21cf53e92b.body 
/root/.cache/pip/http-v2/c/0/7/5/e/c075eddd397d7476a35f6f456176a5e685398513c85b6de587a26888.body 
/root/.cache/pip/http-v2/c/9/8/2/9/c9829d95c08e15277f201869ef58dcdddcdf5e7fd1cb31806eb27773.body 
/root/.cache/pip/http-v2/8/9/0/e/1/890e1d8f8a3be739083459e9f440845c263cfa35fde3fed088e7b670.body

90630 ZIP ['jsonschema/__init__.py', 'jsonschema/__main__.py', 'jsonschema/_format.py', 'jsonschema/_keywords.py', 'jsonschema/_legacy_keywords.py']
73517 ZIP ['httpx/__init__.py', 'httpx/__version__.py', 'httpx/_api.py', 'httpx/_auth.py', 'httpx/_client.py']
57328 ZIP ['pathspec/__init__.py', 'pathspec/_meta.py', 'pathspec/_typing.py', 'pathspec/_version.py', 'pathspec/backend.py']
32253 ZIP ['multipart/__init__.py', 'multipart/decoders.py', 'multipart/exceptions.py', 'multipart/multipart.py', 'python_multipart/__init__.py']
28051 ZIP ['dirty_equals/__init__.py', 'dirty_equals/_base.py', 'dirty_equals/_boolean.py', 'dirty_equals/_datetime.py', 'dirty_equals/_dict.py']
14900 ZIP ['uncalled_for/__init__.py', 'uncalled_for/annotations.py', 'uncalled_for/base.py', 'uncalled_for/frames.py', 'uncalled_for/functional.py']
78784 ZIP ['httpcore/__init__.py', 'httpcore/_api.py', 'httpcore/_exc
…[8629 chars omitted]…
uppress.py']
141756 ZIP ['opentelemetry/sdk/__init__.pyi', 'opentelemetry/sdk/py.typed', 'opentelemetry/sdk/_configuration/__init__.py', 'opentelemetry/sdk/_logs/__init__.py', 'opentelemetry/sdk/_logs/_internal/__init__.py']
11083 ZIP ['uv_dynamic_versioning/__init__.py', 'uv_dynamic_versioning/base.py', 'uv_dynamic_versioning/cli.py', 'uv_dynamic_versioning/hooks.py', 'uv_dynamic_versioning/main.py']

[11/05/26 11:40:14] Error calling tool 't'                                      
                    ╭─────────── Traceback (most recent call last) ────────────╮
                    │ /repo/src/fastmcp/server/server.py:1245 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 t:12                                                  │
                    ╰──────────────────────────────────────────────────────────╯

                    ToolError: Something went wrong                             
raised ToolError Something went wrong
SpanKind.SERVER tools/call t StatusCode.ERROR 'Something went wrong' tool_error
SpanKind.CLIENT tools/call t StatusCode.ERROR 'Something went wrong' tool_error

)

            # Core logic: find and read resource (providers queried in parallel)
            with server_span(
                "resources/read",
                "resources/read",
                self.name,
                "resource",
                uri,
                resource_uri=uri,
            ) as span:
                # Intercept synthetic Prefab renderer URIs before normal

                # resolution. The resource isn't stored anywhere — we
                # build it on demand from the matching tool's CSP.
                from fastmcp.server.providers.prefab_synthesis import (
                    synthesize_prefab_resource_by_uri,
                )

                synthesized = await synthesize_prefab_resource_by_uri(self, uri)
                if synthesized is not None:
                    span.set_attributes(synthesized.get_span_attributes())
          
…[3693 chars omitted]…
Error reading resource {uri!r}") from e
                    raise ResourceError(f"Error reading resource {uri!r}: {e}") from e

    @overload
    async def render_prompt(
        self,
        name: str,
        arguments: dict[str, Any] | None = None,
        *,
        version: VersionSpec | None = None,
        run_middleware: bool = True,
        task_meta: None = None,
    ) -> PromptResult: ...

133:                f"{quote(name)}={quote(str(params[name]))}"

compiled

diff --git a/src/fastmcp/client/mixins/prompts.py b/src/fastmcp/client/mixins/prompts.py
index 4b87bf2..bb32cc2 100644
--- a/src/fastmcp/client/mixins/prompts.py
+++ b/src/fastmcp/client/mixins/prompts.py
@@ -130,6 +130,7 @@ class ClientPromptsMixin:
             "prompts/get",
             name,
             session_id=self.transport.get_session_id(),
+            prompt_name=name,
         ):
             logger.debug(f"[{self.name}] called get_prompt: {name}")
 

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/r
…[5958 chars omitted]…
r_span(
-                f"prompts/get {name}", "prompts/get", self.name, "prompt", name
+                f"prompts/get {name}",
+                "prompts/get",
+                self.name,
+                "prompt",
+                name,
+                prompt_name=name,
             ) as span:
                 prompt = await self.get_prompt(name, version=version)
                 if prompt is None:

"""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, set_span_error
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 union (SEP-1686 graceful degradation)

resource://mid/leaf/multi/abc/def -> abc/def
resource://mid/leaf/multi/abc -> abc

file://sub/data/x/y/z.py -> x/y/z
file://sub/data/x/y/z/.py -> x/y/z/

test://{x}/{y} {'x': 'foo', 'y': 'bar'} => test://foo/bar OK
test://a/{x}/b {'x': 'mid'} => test://a/mid/b OK
test://{path*} {'path': 'a/b/c'} => test://a/b/c OK
test://{a*}/mid/{b*} {'a': 'x/y', 'b': 'p/q'} => test://x/y/mid/p/q OK
test://data{?format,verbose} {} => test://data OK
test://{x} {'x': 'two words'} => test://two%20words OK
test://{x} {'x': 'foo/bar'} => test://foo%2Fbar OK
test://{x} {'x': 'email@domain.com'} => test://email@domain.com OK
roundtrip 'test://foo/123' OK
roundtrip 'test://bar/456' OK
roundtrip 'test://foo/bar' OK
roundtrip 'test://foo/email@domain.com' OK

roundtrip 'test://two words/foo' FAIL got 'test://two%20words/foo'
roundtrip 'test://two.words/foo+bar' OK
roundtrip 'test://escaped%2Fword/bar' OK
roundtrip 'test://escaped%7Bx%7Dword/bar' OK
roundtrip 'test://a/x/y/b' OK
roundtrip 'test://a/x/y/b/c/d' OK
roundtrip 'file://abc/x/y/z.py' OK
roundtrip 'file://abc/x/y/z/.py' OK
roundtrip 'test://data?format=json&verbose=true' OK

users://sub/John%20Doe/profile -> John Doe
users://sub/a%2Fb/profile -> a/b

if name in parsed_query:
                # Take first value if multiple provided
                params[name] = parsed_query[name][0]

    return params


def expand_uri_template(uri_template: str, params: dict[str, Any]) -> str:
    """Expand a URI template with parameters.

    This is the inverse of :func:`match_uri_template`. It supports the same
    RFC 6570 syntax:

    - Simple path parameters: `{var}` -> ``params["var"]``
    - Wildcard path parameters: `{var*}` -> ``params["var"]`` (slashes are
      preserved, since wildcard parameters may span multiple path segments)
    - Query parameters: `{?var1,var2}` -> only the parameters present in
      ``params`` are emitted

    Parameters not referenced by the template are ignored.
    """

    def _expand(match: re.Match[str]) -> str:
        expression = match.group(1)

        if expression.startswith("?"):
       
…[465 chars omitted]…
       # Percent-encode characters that are not valid in a URI path. For
        # wildcard parameters, preserve slashes so they can span multiple
        # path segments.
        safe = "!$&'()*+,;=:@"
        if is_wildcard:
            safe += "/"
        return quote(str(params[name]), safe=safe)

    return re.sub(r"\{([^{}]+)\}", _expand, uri_template)


class ResourceTemplate(FastMCPComponent):

CLIENT tools/call add {'mcp.method.name': 'tools/call', 'fastmcp.component.key': 'add', 'gen_ai.tool.name': 'add'}
CLIENT tools/call add {'mcp.method.name': 'tools/call', 'fastmcp.component.key': 'add', 'gen_ai.tool.name': 'add', 'fastmcp.provider.type': 'ProxyProvider'}
CLIENT tools/call add {'mcp.method.name': 'tools/call', 'fastmcp.component.key': 'add', 'gen_ai.tool.name': 'add'}
CLIENT prompts/get welcome {'mcp.method.name': 'prompts/get', 'fastmcp.component.key': 'welcome', 'gen_ai.prompt.name': 'welcome'}
CLIENT prompts/get welcome {'mcp.method.name': 'prompts/get', 'fastmcp.component.key': 'welcome', 'gen_ai.prompt.name': 'welcome', 'fastmcp.provider.type': 'ProxyProvider'}
CLIENT prompts/get welcome {'mcp.method.name': 'prompts/get', 'fastmcp.component.key': 'welcome', 'gen_ai.prompt.name': 'welcome'}
CLIENT resources/read {'mcp.method.name': 'resources/read', 'fastmcp.component.key': 'data://config', 'mcp.resource.uri': 'data://config'}
CLIENT resources/read {'mcp.method.name': 'resources/read', 'fastmcp.component.key': 'data://config', 'mcp.resource.uri': 'data://config', 'fastmcp.provider.type': 'ProxyProvider'}
CLIENT resources/read {'mcp.method.name': 'resources/read', 'fastmcp.component.key': 'data://config', 'mcp.resource.uri': 'data://config'}

......s................................................................. [ 25%]
........................................................................ [ 50%]
........................................................................ [ 75%]
.......................................................................  [100%]
286 passed, 1 skipped, 1 warning in 4.24s

ok

TRACE_PARENT_KEY = "traceparent"
TRACE_STATE_KEY = "tracestate"


def get_tracer(version: str | None = None) -> Tracer:
    """Get the FastMCP tracer for creating spans.

    Args:
        version: Optional version string for the instrumentation

    Returns:
        A tracer instance. Returns a no-op tracer if no SDK is configured.
    """
    return otel_get_tracer(INSTRUMENTATION_NAME, version)

def record_span_error(span: Span, exception: BaseException) -> None:
    """Record an exception on a span and set error status.

    The status description is the exception message, and ``error.type`` is
    ``"tool_error"`` for :class:`~fastmcp.exceptions.ToolError` (or any
    subclass) and the exception class's qualified name otherwise.
    """
    if isinstance(exception, ToolError):
        error_type = "tool_error"
    else:
        error_type = type(exception).__qualname__

    span.record_exception(exception)
    span.set_attribute("error.type", error_type)
    span.set_status(Status(StatusCode.ERROR, str(exception)))


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

# Now FastMCP will emit traces
    from fastmcp import FastMCP
    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 opentelemetry.trace import get_tracer as otel_get_tracer

from fastmcp.exceptions import ToolError

INSTRUMENTATION_NAME = "fastmcp"

tool error raised: Error calling tool 'failing_tool': boom
missing resource raised: McpError
missing tool raised: ToolError
 SpanKind.SERVER 'tools/call add' StatusCode.UNSET None
 SpanKind.CLIENT 'tools/call add' StatusCode.UNSET None
 SpanKind.SERVER 'prompts/get welcome' StatusCode.UNSET None
 SpanKind.CLIENT 'prompts/get welcome' StatusCode.UNSET None
 SpanKind.SERVER 'resources/read' StatusCode.UNSET None
 SpanKind.CLIENT 'resources/read' StatusCode.UNSET None
 SpanKind.SERVER 'resources/read' StatusCode.UNSET None
 SpanKind.CLIENT 'resources/read' StatusCode.UNSET None
 SpanKind.SERVER 'tools/call failing_tool' StatusCode.ERROR "Error calling tool 'failing_tool': boom"

 SpanKind.CLIENT 'tools/call failing_tool' StatusCode.ERROR "Error calling tool 'failing_tool': boom"
 SpanKind.SERVER 'resources/read' StatusCode.ERROR "Unknown resource: 'missing://nope'"
{'mcp.method.name': 're
…[163 chars omitted]…
'NotFoundError'}
 SpanKind.CLIENT 'resources/read' StatusCode.ERROR "Resource not found: Unknown resource: 'missing://nope'"
{'mcp.method.name': 'resources/read', 'mcp.resource.uri': 'missing://nope', 'error.type': 'McpError'}
 SpanKind.SERVER 'tools/call nonexistent' StatusCode.ERROR "Unknown tool: 'nonexistent'"
 SpanKind.CLIENT 'tools/call nonexistent' StatusCode.ERROR "Unknown tool: 'nonexistent'"

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::TestClientToolTracing::test_call_tool_span_attributes
FAILED tests/client/telemetry/test_client_tracing.py::TestClientResourceTracing::test_read_resource_creates_span
FAILED tests/client/telemetry/test_client_tracing.py::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

FAILE
…[292 chars omitted]…
ead_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, 1 warning in 3.35s

/repo
total 620
drwxr-xr-x 1 root root   4096 Nov  2 18:27 .
drwxr-xr-x 1 root root   4096 Nov  2 18:28 ..
-rw-r--r-- 1 root root    115 Nov  2 18:27 .ccignore
drwxr-xr-x 1 root root   4096 Nov  2 18:27 .claude
-rw-r--r-- 1 root root     53 Nov  2 18:27 .coderabbit.yaml
drwxr-xr-x 1 root root   4096 Nov  2 18:27 .cursor
drwxr-xr-x 1 root root   4096 Nov  2 18:28 .git
drwxr-xr-x 1 root root   4096 Nov  2 18:27 .github
-rw-r--r-- 1 root root    819 Nov  2 18:27 .gitignore
-rw-r--r-- 1 root root   1369 Nov  2 18:27 .pre-commit-config.yaml

-rw-r--r-- 1 root root      5 Nov  2 18:27 .python-version
lrwxrwxrwx 1 root root      9 Nov  2 18:27 AGENTS.md -> CLAUDE.md
-rw-r--r-- 1 root root  12079 Nov  2 18:27 CLAUDE.md
-rw-r--r-- 1 root root   5218 Nov  2 18:27 CODE_OF_CONDUCT.md
-rw-r--r-- 1 root root   5633 Nov  2 18:27 CONTRIBUTING.md
-rw-r--r-- 1 root root  11356 Nov  2 18:27 LICENSE
-rw-r
…[354 chars omitted]…
oml
-rw-r--r-- 1 root root   7478 Nov  2 18:27 pyproject.toml
drwxr-xr-x 1 root root   4096 Nov  2 18:27 scripts
drwxr-xr-x 1 root root   4096 Nov  2 18:27 skills
drwxr-xr-x 1 root root   4096 Nov  2 18:27 src
drwxr-xr-x 1 root root   4096 Nov  2 18:27 tests
-rw-r--r-- 1 root root 545089 Nov  2 18:27 uv.lock
drwxr-xr-x 1 root root   4096 Nov  2 18:27 v3-notes
find: ‘fastmcp’: No such file or directory

src/fastmcp/__init__.py
src/fastmcp/apps/__init__.py
src/fastmcp/apps/app.py
src/fastmcp/apps/approval.py
src/fastmcp/apps/choice.py
src/fastmcp/apps/config.py
src/fastmcp/apps/file_upload.py
src/fastmcp/apps/form.py
src/fastmcp/apps/generative.py
src/fastmcp/cli/__init__.py
src/fastmcp/cli/__main__.py
src/fastmcp/cli/apps_dev.py

src/fastmcp/cli/auth.py
src/fastmcp/cli/cimd.py
src/fastmcp/cli/cli.py
src/fastmcp/cli/client.py
src/fastmcp/cli/discovery.py
src/fastmcp/cli/generate.py
src/fastmcp/cli/install/__init__.py
src/fastmcp/cli/install/claude_code.py
src/fastmcp/cli/install/claude_desktop.py
src/fastmcp/cli/install/cursor.py
src/fastmcp/cli/install/gemini_cli.py
src/fastmcp/cli/install/goose.py
src/fastmcp/cli/install/mcp_json.py
src/fastmcp/cli/install/shared.py
src/fastmcp/cli/install/stdio.py
src/fastmcp/cli/run.py
src/fastmcp/cli/tasks.py
src/fastmcp/client/__init__.py
src/fas
…[8629 chars omitted]…
sts/server/tasks/test_task_proxy.py
tests/server/tasks/test_task_resources.py
tests/server/telemetry/__init__.py
tests/server/telemetry/test_provider_tracing.py
tests/server/telemetry/test_server_tracing.py
tests/server/test_fastapi_testclient_compat.py
tests/server/transforms/test_resources_as_tools.py
tests/server/versioning/test_mounting.py
tests/telemetry/__init__.py
tests/telemetry/test_module.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:
            return f"Hello, {name}!"

        client = Client(server)
        async with client:
            result = await client.call_tool("greet", {"name": "World"})
            assert "Hello, World!" in str(result)

        spans = trace_exporter.get_finished_spans()
…[8630 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

"""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
…[8630 chars omitted]…
n is not None:
            request_meta["fastmcp"] = {
                **request_meta.get("fastmcp", {}),
                "version": version,
            }

        if task:
            return await self._read_resource_as_task(
                uri, task_id, ttl, meta=request_meta or None
            )

        if isinstance(uri, str):
            try:
                uri = AnyUrl(uri)  # Ensure AnyUrl

"""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) -> ProxyTool:
        """Override to preserve _backend_name when name changes."""
        update = kwargs.get("update", {})
        if "name" in update and self._backend_name is None:
            # First time name is being changed, preserve original for backend calls
            update = {**update, "_backend_name": self.name}

            kwargs["update"] = update
        return super().model_copy(**kwargs)

    @classmethod
    def from_mcp_tool(
        cls, client_factory: ClientFactoryT, mcp_tool: mcp.types.Tool
    ) -> ProxyTool:
        """Factory method to create a ProxyTool from a raw MCP tool schema."""
        ret
…[6255 chars omitted]…
 super().get_span_attributes() | {
            "fastmcp.provider.type": "ProxyProvider",
            "fastmcp.proxy.backend_name": self._backend_name,
        }
src/fastmcp/server/server.py:1206:            with server_span(
src/fastmcp/server/server.py:1343:            with server_span(
src/fastmcp/server/server.py:1508:            with server_span(
src/fastmcp/server/telemetry.py:56:def server_span(

import pytest

from fastmcp.resources import ResourceTemplate


class TestQueryParameterExtraction:
    """Test basic query parameter extraction from URIs."""

    async def test_single_query_param(self):
        """Test resource template with single query parameter."""

        def get_data(id: str, format: str = "json") -> str:

            return f"Data {id} in {format}"

        template = ResourceTemplate.from_function(
            fn=get_data,
            uri_template="data://{id}{?format}",
            name="test",
        )

        # Match without query param (uses default)
        params = template.matches("data://123")
        assert params == {"id": "123"}

        # Match with query param
        params = template.matches("data://123?format=xml")
        assert params == {"id": "123", "format": "xml"}

    async def test_multiple_query_params(self):
        """Test resourc
…[8630 chars omitted]…
"Error in prompt operations."""


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


class ClientError(Exception):
    """Error in client operations."""


class NotFoundError(Exception):
    """Object not found."""


class DisabledError(Exception):
    """Object is disabled."""


class AuthorizationError(FastMCPError):
    """Error when authorization check fails."""

sed: can't read tests/telemetry/conftest.py: No such file or directory
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_tes
…[5332 chars omitted]…
   from pydantic import AnyUrl

    from fastmcp import FastMCP
    from fastmcp.utilities.types import Audio, File, Image

    mcp = FastMCP()

    @mcp.tool
    def add(x: int, y: int) -> int:
        return x + y

    @mcp.tool
    def list_tool() -> list[str | int]:
        return ["x", 2]
tests/server/telemetry/test_provider_tracing.py:107:    async def test_delegate_span_is_child_of_server_span(

"""OpenTelemetry instrumentation for FastMCP.

This module provides native OpenTelemetry integration for FastMCP servers and clients.
It uses only the opentelemetry-api package, so telemetry is a no-op unless the user
installs an OpenTelemetry SDK and configures exporters.

Example usage with SDK:
    ```python
    from opentelemetry import trace
    from opentelemetry.sdk.trace import TracerProvider
    from opentelemetry.sdk.trace.export import ConsoleSpanExporter, SimpleSpanProcessor

    # Configure the SDK (user responsibility)
    provider = TracerProvider()
    provider.add_span_processor(SimpleSpanProcessor(ConsoleSpanExporter()))
    trace.set_tracer_provider(provider)

    # Now FastMCP will emit traces
    from fastmcp import FastMCP
    mcp = FastMCP("my-server")
    ```
"""

from typing import Any

from opentelemetry import context as otel_context
from opentelemetry impor
…[8629 chars omitted]…
ing.py:136:        assert span.attributes["rpc.method"] == "resources/read"
tests/server/telemetry/test_server_tracing.py:183:        assert span.attributes["rpc.system"] == "mcp"
tests/server/telemetry/test_server_tracing.py:184:        assert span.attributes["rpc.service"] == "test-server"
tests/server/telemetry/test_server_tracing.py:185:        assert span.attributes["rpc.method"] == "prompts/get"

src/fastmcp/telemetry.py:76:def record_span_error(span: Span, exception: BaseException) -> None:
src/fastmcp/telemetry.py:121:    "record_span_error",
src/fastmcp/client/telemetry.py:42:            span.record_exception(e)
src/fastmcp/client/telemetry.py:43:            span.set_status(Status(StatusCode.ERROR))
src/fastmcp/server/telemetry.py:94:            span.record_exception(e)
src/fastmcp/server/telemetry.py:95:            span.set_status(Status(StatusCode.ERROR))
src/fastmcp/server/telemetry.py:121:            span.record_exception(e)
src/fastmcp/server/telemetry.py:122:            span.set_status(Status(StatusCode.ERROR))
src/fastmcp/telemetry.py:78:    span.record_exception(exception)
src/fastmcp/telemetry.py:79:    span.set_status(Status(StatusCode.ERROR))
src/fastmcp/client/telemetry.py:43:            span.set_status(Status(StatusCode.ERROR))
src/fastmcp/server/telemetry.py:95:            span.set_status(Status(StatusCode.ERROR))

src/fastmcp/server/telemetry.py:122:            span.set_status(Status(StatusCode.ERROR))
src/fastmcp/telemetry.py:79:    span.set_status(Status(StatusCode.ERROR))

[('resource://sub/multi/{extra*}', 'multi')]
resource://sub/multi/abc/def {extra*}
resource://sub/multi/abc {extra*}

tests/resources/test_resource_template.py:10:from fastmcp.resources.template import build_regex, match_uri_template
tests/resources/test_resource_template.py:296:    async def test_wildcard_param_can_create_resource(self):
tests/resources/test_resource_template.py:297:        """Test that wildcard parameters are valid."""
tests/resources/test_resource_template.py:313:    async def test_wildcard_param_matches(self):
tests/resources/test_resource_template.py:326:    async def test_multiple_wildcard_params(self):
tests/resources/test_resource_template.py:327:        """Test that multiple wildcard parameters are valid."""
tests/resources/test_resource_template.py:341:    async def test_wildcard_param_with_regular_param(self):
tests/resources/test_resource_template.py:342:        """Test that a wildcard parameter can be used with a regular parameter."""
tests/resources/test_resource_templa
…[3529 chars omitted]…
s/test_resource_template_query_params.py:233:        """Test combining wildcard path params with query params."""
src/fastmcp/resources/template.py:39:def extract_query_params(uri_template: str) -> set[str]:

src/fastmcp/resources/template.py:101:        query_param_names = extract_query_params(uri_template)
src/fastmcp/resources/template.py:506:        query_params = extract_query_params(uri_template)

resource = await template.create_resource(
            "test://hello",
            {"value": "hello"},
        )

        assert isinstance(resource, FunctionResource)
        # read() returns raw CustomData object
        result = await resource.read()
        assert isinstance(result, CustomData)
        assert str(result) == "hello"

    async def test_wildcard_param_can_create_resource(self):

        """Test that wildcard parameters are valid."""

        def identity(path: str) -> str:
            return path

        template = ResourceTemplate.from_function(
            fn=identity,
            uri_template="test://{path*}.py",
            name="test",
        )

        assert await template.create_resource(
            "test://path/to/test.py",
            {"path": "path/to/test.py"},
        )

    async def test_wildcard_param_matches(self):
        def identify(pat
…[8629 chars omitted]…
"value", ["true", "True", "TRUE", "1", "yes", "Yes", "YES"]
    )
    async def test_valid_true_values(self, value: str):
        """Test that all accepted truthy string values coerce to True."""
        template = await self._make_template()

        resource = await template.create_resource(
            f"config://feature?enabled={value}",
            {"name": "feature", "enabled": value},
        )

)
    def test_match_uri_template_single_param(
        self, uri: str, expected_params: dict[str, str]
    ):
        """Test that match_uri_template uses the slash delimiter."""
        uri_template = "test://a/{x}/b"
        result = match_uri_template(uri=uri, uri_template=uri_template)
        assert result == expected_params

    @pytest.mark.parametrize(
        "uri, expected_params",
        [

            ("test://foo/123", {"x": "foo", "y": "123"}),
            ("test://bar/456", {"x": "bar", "y": "456"}),
            ("test://foo/bar", {"x": "foo", "y": "bar"}),
            ("test://foo/bar/baz", None),
            ("test://foo/email@domain.com", {"x": "foo", "y": "email@domain.com"}),
            ("test://two words/foo", {"x": "two words", "y": "foo"}),
            ("test://two.words/foo+bar", {"x": "two.words", "y": "foo+bar"}),
            (
                f"test://
…[8630 chars omitted]…
ver_span is not None, "Server should create a span"

        # Server span should have ERROR status
        assert server_span.status.status_code == StatusCode.ERROR

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

meta=item.meta,
                        )
                    )
                elif isinstance(item, BlobResourceContents):
                    contents.append(
                        ResourceContent(
                            content=base64.b64decode(item.blob),
                            mime_type=item.mimeType,
                            meta=item.meta,
                        )
                    )
                else:

                    raise ResourceError(f"Unsupported content type: {type(item)}")

            return ResourceResult(contents=contents)

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


class ProxyTemplate(ResourceTemplate):
    """A ResourceTemplate tha
…[5684 chars omitted]…
s: dict[str, Any]) -> str:
src/fastmcp/server/providers/fastmcp_provider.py:397:        original_uri = _expand_uri_template(self._original_uri_template or "", params)
src/fastmcp/server/providers/fastmcp_provider.py:427:        original_uri = _expand_uri_template(self._original_uri_template or "", params)
src/fastmcp/server/providers/fastmcp_provider.py:446:        original_uri = _expand_uri_template(

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'?

351:        self._mask_error_details: bool = (
1261:                    if self._mask_error_details:
1387:                        if self._mask_error_details:
1426:                    if self._mask_error_details:
1524:                    if self._mask_error_details:
2078:        if self._mask_error_details and not server._mask_error_details:
tests/client/client/test_error_handling.py:33:        mcp = FastMCP("TestServer", mask_error_details=True)
tests/client/client/test_error_handling.py:49:        mcp = FastMCP("TestServer", mask_error_details=True)
tests/client/client/test_error_handling.py:95:        mcp = FastMCP("TestServer", mask_error_details=True)
tests/client/client/test_error_handling.py:141:        mcp = FastMCP("TestServer", mask_error_details=True)
tests/deprecated/test_settings.py:61:            mask_error_details=True,
tests/server/mount/test_mount.py:599:    """Test t

…[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

[11/02/26 18:34:23] Error calling tool 'bad'                                    
                    ╭─────────── 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 bad:12                                                │
      

…[1744 chars omitted]…
ll', 'fastmcp.server.name': 'srv', 'mcp.session.id': '7646577d-2b63-4384-9823-292af60a4a99', 'fastmcp.component.key': 'tool:bad@', 'fastmcp.component.type': 'tool', 'fastmcp.provider.type': 'LocalProvider'}
client tools/call bad <opentelemetry.trace.status.Status object at 0x72e69f172c30> {'rpc.system': 'mcp', 'rpc.method': 'tools/call', 'mcp.method.name': 'tools/call', 'fastmcp.component.key': 'bad'}

version: Specific version to read. If None, reads highest version.
            run_middleware: If True (default), apply the middleware chain.
                Set to False when called from middleware to avoid re-applying.
            task_meta: If provided, execute as a background task and return
                CreateTaskResult. If None (default), execute synchronously and
                return ResourceResult.

        Returns:
            ResourceResult when task_meta is None.
            CreateTaskResult when task_meta is provided.

        Raises:

            NotFoundError: If resource not found or disabled
            ResourceError: If resource read fails
        """
        # Note: fn_key enrichment happens here after finding the resource/template.
        # Resources and templates use different key formats:
        # - Resources use resource.key (derived from the co
…[8628 chars omitted]…
await client.get_prompt(backend_name, arguments)
            # Convert GetPromptResult to PromptResult, preserving meta from result
            # (not the static prompt meta which includes fastmcp tags)
            # Convert PromptMessages to Messages
            messages = [
                Message(content=m.content, role=m.role) for m in result.messages
            ]
            return PromptResult(

import sys

from .function_resource import FunctionResource, resource
from .base import Resource, ResourceContent, ResourceResult
from .template import ResourceTemplate
from .types import (
    BinaryResource,
    DirectoryResource,
    FileResource,
    HttpResource,
    TextResource,
)

__all__ = [
    "BinaryResource",
    "DirectoryResource",
    "FileResource",
    "FunctionResource",
    "HttpResource",
    "Resource",
    "ResourceContent",
    "ResourceResult",
    "ResourceTemplate",
    "TextResource",
    "resource",
]

# Backward compat: resource.py was renamed to base.py to stop Pyright from resolving
# `from fastmcp.resources import resource` as the submodule instead of the decorator function.
# This shim keeps `from fastmcp.resources.resource import Resource` working at runtime.
# Safe to remove once we're confident no external code imports from the old path.
sys.modules[f"{__name__}.resource"] = sys.modules[f"{__name__}.base"]
tests/server/providers/proxy/test_proxy_server.py:502:            t for t in templates if t.uri_template == "data://user/{user_id}"

49:        result = re.sub(rf"\{{{key}\}}", str(value), result)
52:    def _expand_query_block(match: re.Match[str]) -> str:
57:                parts.append(f"{quote(name)}={quote(str(params[name]))}")
62:    result = re.sub(r"\{\?([^}]+)\}", _expand_query_block, result)

"""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 =
…[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"
        )

(status_code: opentelemetry.trace.status.StatusCode = <StatusCode.UNSET: 0>, description: str | None = None)

"""Resource template functionality."""

from __future__ import annotations

import functools
import inspect
import re
from collections.abc import Callable
from typing import TYPE_CHECKING, Any, ClassVar, overload
from urllib.parse import parse_qs, quote, unquote

import mcp.types

from mcp.types import Annotations, Icon
from pydantic.json_schema import SkipJsonSchema

if TYPE_CHECKING:
    from docket import Docket
    from docket.execution import Execution
from mcp.types import ResourceTemplate as SDKResourceTemplate
from pydantic import (
    Field,
    field_validator,
    validate_call,
)

from fastmcp.resources.base import Resource, ResourceResult
from fastmcp.server.auth.authorization import AuthCheck
from fastmcp.server.dependencies import (
    transform_context_annotations,
    without_injected_parameters,
)
from fastmcp.server.tasks.config import TaskConfig, TaskMeta
from fas
…[6166 chars omitted]…
FastMCPProviderTool:
        """Wrap a Tool to delegate execution to the server's middleware."""
22:from fastmcp.resources.template import ResourceTemplate, expand_uri_template
367:        original_uri = expand_uri_template(self._original_uri_template or "", params)
397:        original_uri = expand_uri_template(self._original_uri_template or "", params)
416:        original_uri = expand_uri_template(

pattern += f"(?P<{name}>[^/]+)"
        else:
            pattern += re.escape(part)
    try:
        return re.compile(f"^{pattern}$")
    except re.error:
        return None


class _MatchedURIParams(dict[str, str]):
    """Matched parameters retaining the concrete URI for exact round-trips."""

    def __init__(self, params: dict[str, str], uri: str, uri_template: str):
        super().__init__(params)
        self.uri = uri
        self.uri_template = uri_template
        self._snapshot = dict(params)


def match_uri_template(uri: str, uri_template: str) -> dict[str, str] | None:
    """Match URI against template and extract both path and query parameters.

    Supports RFC 6570 URI templates:
    - Path params: `{var}`, `{var*}`
    - Query params: `{?var1,var2}`
    """
    # Split URI into path and query parts
    uri_path, _, query_string = uri.partition("?")

…[2386 chars omitted]…
 quote(value, safe="/") if parameter.endswith("*") else quote(value, safe="")

    return re.sub(r"\{([^{}]+)\}", expand_path_parameter, result)


class ResourceTemplate(FastMCPComponent):
    """A template for dynamically creating resources."""

    KEY_PREFIX: ClassVar[str] = "template"

    uri_template: str = Field(
        description="URI template with parameters (e.g. weather://{city}/current)"

15:from urllib.parse import quote
338:        # quote params to ensure they are valid for the uri_template
341:            **{k: quote(v, safe="") for k, v in params.items()}

arguments: dict[str, Any],
        task_meta: None = None,
    ) -> ToolResult: ...

    @overload
    async def _run(
        self,
        arguments: dict[str, Any],
        task_meta: TaskMeta,
    ) -> mcp.types.CreateTaskResult: ...

    async def _run(

        self,
        arguments: dict[str, Any],
        task_meta: TaskMeta | None = None,
    ) -> ToolResult | mcp.types.CreateTaskResult:
        """Server entry point that handles task routing.

        This allows ANY Tool subclass to support background execution by setting
        task_config.mode to "supported" or "required". The server calls this
        method instead of run() directly.

        Args:
            arguments: Tool arguments
            task_meta: If provided, execute as background task and return
                CreateTaskResult. If None (default), execute synchronously and
                return T
…[8628 chars omitted]…
Block]
        | 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,
162:    def set_status(
565:    def set_status(

on the implementation.
        """

    @abc.abstractmethod
    def is_recording(self) -> bool:
        """Returns whether this span will be recorded.

        Returns true if this Span is active and recording information like
        events with the add_event operation and attributes using set_attribute.
        """

    @abc.abstractmethod

    def set_status(
        self,
        status: Status | StatusCode,
        description: str | None = None,
    ) -> None:
        """Sets the Status of the Span. If used, this will override the default
        Span status.
        """

    @abc.abstractmethod
    def record_exception(
        self,
        exception: BaseException,
        attributes: types.Attributes = None,
        timestamp: int | None = None,
        escaped: bool = False,
    ) -> None:
        """Records an exception as a span event."""

    def set_tp() -> None:
…[1060 chars omitted]…
r_provider(tracer_provider, log=False)
    # _TRACER_PROVIDER will have been set by one thread
    return cast("TracerProvider", _TRACER_PROVIDER)


@_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.

"""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,
    tool_name: str | None = None,
    prompt_name: 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
          
…[6592 chars omitted]…
emantic tool_error
    # type for the wrapper.
    description = str(exception)
    if isinstance(exception, ToolError) and exception.__cause__ is not None:
        description = str(exception.__cause__)
    span.set_status(Status(StatusCode.ERROR, description=description))


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

tests/client/telemetry/test_client_tracing.py:31:        span_names = [s.name for s in spans]
tests/client/telemetry/test_client_tracing.py:34:        assert "tools/call greet" in span_names
tests/client/telemetry/test_client_tracing.py:91:        span_names = [s.name for s in spans]
tests/client/telemetry/test_client_tracing.py:93:        # Client should create "resources/read data://config" span
tests/client/telemetry/test_client_tracing.py:94:        assert "resources/read data://config" in span_names
tests/client/telemetry/test_client_tracing.py:116:                if s.name.startswith("resources/read data://")
tests/client/telemetry/test_client_tracing.py:151:        span_names = [s.name for s in spans]
tests/client/telemetry/test_client_tracing.py:154:        assert "prompts/get greeting" in span_names
tests/client/telemetry/test_client_tracing.py:383:                if s.name.s
…[2154 chars omitted]…
len(spans) == 1
tests/server/telemetry/test_server_tracing.py:257:        assert len(spans) == 1

tests/server/telemetry/test_server_tracing.py:285:        assert len(spans) == 1
tests/server/telemetry/test_server_tracing.py:305:        assert len(spans) == 1
tests/server/telemetry/test_server_tracing.py:334:        assert len(spans) == 1
tests/telemetry/test_module.py:27:        assert len(spans) == 1

src/fastmcp/resources/base.py:430:    def get_span_attributes(self) -> dict[str, Any]:
src/fastmcp/resources/template.py:382:    def get_span_attributes(self) -> dict[str, Any]:
src/fastmcp/prompts/base.py:404:    def get_span_attributes(self) -> dict[str, Any]:
src/fastmcp/tools/base.py:457:    def get_span_attributes(self) -> dict[str, Any]:
        self: Client,
        name: str,
        arguments: dict[str, Any] | None = None,
        *,
        version: str | None = None,
        meta: dict[str, Any] | None = None,
        task: bool = False,
        task_id: str | None = None,

        ttl: int = 60000,
    ) -> mcp.types.GetPromptResult | PromptTask:
        """Retrieve a rendered prompt message list from the server.

        Args:
            name (str): The name of the prompt to retrieve.
            arguments (dict[str, Any] | None, optional): Arguments to pass to the prompt
…[5157 chars omitted]…
trace_context(meta)

        if isinstance(uri, str):
            uri = AnyUrl(uri)

        request = mcp.types.ReadResourceRequest(
            params=mcp.types.ReadResourceRequestParams(
                uri=uri,
                task=mcp.types.TaskMetadata(ttl=ttl),
                _meta=propagated_meta,  # type: ignore[unknown-argument]  # pydantic alias  # ty:ignore[unknown-argument]
            )

meta (dict[str, Any] | None, optional): Additional metadata to include with the request.
                This is useful for passing contextual information (like user IDs, trace IDs, or preferences)
                that shouldn't be tool arguments but may influence server-side processing. The server
                can access this via `context.request_context.meta`. Defaults to None.

        Returns:
            mcp.types.CallToolResult: The complete response object from the protocol,
                containing the tool result and any additional metadata.

        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.tr
…[6336 chars omitted]…
d_name,
        ) as span:
            span.set_attribute("fastmcp.provider.type", "ProxyProvider")
            client = await self._get_client()
            async with client:
                result = await client.get_prompt(backend_name, arguments)
            # Convert GetPromptResult to PromptResult, preserving meta from result
            # (not the static prompt meta which includes fastmcp tags)

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:143:        with client_span(
src/fastmcp/client/telemetry.py:12:def client_span(
src/fastmcp/server/providers/proxy.py:121:        with client_span(
src/fastmcp/server/providers/proxy.py:240:        with client_span(
src/fastmcp/server/providers/proxy.py:455:        with client_span(
src/fastmcp/server/server.py:1206:            with server_span(
src/fastmcp/server/server.py:1348:            with server_span(
src/fastmcp/server/server.py:1513:            with server_span(
src/fastmcp/server/telemetry.py:56:def server_span(

76-    "pyinstrument>=5.0.2",
77-    "pyperclip>=1.9.0",
78:    "pytest>=8.3.3",
79:    "pytest-asyncio>=1.2.0",
80:    "pytest-cov>=6.1.1",
81:    "pytest-env>=1.1.5",
82:    "pytest-flakefinder>=1.1.0",
83:    "pytest-httpx>=0.35.0",
84:    "pytest-report>=0.2.1",
85:    "pytest-retry>=1.7.0",
86:    "pytest-timeout>=2.4.0",
87:    "pytest-xdist>=3.6.1",

88:    "ruff>=0.12.8",
89-    "ty>=0.0.29",
90-    "prek>=0.2.12",
91-    "loq>=0.1.0a3",
92-    "opentelemetry-exporter-otlp-proto-grpc>=1.39.0",
93:    "pytest-examples>=0.0.18",
94-]
95-
--
120-
121-
122:[tool.pytest.ini_options]
123-asyncio_mode = "auto"
124-asyncio_default_fixture_loop_scope = "function"
--
130-    # Treat unawaited coroutine warnings as errors - these are almost always bugs
131-    "error:coroutine .* was never awaited:RuntimeWarning",
132:    "error:Exception ignored in.*coroutine:pytest.PytestUnraisableExcep
…[1026 chars omitted]…
orts not at the top of the file
213-"src/fastmcp/__init__.py" = ["E402"]
214:"!src/**.py" = [ # Only enforce extended ruff rules for code in src/
215-    "B",    # flake8-bugbear
216-    "C4",   # flake8-comprehensions
--
223-    "LOG",  # flake8-logging
224-    "PIE",  # flake8-pie
225:    "PLE",  # pylint-error
226-    "RSE",  # flake8-raise
227-    "RUF",  # Ruff-specific
URI template checks passed

........................................................................ [ 52%]
.................................................................        [100%]
137 passed, 1 warning in 1.15s

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

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

    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]…
ead_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, 21 passed, 1 warning in 2.26s

[11/02/26 18:50:39] Error calling tool 'failing_tool'                           
                    ╭─────────── Traceback (most recent call last) ────────────╮
                    │ /repo/src/fastmcp/server/server.py:1245 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:34                                       │
      

…[1187 chars omitted]…
/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 52, in main
AssertionError: ToolError: Error calling tool 'failing_tool': boom

(self, name: str, context: opentelemetry.context.context.Context | None = None, kind: opentelemetry.trace.SpanKind = <SpanKind.INTERNAL: 0>, attributes: collections.abc.Mapping[str, str | bool | int | float | bytes | collections.abc.Sequence['AnyValue'] | collections.abc.Mapping[str, 'AnyValue'] | None] | None = None, links: collections.abc.Sequence[opentelemetry.trace.Link] | None = None, start_time: int | None = None, record_exception: bool = True, set_status_on_exception: bool = True, end_on_exit: bool = True) -> collections.abc.Iterator['Span']

[11/02/26 18:51:36] Error calling tool 'failing_tool'                           
                    ╭─────────── Traceback (most recent call last) ────────────╮
                    │ /repo/src/fastmcp/server/server.py:1245 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:18                                       │
      

…[463 chars omitted]…
tool', 'fastmcp.provider.type': 'LocalProvider', 'error.type': 'tool_error'}
CLIENT tools/call failing_tool StatusCode.ERROR "Error calling tool 'failing_tool': Something went wrong" {'mcp.method.name': 'tools/call', 'fastmcp.component.key': 'failing_tool', 'gen_ai.tool.name': 'failing_tool', 'error.type': 'tool_error'}
missing span StatusCode.ERROR Unknown resource: 'missing://resource' NotFoundError

src/fastmcp/client/mixins/resources.py:180:        """Send a resources/read request and return the complete MCP protocol result.
src/fastmcp/client/telemetry.py:26:    with tracer.start_as_current_span(
src/fastmcp/server/telemetry.py:71:    with tracer.start_as_current_span(
src/fastmcp/server/telemetry.py:114:    with tracer.start_as_current_span(
src/fastmcp/client/telemetry.py:43:            attrs["gen_ai.tool.name"] = tool_name
src/fastmcp/client/telemetry.py:45:            attrs["gen_ai.prompt.name"] = prompt_name
src/fastmcp/server/telemetry.py:91:            attrs["gen_ai.tool.name"] = tool_name
src/fastmcp/server/telemetry.py:93:            attrs["gen_ai.prompt.name"] = prompt_name

diff --git a/src/fastmcp/client/mixins/prompts.py b/src/fastmcp/client/mixins/prompts.py
index 4b87bf2..bb32cc2 100644
--- a/src/fastmcp/client/mixins/prompts.py
+++ b/src/fastmcp/client/mixins/prompts.py
@@ -130,6 +130,7 @@ class ClientPromptsMixin:
             "prompts/get",
             name,
             session_id=self.transport.get_session_id(),
+            prompt_name=name,
         ):
             logger.debug(f"[{self.name}] called get_prompt: {name}")
 

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/r
…[8630 chars omitted]…
ype for the wrapper.
+    description = str(exception)
+    if isinstance(exception, ToolError) and exception.__cause__ is not None:
+        description = str(exception.__cause__)
+    span.set_status(Status(StatusCode.ERROR, description=description))
 
 
 def extract_trace_context(meta: dict[str, Any] | None) -> Context:
bash: line 821: ruff: command not found
bash: line 821: ruff: command not found

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

"""Client error handling tests."""

import mcp.types
import pytest
from mcp.types import TextContent
from pydantic import AnyUrl

from fastmcp.client import Client
from fastmcp.client.mixins.tools import _parse_call_tool_result
from fastmcp.client.transports import FastMCPTransport
from fastmcp.exceptions import ResourceError, ToolError
from fastmcp.server.server import FastMCP

class TestErrorHandling:
    async def test_general_tool_exceptions_are_not_masked_by_default(self):
        mcp = FastMCP("TestServer")

        @mcp.tool
        def error_tool():
            raise ValueError("This is a test error (abc)")

        client = Client(transport=FastMCPTransport(mcp))

        async with client:
            result = await client.call_tool_mcp("error_tool", {})
            assert result.isError
            assert isinstance(result.content[0], TextContent)
            assert "test 
…[8629 chars omitted]…
            ) from e
                    # Standard masking logic
                    if self._mask_error_details:
                        raise ToolError(f"Error calling tool {name!r}") from e
                    raise ToolError(f"Error calling tool {name!r}: {e}") from e

    @overload
    async def read_resource(
        self,
        uri: str,
        *,
        version: VersionSpec | None = None,

unused-ignore-comment = "warn"

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

[tool.ruff.lint]
fixable = ["ALL"]
ignore = [
    "COM812",
    "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
    "FLY",  # flynt: Static string joins that should be f-strings
    "I",    # isort: Import sorting
    "INP",  # flake8-no-pep420: Require __init__.py in namespace packages
    "ISC",  # flake8-implicit-str-concat: Prevent accidental string 
…[3991 chars omitted]…
[^}]+)\}", expand_query_block, uri_template)

    def expand_path_parameter(match: re.Match[str]) -> str:
        parameter = match.group(1)
        name = parameter[:-1] if parameter.endswith("*") else parameter
        if name not in params:
            return match.group(0)
        value = str(params[name])
        return quote(value, safe="/") if parameter.endswith("*") else quote(value, safe="")

src/fastmcp/resources/template.py:190:151         return f"{self.__class__.__name__}(uri_template={self.uri_template!r}, name={self.name!r}, description={self.description!r}, tags={self.tags})"
src/fastmcp/resources/template.py:301:95         # Call resource.read() not resource._read() to avoid task routing on ephemeral resource
src/fastmcp/resources/template.py:331:100             _meta=overrides.get(  # type: ignore[call-arg]  # _meta is Pydantic alias for meta field
src/fastmcp/resources/template.py:339:94         # Note: This creates a simple ResourceTemplate instance. For function-based templates,
src/fastmcp/resources/template.py:482:90                                 f"Invalid boolean value for {param_name}: {param_value!r}"
src/fastmcp/resources/template.py:591:119                     f"Query parameters {invalid_query_params} must be optional function parameters with default v
…[8629 chars omitted]…
er/server.py:2140:89           Example: If server has a prompt named "weather_prompt", it will be available as
src/fastmcp/server/server.py:2198: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:2385:89     use `FastMCPProxy` or `ProxyProvider` directly from `fastmcp.server.providers.proxy`.

113:    def get_multi_template(id: str) -> ResourceResult:
114:        """Resource template that returns multiple content items."""
465:        Test that a resource defined on the proxy can overwrite the proxied resource with the same URI.
495:    async def test_get_resource_templates(self, proxy_server):
496:        templates = await proxy_server.list_resource_templates()
497:        assert [t.name for t in templates] == Contains("get_user")
499:    async def test_get_resource_templates_meta(self, proxy_server):
500:        templates = await proxy_server.list_resource_templates()
501:        get_user_template = next(
502:            t for t in templates if t.uri_template == "data://user/{user_id}"
504:        assert get_user_template.title == "User Template"
505:        assert get_user_template.meta == {"fastmcp": {"tags": ["users"]}}

506:        assert get_user_template.icons == [
5
…[5328 chars omitted]…
xied, TextResourceContents)
            assert original.text == proxied.text, f"Content {i} text mismatch"
            assert original.mimeType == proxied.mimeType, (
                f"Content {i} mimeType mismatch"
            )
15:from urllib.parse import quote
341:        # quote params to ensure they are valid for the uri_template
344:            **{k: quote(v, safe="") for k, v in params.items()}

template expansion and roundtrip checks pass

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/resources/__init__.py
 M src/fastmcp/resources/template.py
 M src/fastmcp/server/providers/fastmcp_provider.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
........................................................................ [ 33%]

........................................................................ [ 66%]
........................................................................ [ 99%]
..                                                                       [100%]
218 passed, 16 warnings in 3.95s

docs/development/v3-notes/v3-features.mdx:1162:### OpenTelemetry Tracing
docs/development/v3-notes/v3-features.mdx:1171:# Tracing is passive - configure an OTel SDK to export spans
docs/development/v3-notes/v3-features.mdx:1172:from opentelemetry import trace
docs/development/v3-notes/v3-features.mdx:1173:from opentelemetry.sdk.trace import TracerProvider
docs/development/v3-notes/v3-features.mdx:1174:from opentelemetry.sdk.trace.export import BatchSpanProcessor
docs/development/v3-notes/v3-features.mdx:1175:from opentelemetry.exporter.otlp.proto.grpc.trace_exporter import OTLPSpanExporter
docs/development/v3-notes/v3-features.mdx:1186:Documentation: [Telemetry](/servers/telemetry)
docs/docs.json:126:                      "servers/telemetry",
docs/python-sdk/fastmcp-client-telemetry.mdx:2:title: telemetry
docs/python-sdk/fastmcp-client-telemetry.mdx:3:sidebarTitle: telemetry
docs/pyth
…[7779 chars omitted]…

r
tests/server/telemetry/test_server_tracing.py:9:from opentelemetry.trace import SpanKind, StatusCode
tests/server/telemetry/test_server_tracing.py:16:class TestToolTracing:
tests/server/telemetry/test_server_tracing.py:81:class TestResourceTracing:
tests/server/telemetry/test_server_tracing.py:160:class TestPromptTracing:
tests/server/telemetry/__init__.py:1:"""Tests for FastMCP server telemetry."""

src/fastmcp/client/mixins/prompts.py             |  1 +
 src/fastmcp/client/mixins/resources.py           |  2 +-
 src/fastmcp/client/mixins/tools.py               | 15 +++++-
 src/fastmcp/client/telemetry.py                  | 23 ++++++---
 src/fastmcp/resources/__init__.py                |  3 +-
 src/fastmcp/resources/template.py                | 66 +++++++++++++++++++++---
 src/fastmcp/server/providers/fastmcp_provider.py | 38 ++------------
 src/fastmcp/server/providers/proxy.py            | 12 +++--
 src/fastmcp/server/server.py                     | 16 ++++--
 src/fastmcp/server/telemetry.py                  | 28 ++++++----
 src/fastmcp/telemetry.py                         | 20 ++++++-
 11 files changed, 154 insertions(+), 70 deletions(-)

diff --git a/src/fastmcp/resources/__init__.py b/src/fastmcp/resources/__init__.py
index cbcfff7..0bd5551 100644
--- a/src/fastmcp/resources/
…[7550 chars omitted]…
ne
@@ -443,7 +413,7 @@ class FastMCPProviderResourceTemplate(ResourceTemplate):
         This method is called by Docket during background task execution.
         """
         # Expand the original template with arguments to get internal URI
-        original_uri = _expand_uri_template(
+        original_uri = expand_uri_template(
             self._original_uri_template or "", arguments
         )

pyproject.toml:12:    "opentelemetry-api>=1.20.0",
uv.lock:839:    { name = "opentelemetry-api" },
uv.lock:925:    { name = "opentelemetry-api", specifier = ">=1.20.0" },
uv.lock:1727:name = "opentelemetry-api"
uv.lock:1758:    { name = "opentelemetry-api" },
uv.lock:1786:    { name = "opentelemetry-api" },
uv.lock:1800:    { name = "opentelemetry-api" },
uv.lock:2297:    { name = "opentelemetry-api" },
src/fastmcp/client/telemetry.py:30:        set_status_on_exception=False,
src/fastmcp/server/telemetry.py:76:        set_status_on_exception=False,
src/fastmcp/server/telemetry.py:117:        set_status_on_exception=False,

## Tracing

FastMCP creates spans for all MCP operations, providing end-to-end visibility into request handling.

### Server Spans

The server creates spans for each operation using [MCP semantic conventions](https://opentelemetry.io/docs/specs/semconv/gen-ai/mcp/):

| Span Name | Description |
|-----------|-------------|
| `tools/call {name}` | Tool execution (e.g., `tools/call get_weather`) |
| `resources/read {uri}` | Resource read (e.g., `resources/read config://database`) |

| `prompts/get {name}` | Prompt render (e.g., `prompts/get greeting`) |

For mounted servers, an additional `delegate {name}` span shows the delegation to the child server.

### Client Spans

The FastMCP client creates spans for outgoing requests with the same naming pattern (`tools/call {name}`, `resources/read {uri}`, `prompts/get {name}`).

### Span Hierarchy

Spans form a hierarchy showing the request flo
…[1279 chars omitted]…
.name` | The MCP method being called (`tools/call`, `resources/read`, `prompts/get`) |
| `mcp.session.id` | Session identifier for the MCP connection |
| `mcp.resource.uri` | The resource URI (for resource operations) |

### Auth Attributes

Standard [identity attributes](https://opentelemetry.io/docs/specs/semconv/attributes-registry/enduser/):

| Attribute | Description |
|-----------|-------------|

....F....                                                                [100%]
=================================== FAILURES ===================================
________ TestResourceTracing.test_read_nonexistent_resource_sets_error _________

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

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

        with pytest.raises(NotFoundError):
            await mcp.read_resource("nonexistent://resource")
    
        spans = trace_exporter.get_finished_spans()
        assert len(spans) == 1
    
        span = spans[0]
>       assert span.name == "resources/read nonexistent:/
…[80 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, 8 passed, 1 warning in 1.62s

import inspect
import json
import time
from typing import Any, cast
from unittest.mock import AsyncMock, patch

import mcp.types as mcp_types
import pytest
from anyio import create_task_group
from dirty_equals import Contains
from mcp import McpError
from mcp.types import Icon, TextContent, TextResourceContents

from pydantic import AnyUrl

from fastmcp import FastMCP
from fastmcp.client import Client
from fastmcp.client.transports import FastMCPTransport, StreamableHttpTransport
from fastmcp.exceptions import ToolError
from fastmcp.resources import ResourceContent, ResourceResult
from fastmcp.server import create_proxy
from fastmcp.server.providers.proxy import (
    FastMCPProxy,
    ProxyClient,
    ProxyProvider,
)
from fastmcp.tools.base import ToolResult
from fastmcp.tools.tool_transform import (
    ToolTransformConfig,
)

USERS = [
    {"id": "1", "name": "Alice", "active": Tru
…[7420 chars omitted]…
 ProxyProvider(
tests/server/providers/proxy/test_proxy_server.py:825:        provider = ProxyProvider(
tests/server/providers/proxy/test_proxy_server.py:839:        provider = ProxyProvider(
tests/server/providers/proxy/test_proxy_server.py:859:        provider = ProxyProvider(
tests/server/providers/proxy/test_proxy_server.py:880:            p for p in proxy.providers if isinstance(p, ProxyProvider)

"""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

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_NOT_FOUND,
    BlobResourceContents,
    ElicitRequestFormParams,
    TextResourceContents,
)
from pydantic.networks import AnyUrl

from fastmcp.client.client import Client
…[2340 chars omitted]…
th(f": {cause_description}"):
            description = cause_description
    span.set_status(Status(StatusCode.ERROR, description=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.

"""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:
   
…[1751 chars omitted]…
tx).get_span_context()
        assert not span_ctx.is_valid
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

a/b a/b
foo%2Fbar foo%252Fbar
x y x%20y
a?b&c a%3Fb%26c

test://a%2Fb {'x': 'a/b'} test://a%2Fb test://a%2Fb
test://a%2Fb/c {'p': 'a/b/c'} test://a%2Fb/c test://a/b/c

from pydantic.networks import AnyUrl

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
from fastmcp.prompts import Message, Prompt, PromptResult
from fastmcp.prompts.base import PromptArgument

from fastmcp.resources import Resource, ResourceTemplate
from fastmcp.resources.base import ResourceContent, ResourceResult
from fastmcp.resources.template import expand_uri_template
from fastmcp.server.context import Context
from fastmcp.server.dependencies import get_context
from fastmcp.server.providers.base import Provider
from fastmcp.server.serve
…[1461 chars omitted]…
 opentelemetry import propagate, trace
from opentelemetry.context import Context
from opentelemetry.trace import Span, Status, StatusCode, Tracer
from opentelemetry.trace import get_tracer as otel_get_tracer

from fastmcp.exceptions import ToolError

INSTRUMENTATION_NAME = "fastmcp"

TRACE_PARENT_KEY = "traceparent"
TRACE_STATE_KEY = "tracestate"


def get_tracer(version: str | None = None) -> Tracer:

FastMCP creates spans for all MCP operations, providing end-to-end visibility into request handling.

### Server Spans

The server creates spans for each operation using [MCP semantic conventions](https://opentelemetry.io/docs/specs/semconv/gen-ai/mcp/):

| Span Name | Description |
|-----------|-------------|
| `tools/call {name}` | Tool execution (e.g., `tools/call get_weather`) |
| `resources/read` | Resource read; the URI is stored in `mcp.resource.uri` |
| `prompts/get {name}` | Prompt render (e.g., `prompts/get greeting`) |

For mounted servers, an additional `delegate {name}` span shows the delegation to the child server.

### Client Spans

The FastMCP client creates spans for outgoing requests with the same naming pattern (`tools/call {name}`, `resources/read`, `prompts/get {name}`).

### Span Hierarchy

Spans form a hierarchy showing the request flow. For mounted servers:

``
…[955 chars omitted]…
rompts/get`) |
| `mcp.session.id` | Session identifier for the MCP connection |
| `mcp.resource.uri` | The resource URI (for resource operations) |
| `gen_ai.tool.name` | The tool name (for tool operations) |
| `gen_ai.prompt.name` | The prompt name (for prompt operations) |

### Auth Attributes

Standard [identity attributes](https://opentelemetry.io/docs/specs/semconv/attributes-registry/enduser/):

def make_key(cls, identifier: str) -> str:
        """Construct the lookup key for this component type.

        Args:
            identifier: The raw identifier (name for tools/prompts, uri for resources)

        Returns:
            A prefixed key like "tool:name" or "resource:uri"
        """
        if cls.KEY_PREFIX:
            return f"{cls.KEY_PREFIX}:{identifier}"
        return identifier

    @property
    def key(self) -> str:
        """The globally unique lookup key for this component.

        Format: "{key_prefix}:{identifier}@{version}" or "{key_prefix}:{identifier}@"
        e.g. "tool:my_tool@v2", "tool:my_tool@", "resource:file://x.txt@"

        The @ suffix is ALWAYS present to enable unambiguous parsing of keys
        (URIs may contain @ characters, so we always include the delimiter).

        Subclasses should override this to use their specific identifi
…[3540 chars omitted]…
: Any, serializer: ToolResultSerializerType | None = None
) -> str:
    if serializer is not None:
        try:
            return serializer(result)
        except Exception as e:
            logger.warning(
                "Error serializing tool result: %s",
                e,
                exc_info=True,
            )

    return default_serializer(result)


def _convert_to_single_content_block(

Traceback (most recent call last):
  File "<stdin>", line 15, in <module>
AssertionError
195:### RPC Semantic Conventions
201:| `rpc.system` | `"mcp"` |
def risky_operation() -> str:
    raise ValueError("Something went wrong")

# The span will have:
# - status = ERROR
# - exception event with stack trace
```

## Attributes Reference

### RPC Semantic Conventions

Standard [RPC semantic conventions](https://opentelemetry.io/docs/specs/semconv/rpc/rpc-spans/):

| Attribute | Value |
|-----------|-------|
| `rpc.system` | `"mcp"` |
| `rpc.service` | Server name |
| `rpc.method` | MCP protocol method |

### MCP Semantic Conventions

FastMCP implements the [OpenTelemetry MCP semantic conventions](https://opentelemetry.io/docs/specs/semconv/gen-ai/mcp/):

| Attribute | Description |
|-----------|-------------|
| `mcp.method.name` | The MCP method being called (`tools/call`, `resources/read`, `prompts/get`) |
| `mcp.session.id` | Session identifier for the MCP connection |
| `mcp.resource.uri` | The resource URI (for resource operations) |
| `gen_ai.tool.name` | The tool name (for tool operations) |
| `gen_ai.prompt.name` | The prompt name (for prompt operations) |

[11/02/26 19:10:33] Error calling tool 'failing_tool'                           
                    ╭─────────── Traceback (most recent call last) ────────────╮
                    │ /repo/src/fastmcp/server/server.py:1245 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:21                                       │
      

…[372 chars omitted]…
rces/read', <StatusCode.UNSET: 0>, None), ('INTERNAL', 'delegate resource://multi/abc', <StatusCode.UNSET: 0>, None), ('SERVER', 'resources/read', <StatusCode.UNSET: 0>, None), ('SERVER', 'tools/call failing_tool', <StatusCode.ERROR: 2>, 'boom'), ('CLIENT', 'tools/call failing_tool', <StatusCode.ERROR: 2>, "Error calling tool 'failing_tool': boom")]
All local telemetry and template smoke checks passed

Simple and wildcard path parameters are substituted in place. Wildcard
    values are percent-encoded as path segments, except wildcard values where
    slashes are left unescaped to represent path separators. Query parameters
    use RFC 6570 `{?name,...}` syntax; only parameters present in ``params``
    are emitted. When passed the mapping returned by ``match_uri_template``,
    the exact original URI is preserved, including details omitted by matching
    such as percent-escape casing or unrelated query parameters.
    """
    if (
        isinstance(params, _MatchedURIParams)
        and params.uri_template == uri_template
        and params == params._snapshot

    ):
        return params.uri

    def expand_query_block(match: re.Match[str]) -> str:
        names = {name.strip() for name in match.group(1).split(",")}
        # Preserve the parameter mapping's order. In parti
…[2074 chars omitted]…
Auth scopes (when authenticated) |

### FastMCP Custom Attributes

All custom attributes use the `fastmcp.` prefix for features unique to FastMCP:

| Attribute | Description |
|-----------|-------------|
| `fastmcp.server.name` | Server name |
| `fastmcp.component.type` | `tool`, `resource`, `prompt`, or `resource_template` |
| `fastmcp.component.key` | Full component identifier (e.g., `tool:greet`) |

McpError "Resource not found: Unknown resource: 'missing://resource'"
SERVER resources/read {'mcp.method.name': 'resources/read', 'fastmcp.server.name': 'x', 'fastmcp.component.type': 'resource', 'fastmcp.component.key': 'missing://resource', 'mcp.session.id': 'b27c82cf-9cf0-4903-b9f7-febbf6901c65', 'mcp.resource.uri': 'missing://resource', 'error.type': 'NotFoundError'} StatusCode.ERROR "Unknown resource: 'missing://resource'"
CLIENT resources/read {'mcp.method.name': 'resources/read', 'fastmcp.component.key': 'missing://resource', 'mcp.resource.uri': 'missing://resource', 'error.type': 'McpError'} StatusCode.ERROR "Resource not found: Unknown resource: 'missing://resource'"

docs/servers/telemetry.mdx                       | 19 +++----
 src/fastmcp/client/mixins/prompts.py             |  1 +
 src/fastmcp/client/mixins/resources.py           |  2 +-
 src/fastmcp/client/mixins/tools.py               | 15 +++++-
 src/fastmcp/client/telemetry.py                  | 23 ++++++---
 src/fastmcp/resources/__init__.py                |  3 +-
 src/fastmcp/resources/template.py                | 66 +++++++++++++++++++++---
 src/fastmcp/server/providers/fastmcp_provider.py | 38 ++------------
 src/fastmcp/server/providers/proxy.py            | 19 ++++---
 src/fastmcp/server/server.py                     | 16 ++++--
 src/fastmcp/server/telemetry.py                  | 28 ++++++----
 src/fastmcp/telemetry.py                         | 26 +++++++++-

 12 files changed, 168 insertions(+), 88 deletions(-)
diff --git a/docs/servers/telemetry.mdx b/docs/servers/telemetry.mdx
inde
…[6703 chars omitted]…
 is not None
+        and description.startswith("Error calling tool ")
+    ):
+        cause_description = str(exception.__cause__)
+        if cause_description and description.endswith(f": {cause_description}"):
+            description = cause_description
+    span.set_status(Status(StatusCode.ERROR, description=description))
 
 
 def extract_trace_context(meta: dict[str, Any] | None) -> Context:

........................................................................ [ 52%]
.................................................................        [100%]
137 passed, 1 warning in 1.06s

[('SERVER', 'tools/call greet', 'greet', None), ('CLIENT', 'tools/call greet', 'greet', None), ('CLIENT', 'tools/call greet', 'greet', None), ('SERVER', 'tools/call greet', 'greet', None), ('CLIENT', 'tools/call greet', 'greet', None), ('SERVER', 'prompts/get welcome', None, 'welcome'), ('CLIENT', 'prompts/get welcome', None, 'welcome'), ('CLIENT', 'prompts/get welcome', None, 'welcome'), ('SERVER', 'prompts/get welcome', None, 'welcome'), ('CLIENT', 'prompts/get welcome', None, 'welcome')]

[11/02/26 19:17:08] Error calling tool 'fail'                                   
                    ╭─────────── Traceback (most recent call last) ────────────╮
                    │ /repo/src/fastmcp/server/server.py:1245 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: boom                                            
client failed tool span status: ERROR Error calling tool 'fail': boom tool_error

final reproducer and URI expansion checks pass
 M docs/servers/telemetry.mdx
 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/resources/__init__.py
 M src/fastmcp/resources/template.py
 M src/fastmcp/server/providers/fastmcp_provider.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

M docs/servers/telemetry.mdx
 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/resources/__init__.py
 M src/fastmcp/resources/template.py
 M src/fastmcp/server/providers/fastmcp_provider.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

./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:128:        assert client_span.attributes["rpc.system"] == "mcp"
./tests/client/telemetry/test_client_tracing.py:129:        assert client_span.attributes["rpc.method"] == "resources/read"
./tests/client/telemetry/test_client_tracing.py:187:        assert client_span.attributes["rpc.system"] == "mcp"
./tests/client/telemetry/test_client_tracing.py:188:        assert client_span.attributes["rpc.method"] == "prompts/get"
./tests/client/telemetry/test_client_tracing.py:245:        assert client_span.attributes["rpc.method"] == "tools/call"
./tests/server/telemetry/test_server_tracing.py:37:        assert span.attr
…[1557 chars omitted]…
ompts.py
1	1	src/fastmcp/client/mixins/resources.py
14	1	src/fastmcp/client/mixins/tools.py

15	8	src/fastmcp/client/telemetry.py
2	1	src/fastmcp/resources/__init__.py
59	5	src/fastmcp/resources/template.py
4	34	src/fastmcp/server/providers/fastmcp_provider.py
11	8	src/fastmcp/server/providers/proxy.py
13	3	src/fastmcp/server/server.py
17	11	src/fastmcp/server/telemetry.py
24	2	src/fastmcp/telemetry.py

........................................................................ [ 30%]
........................................................................ [ 61%]
........................................................................ [ 92%]
..................                                                       [100%]
234 passed, 16 warnings in 3.69s

submitted.