prefecthq-fastmcp-3899-3889

AGENTS.md
CLAUDE.md
CODE_OF_CONDUCT.md
CONTRIBUTING.md
LICENSE
README.md
SECURITY.md
docs
examples
justfile
logo.py
loq.toml

pyproject.toml
scripts
skills
src
tests
uv.lock
v3-notes
ls: cannot access 'fastmcp/resources': No such file or directory
ls: cannot access 'fastmcp/client': No such file or directory
ls: cannot access 'fastmcp/server': No such file or directory

src/fastmcp/client:
__init__.py
auth
client.py
elicitation.py
logging.py
messages.py
mixins
oauth_callback.py
progress.py
roots.py
sampling

tasks.py
telemetry.py
transports

src/fastmcp/resources:
__init__.py
base.py
function_resource.py
template.py
types.py

src/fastmcp/server:
__init__.py
app.py
apps.py
auth
context.py
dependencies.py
elicitation.py
event_store.py
http.py
lifespan.py
low_level.py
middleware
mixins
openapi
providers
proxy.py
sampling
server.py
tasks
telemetry.py
transforms
src/fastmcp/resources/template.py:79:def match_uri_template(uri: str, uri_template: str) -> dict[str, str] | None:
src/fastmcp/resources/template.py:180:        return match_uri_template(uri, self.uri_template)

"""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, 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 fastmcp.ut
…[5470 chars omitted]…
    This is used in two contexts:
        1. In _read() to convert user function return values to ResourceResult
        2. In tasks_result_handler() to convert Docket task results to ResourceResult

        Handles ResourceResult passthrough and converts raw values using
        ResourceResult's normalization.
        """
        if isinstance(raw_value, ResourceResult):
            return raw_value

"""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, Status, StatusCode

from fastmcp.telemetry import extract_trace_context, get_tracer

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
…[4002 chars omitted]…
_key,
        }
        if session_id:
            attrs["mcp.session.id"] = session_id
        if resource_uri:
            attrs["mcp.resource.uri"] = resource_uri
        span.set_attributes(attrs)
        try:
            yield span
        except Exception as e:
            span.record_exception(e)
            span.set_status(Status(StatusCode.ERROR))
            raise


__all__ = ["client_span"]

src/fastmcp/client/mixins/prompts.py:17:from fastmcp.client.telemetry import client_span
src/fastmcp/client/mixins/prompts.py:128:        with client_span(
src/fastmcp/client/mixins/resources.py:16:from fastmcp.client.telemetry import client_span
src/fastmcp/client/mixins/resources.py:195:        with client_span(
src/fastmcp/client/mixins/tools.py:18:from fastmcp.client.telemetry import client_span
src/fastmcp/client/mixins/tools.py:142:        with client_span(
src/fastmcp/server/providers/proxy.py:35:from fastmcp.client.telemetry import client_span
src/fastmcp/server/providers/proxy.py:121:        with client_span(
src/fastmcp/server/providers/proxy.py:237:        with client_span(
src/fastmcp/server/providers/proxy.py:452:        with client_span(
src/fastmcp/server/server.py:74:from fastmcp.server.telemetry import server_span
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(

raise RuntimeError(
                f"[{self.name}] Reached auto-pagination limit"
                f" ({max_pages} pages) for list_tools."
                " Use list_tools_mcp() with cursor for manual pagination,"
                " or increase max_pages."
            )

        return all_tools

    # --- Call Tool ---

    async def call_tool_mcp(

        self: Client,
        name: str,
        arguments: dict[str, Any],
        progress_handler: ProgressHandler | None = None,
        timeout: datetime.timedelta | float | int | None = None,
        meta: dict[str, Any] | None = None,
    ) -> mcp.types.CallToolResult:
        """Send a tools/call request and return the complete MCP protocol result.

        This method returns the raw CallToolResult object, which includes an isError flag
        and other metadata. It does not raise an exception if the tool call results 
…[6955 chars omitted]…
send_request(
                        request=request,  # type: ignore[arg-type]  # ty:ignore[invalid-argument-type]
                        result_type=mcp.types.ReadResourceResult,
                    )
                )
            else:
                result = await self._await_with_session_monitoring(
                    self.session.read_resource(uri)
                )
            return result

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

        )

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


# -----------------------------------------------------------------------------
# ProxyProvider
# -----------------------------------------------------------------------------

#   2. Display-name path — everything else. Goes through normal
        #      `get_tool` aggregation/transforms. Address is determined
        #      after resolution by walking the registry.
        async with fastmcp.server.context.Context(fastmcp=self) as ctx:
            if run_middleware:
                mw_context = MiddlewareContext[CallToolRequestParams](
                    message=mcp.types.CallToolRequestParams(
                        name=name, arguments=arguments or {}
                    ),
                    source="client",
                    type="request",
                    method="tools/call",

                    fastmcp_context=ctx,
                )
                return await self._run_middleware(
                    context=mw_context,
                    call_next=lambda context: self.call_tool(
                        context.message.name,
     
…[8628 chars omitted]…
 versions. If specified, removes only that version.

        Raises:
            NotFoundError: If no matching tool is found.
        """
        if fastmcp.settings.deprecation_warnings:
            warnings.warn(
                "remove_tool() is deprecated. Use "
                "mcp.local_provider.remove_tool(name) instead.",
                FastMCPDeprecationWarning,
                stacklevel=2,

__init__.py
apps
cli
client
conformance
conftest.py
contrib
deprecated
docs
experimental
fs
integration_tests

prompts
resources
server
telemetry
test_apps.py
test_apps_prefab.py
test_fastmcp_app.py
test_json_schema_generation.py
test_mcp_config.py
tools
utilities
tests/server/middleware/test_error_handling.py

tests/resources:
__init__.py
test_file_resources.py
test_function_resources.py
test_resource_template.py
test_resource_template_meta.py
test_resource_template_query_params.py
test_resources.py
test_standalone_decorator.py

tests/telemetry:
__init__.py

test_module.py

83 tests/telemetry/test_module.py
"""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


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

src/fastmcp/server/providers/base.py:365:            matching = [t for t in matching if version.matches(t.version)]
src/fastmcp/server/providers/base.py:396:            matching = [r for r in matching if version.matches(r.version)]
src/fastmcp/server/providers/base.py:425:        matching = [t for t in templates if t.matches(uri) is not None]
src/fastmcp/server/providers/base.py:427:            matching = [t for t in matching if version.matches(t.version)]
src/fastmcp/server/providers/base.py:458:            matching = [p for p in matching if version.matches(p.version)]
src/fastmcp/server/providers/fastmcp_provider.py:39:def _expand_uri_template(template: str, params: dict[str, Any]) -> str:
src/fastmcp/server/providers/fastmcp_provider.py:355:    _original_uri_template: str | None = None
src/fastmcp/server/providers/fastmcp_provider.py:360:        original_uri_template: str,
src/fast
…[2126 chars omitted]…
rams to ensure they are valid for the uri_template
src/fastmcp/server/providers/proxy.py:339:        backend_template = self._backend_uri_template or self.uri_template

src/fastmcp/server/providers/proxy.py:394:            "fastmcp.proxy.backend_uri_template": self._backend_uri_template,
src/fastmcp/server/providers/proxy.py:595:            matching = [t for t in matching if version.matches(t.version)]

"""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
…[7424 chars omitted]…
-------------------------------------------------------------
# FastMCPProvider
# -----------------------------------------------------------------------------


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

    This provider enables mounting one FastMCP server onto another, exposing
    the mounted server's tools, resources, and prompts through the parent
    server.

fastmcp_context=ctx,
                )
                return await self._run_middleware(
                    context=mw_context,
                    call_next=lambda context: self.read_resource(
                        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",
                self.name,
                "resource",
                uri,
                resource_uri=uri,
            ) as span:
                # Intercept synthetic Prefab renderer URIs before normal
                # resolution. The resource isn't stored anywhere 
…[82 chars omitted]…
      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())
27:class ToolError(FastMCPError):
43:class NotFoundError(Exception):

Traceback (most recent call last):
  File "<string>", line 11, in <module>
  File "/repo/src/fastmcp/resources/template.py", line 141, in expand_uri_template
    if name not in params:
       ^^^^^^^^^^^^^^^^^^
TypeError: argument of type 'NoneType' is not iterable
test://foo/bar
test://a/mid/b
test://a/b/c
test://x/y/mid/p/q
test://data
test://data?verbose=1

test://{x}/{y}
resource://multi/{extra*} {'extra': 'abc/def'} True

{'x': 'foo', 'y': 'bar'}
{'x': 'foo', 'y': 'bar'}

{'verbose': 'true', 'format': 'json'}
['test://data', '{?format,verbose}', '']

'resource://multi/{extra*}' 'resource://multi/abc/def' {'extra': 'abc/def'}
True
'test://{x}/{y}?a=1' 'test://foo/bar?a=1' None
'test://data{?format,verbose}' 'test://data?format=json&verbose=true' {'format': 'json', 'verbose': 'true'}
True

68:    Automatically records any exception on the span and sets error status.
89:            attrs["gen_ai.tool.name"] = tool_name
91:            attrs["gen_ai.prompt.name"] = prompt_name
98:            from fastmcp.client.telemetry import _error_attributes
100:            span.set_attributes(_error_attributes(e))
113:    Automatically records any exception on the span and sets error status.

24:from typing import Any
26:from opentelemetry import context as otel_context
27:from opentelemetry import propagate, trace
28:from opentelemetry.context import Context
29:from opentelemetry.trace import Span, Status, StatusCode, Tracer
30:from opentelemetry.trace import get_tracer as otel_get_tracer
38:def get_tracer(version: str | None = None) -> Tracer:
50:def inject_trace_context(
76:def record_span_error(span: Span, exception: BaseException) -> None:
82:def extract_trace_context(meta: dict[str, Any] | None) -> Context:

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."""
    span.record_exception(exception)
    span.set_status(Status(StatusCode.ERROR))


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.

    Args:
        meta: The meta dict from an MCP request (ctx.request_context.meta)

    Returns:
        An OpenTelemetry Context with the extracted trace context,
        or the current context if no trace context found or already in a trace
    """
    # Don't override existing trace context (e.g., from HTTP propagation)

grep: src/fastmcp/__pycache__/telemetry.cpython-312.pyc: binary file matches

1206:            with server_span(
1348:            with server_span(
1513:            with server_span(

16:from urllib.parse import quote

16:from urllib.parse import quote

    When `create_resource()` is called, this template creates a
    FastMCPProviderResource that will invoke the wrapped server's middleware
    when read.
    """

    _server: Any = None  # FastMCP, but Any to avoid circular import
    _original_uri_template: str | None = None

    def __init__(
        self,

        server: Any,
        original_uri_template: str,
        **kwargs: Any,
    ):
        super().__init__(**kwargs)

abc/def -> abc/def
abc -> abc
two-wildcard -> x/y/mid/p/q
tool error: ToolError Unknown tool: 'failing_tool'

[Tool(name='sub_failing_tool', title=None, description=None, inputSchema={'additionalProperties': False, 'properties': {}, 'type': 'object'}, outputSchema={'description': 'Generic wrapper for non-object return types.', 'properties': {'result': {'type': 'string'}}, 'required': ['result'], 'type': 'object', 'x-fastmcp-wrap-result': True}, icons=None, annotations=None, meta={'fastmcp': {'tags': []}}, execution=None)]

[10/01/26 19:28:59] 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:441 in validate_python                          │
                    │                                                          │
      

…[5204 chars omitted]…
^^^^^^^^^^^^^^^^^^^^^^^
  File "/repo/src/fastmcp/client/client.py", line 733, in _await_with_session_monitoring
    return call_task.result()
           ^^^^^^^^^^^^^^^^^^
  File "/usr/local/lib/python3.12/site-packages/mcp/shared/session.py", line 306, in send_request
    raise McpError(response_or_error.error)
mcp.shared.exceptions.McpError: Resource not found: Unknown resource: 'res://sub/missing'

raised: Error calling tool 'failing_tool': boom
missing: McpError
tools/call failing_tool | {'mcp.method.name': 'tools/call', 'fastmcp.server.name': 'sub', 'mcp.session.id': '15ce7e9b-d279-4d8b-a32e-60c7c64341cc', 'gen_ai.tool.name': 'failing_tool', 'fastmcp.component.key': 'tool:failing_tool@', 'fastmcp.component.type': 'tool', 'fastmcp.provider.type': 'LocalProvider', 'error.type': 'tool_error'}
delegate failing_tool | {'fastmcp.provider.type': 'FastMCPProvider', 'fastmcp.component.key': 'failing_tool'}
tools/call sub_failing_tool | {'mcp.method.name': 'tools/call', 'fastmcp.server.name': 'main', 'mcp.session.id': '15ce7e9b-d279-4d8b-a32e-60c7c64341cc', 'gen_ai.tool.name': 'sub_failing_tool', 'fastmcp.component.key': 'tool:sub_failing_tool@', 'fastmcp.component.type': 'tool', 'fastmcp.provider.type': 'FastMCPProvider', 'fastmcp.delegate.original_name': 'failing_tool', 'error.type': 
…[2867 chars omitted]…
mcp.session.id': '15ce7e9b-d279-4d8b-a32e-60c7c64341cc', 'gen_ai.prompt.name': 'sub_welcome', 'fastmcp.component.key': 'prompt:sub_welcome@', 'fastmcp.component.type': 'prompt', 'fastmcp.provider.type': 'FastMCPProvider', 'fastmcp.delegate.original_name': 'welcome'}
prompts/get sub_welcome | {'mcp.method.name': 'prompts/get', 'fastmcp.component.key': 'sub_welcome', 'gen_ai.prompt.name': 'sub_welcome'}

src/fastmcp/client/client.py:19:from mcp import ClientSession, McpError
src/fastmcp/client/client.py:602:                    if isinstance(exception, httpx.HTTPStatusError | McpError):
src/fastmcp/client/client.py:832:            McpError: If the request results in a TimeoutError | JSONRPCError
src/fastmcp/client/client.py:862:            McpError: If the request results in a TimeoutError | JSONRPCError
src/fastmcp/client/mixins/prompts.py:50:            McpError: If the request results in a TimeoutError | JSONRPCError
src/fastmcp/client/mixins/prompts.py:77:            McpError: If the request results in a TimeoutError | JSONRPCError
src/fastmcp/client/mixins/prompts.py:126:            McpError: If the request results in a TimeoutError | JSONRPCError
src/fastmcp/client/mixins/prompts.py:228:            McpError: If the request results in a TimeoutError | JSONRPCError
src/fastmcp/client/mixins/resources.py:49:            McpError: If the request results in a TimeoutError | JSONRPCError
src/fastmcp/client/mixins/resources.py:76:            McpError: If the request results in a TimeoutError | JSONRPCError

self._warn_or_fail_if_strict(f"Unknown config option: {key}\n")

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

-- Docs: https://docs.pytest.org/en/stable/how-to/capture-warnings.html
=========================== short test summary info ============================
ERROR tests/client/sampling/handlers/test_anthropic_handler.py
!!!!!!!!!!!!!!!!!!!!!!!!!! stopping after 1 failures !!!!!!!!!!!!!!!!!!!!!!!!!!!
1 warning, 1 error in 2.60s

ERROR tests/client/sampling/handlers/test_openai_handler.py
ERROR tests/client/test_openapi.py
ERROR tests/client/test_stdio.py
ERROR tests/server/tasks/test_task_mount.py
ERROR tests/server/test_fastapi_testclient_compat.py
ERROR tests/server/test_server_docket.py
!!!!!!!!!!!!!!!!!!! Interrupted: 7 errors during collection !!!!!!!!!!!!!!!!!!!!
2 skipped, 11 warnings, 7 errors in 20.60s

ERROR tests/client/sampling/handlers/test_openai_handler.py
ERROR tests/client/test_openapi.py
ERROR tests/client/test_stdio.py
ImportError while importing test module '/repo/tests/client/test_stdio.py'.
E   ModuleNotFoundError: No module named 'psutil'
!!!!!!!!!!!!!!!!!!!! Interrupted: 1 error during collection !!!!!!!!!!!!!!!!!!!!
1 warning, 1 error in 1.04s

ERROR tests/server/tasks/test_task_tools.py::test_tool_task_executes_in_background
ERROR tests/server/tasks/test_task_tools.py::test_forbidden_mode_tool_rejects_task_calls
ERROR tests/server/tasks/test_task_ttl.py::test_keepalive_returned_in_submitted_state
ERROR tests/server/tasks/test_task_ttl.py::test_keepalive_returned_in_completed_state
ERROR tests/server/tasks/test_task_ttl.py::test_default_keepalive_when_not_specified
143 failed, 2598 passed, 2 skipped, 1 xfailed, 46 warnings, 141 errors in 126.73s (0:02:06)

1 FAILED tests/server/test_tool_annotations.py::test_task_execution_auto_populated_for_task_enabled_tool
      1 FAILED tests/server/test_dependencies.py::TestSharedDependencies::test_shared_with_depends
      1 FAILED tests/server/test_dependencies.py::TestSharedDependencies::test_shared_sync_function
      1 FAILED tests/server/test_dependencies.py::TestSharedDependencies::test_shared_in_resource
      1 FAILED tests/server/test_dependencies.py::TestSharedDependencies::test_shared_in_prompt
      1 FAILED tests/server/test_dependencies.py::TestSharedDependencies::test_shared_async_function
      1 FAILED tests/server/test_dependencies.py::TestSharedDependencies::test_shared_async_context_manager
      1 FAILED tests/server/test_dependencies.py::TestDependencyInjection::test_require_docket_passes_when_installed
      1 FAILED tests/server/test_dependencies.py::TestDependencyInj
…[2368 chars omitted]…
a_wrapped_primitive
      1 FAILED tests/server/providers/local_provider_tools/test_output_schema.py::TestToolOutputSchema::test_output_schema_complex_type

      1 FAILED tests/server/mount/test_advanced.py::TestMountedServerDocketBehavior::test_mounted_server_does_not_have_docket
      1 FAILED tests/server/http/test_http_dependencies.py::test_background_task_current_http_dependencies_restore_headers

__init__.py
__pycache__
test_provider_tracing.py
test_server_tracing.py
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
5 failed, 12 passed, 1 warning in 2.21s
    1 tests/server/telemetry/__init__.py
  133 tests/server/telemetry/test_provider_tracing.py
  340 tests/server/telemetry/test_server_tracing.py
  474 total

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

60 /tmp/fail_new.txt

Saved working directory and index state WIP on master: 095f65e base
49 /tmp/fail_base.txt
On branch master
Changes not staged for commit:
  (use "git add <file>..." to update what will be committed)
  (use "git restore <file>..." to discard changes in working directory)
	modified:   src/fastmcp/client/mixins/prompts.py
	modified:   src/fastmcp/client/mixins/resources.py
	modified:   src/fastmcp/client/mixins/tools.py
	modified:   src/fastmcp/client/telemetry.py
	modified:   src/fastmcp/resources/template.py
	modified:   src/fastmcp/server/providers/fastmcp_provider.py

	modified:   src/fastmcp/server/providers/proxy.py
	modified:   src/fastmcp/server/server.py
	modified:   src/fastmcp/server/telemetry.py
	modified:   src/fastmcp/telemetry.py

no changes added to commit (use "git add" and/or "git commit -a")
Dropped refs/stash@{0} (ec4ed0f63028f5494dc276431d44e64ea2c1df20)

13a14,19
> FAILED tests/client/telemetry/test_client_tracing.py::TestClientErrorTracing::test_read_resource_error_creates_spans
> FAILED tests/client/telemetry/test_client_tracing.py::TestClientPromptTracing::test_get_prompt_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::TestClientServerSpanHierarchy::test_client_and_server_spans_created
> FAILED tests/client/telemetry/test_client_tracing.py::TestClientToolTracing::test_call_tool_span_attributes
40a47,51
> FAILED tests/server/telemetry/test_server_tracing.py::TestPromptTracing::test_render_prompt_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::TestResourceTracing::test_read_resource_creates_span
> FAILED tests/server/telemetry/test_server_tracing.py::TestResourceTracing::test_read_resource_template_creates_span

> FAILED tests/server/telemetry/test_server_tracing.py::TestToolTracing::test_call_tool_creates_span

__________ TestClientResourceTracing.test_read_resource_creates_span ___________

self = <tests.client.telemetry.test_client_tracing.TestClientResourceTracing object at 0x700c15f2be30>
trace_exporter = <opentelemetry.sdk.trace.export.in_memory_span_exporter.InMemorySpanExporter object at 0x700c15f63ad0>

    async def test_read_resource_creates_span(
        self, trace_exporter: InMemorySpanExporter
    ):
        server = FastMCP("test-server")
    
        @server.resource("data://config")
        def get_config() -> str:

            return "config data"
    
        client = Client(server)
        async with client:
            result = await client.read_resource("data://config")
            assert "config data" in str(result)
    
        spans = trace_exporter.get_finished_spans()
        span_names = [s.name for s in spans]
--
FAILED tests/client/telemetry/test_client_tracing.p
…[162 chars omitted]…
span_attributes
FAILED tests/client/telemetry/test_client_tracing.py::TestClientPromptTracing::test_get_prompt_span_attributes
FAILED tests/client/telemetry/test_client_tracing.py::TestClientServerSpanHierarchy::test_client_and_server_spans_created
FAILED tests/client/telemetry/test_client_tracing.py::TestClientErrorTracing::test_read_resource_error_creates_spans
6 failed, 9 passed, 1 warning in 2.25s

67:        assert client_span.attributes["rpc.system"] == "mcp"
68:        assert client_span.attributes["rpc.method"] == "tools/call"
93:        # Client should create "resources/read data://config" span
94:        assert "resources/read data://config" in span_names
116:                if s.name.startswith("resources/read data://")
125:        assert client_span.attributes["mcp.method.name"] == "resources/read"
128:        assert client_span.attributes["rpc.system"] == "mcp"
129:        assert client_span.attributes["rpc.method"] == "resources/read"
187:        assert client_span.attributes["rpc.system"] == "mcp"
188:        assert client_span.attributes["rpc.method"] == "prompts/get"
245:        assert client_span.attributes["rpc.method"] == "tools/call"
383:                if s.name.startswith("resources/read data://fail")

394:                if s.name.startswith("resources/read data://fail")

for s in spans
                if s.name == "tools/call add"
                and s.attributes is not None
                and "fastmcp.server.name" not in s.attributes
            ),
            None,
        )
        assert client_span is not None
        assert client_span.attributes is not None
        # Standard MCP semantic conventions
        assert client_span.attributes["mcp.method.name"] == "tools/call"
        # Standard RPC semantic conventions

        assert client_span.attributes["rpc.system"] == "mcp"
        assert client_span.attributes["rpc.method"] == "tools/call"
        # FastMCP-specific attributes
        assert client_span.attributes["fastmcp.component.key"] == "add"


class TestClientResourceTracing:
    """Tests for client resource read tracing."""

    async def test_read_resource_creates_span(
        self, trace_exporter: InMemorySpanExport
…[4550 chars omitted]…
ame" not in s.attributes
            ),
            None,
        )
        # Find server-side span
        server_span = next(
            (
                s
                for s in spans
                if s.name.startswith("resources/read data://fail")
                and s.attributes is not None
                and "fastmcp.server.name" in s.attributes
            ),
            None,
        )

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

96:        assert span.name == "resources/read"
100:        assert span.attributes["mcp.method.name"] == "resources/read"
123:        assert span.name == "resources/read"
127:        assert span.attributes["mcp.method.name"] == "resources/read"
148:        assert span.name == "resources/read nonexistent://resource"
174:        assert span.attributes["rpc.system"] == "mcp"
175:        assert span.attributes["rpc.service"] == "test-server"
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
2 failed, 15 passed, 1 warning in 2.43s

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://resource"
        assert span.status.status_code == StatusCode.ERROR


class TestPromptTracing:

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

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

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

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

        span = spans[0]
        assert span.name == "prompts/get greeting"
       
…[808 chars omitted]…
nexistent", {})

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

        span = spans[0]
        assert span.name == "prompts/get nonexistent"
        assert span.status.status_code == StatusCode.ERROR


class TestAuthAttributesOnSpans:
    async def test_tool_span_includes_auth_attributes_when_authenticated(
        self, trace_exporter: InMemorySpanExporter
    ):

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

FAILED tests/utilities/test_async_utils.py::TestAsyncPartialIntegration::test_async_partial_with_task_true_does_not_raise
FAILED tests/utilities/test_async_utils.py::TestAsyncPartialIntegration::test_sync_partial_with_task_true_raises
28 failed, 1336 passed, 3 skipped, 20 warnings in 18.01s

SAME

'tools/call failing_tool' ERROR "ToolError: Error calling tool 'failing_tool': Something went wrong" tool_error
'tools/call failing_tool' ERROR "Error calling tool 'failing_tool': Something went wrong" tool_error
'resources/read' ERROR "NotFoundError: Unknown resource: 'res://gone2'" NotFoundError
'resources/read' ERROR "McpError: Resource not found: Unknown resource: 'res://gone2'" McpError

src/fastmcp/client/mixins/tools.py:111:    async def call_tool_mcp(
src/fastmcp/client/mixins/tools.py:173:    async def _parse_call_tool_result(
src/fastmcp/client/mixins/tools.py:190:        return await _parse_call_tool_result(
src/fastmcp/client/mixins/tools.py:200:    async def call_tool(
src/fastmcp/client/mixins/tools.py:214:    async def call_tool(
src/fastmcp/client/mixins/tools.py:229:    async def call_tool(
src/fastmcp/client/mixins/tools.py:296:        return await self._parse_call_tool_result(
src/fastmcp/client/mixins/tools.py:360:            parsed_result = await self._parse_call_tool_result(name, raw_result)
src/fastmcp/client/mixins/tools.py:370:async def _parse_call_tool_result(

**request_meta.get("fastmcp", {}),
                "version": version,
            }

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

        result = await self.call_tool_mcp(
            name=name,
            arguments=arguments or {},

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

    async def _call_tool_as_task(
            server_task_id = raw_result.task.taskId
            self._submitted_task_ids.add(server_task_id)

            task_obj = ToolTask(
                self, server_task_id, tool_name=name, immediate_result=None
            )
            self._task_re
…[12 chars omitted]…
r_task_id] = weakref.ref(task_obj)
            return task_obj
        else:
            # Graceful degradation - server returned CallToolResult
            parsed_result = await self._parse_call_tool_result(name, raw_result)
            synthetic_task_id = task_id or str(uuid.uuid4())
            return ToolTask(
                self,
                synthetic_task_id,
                tool_name=name,

RT test://{path*} test://{path*} {'path': '{path*}'} test://%7Bpath%2A%7D
RT test://{path*} test://{path*} {'path': '{path*}'} test://%7Bpath%2A%7D
RT test://{path*} test://{path*} {'path': '{path*}'} test://%7Bpath%2A%7D
RT test://{path*} test://{path*} {'path': '{path*}'} test://%7Bpath%2A%7D
RT test://{path*} test://{path*} {'path': '{path*}'} test://%7Bpath%2A%7D
RT test://{path*} test://{path*} {'path': '{path*}'} test://%7Bpath%2A%7D
RT test://{path*} test://{path*} {'path': '{path*}'} test://%7Bpath%2A%7D
RT test://{path*} test://{path*} {'path': '{path*}'} test://%7Bpath%2A%7D
RT test://{path*} test://{path*} {'path': '{path*}'} test://%7Bpath%2A%7D
RT test://{path*} test://{path*} {'path': '{path*}'} test://%7Bpath%2A%7D
RT test://{path*} test://{path*} {'path': '{path*}'} test://%7Bpath%2A%7D
RT test://{path*} test://{path*} {'path': '{path*}'} test://%7Bpath%2A%7D

RT test:/
…[8631 chars omitted]…
b%2A%7D/bar
RT scheme://{a*}/{b*}/{c} scheme://{a*}/{b*}/p%25q {'a': '{a*}', 'b': '{b*}', 'c': 'p%q'} scheme://%7Ba%2A%7D/%7Bb%2A%7D/p%25q
RT scheme://{a*}/{b*}/{c} scheme://{a*}/{b*}/1%2F2 {'a': '{a*}', 'b': '{b*}', 'c': '1/2'} scheme://%7Ba%2A%7D/%7Bb%2A%7D/1%2F2
RT scheme://{a*}/{b*}/{c} scheme://{a*}/{b*}/x%20y {'a': '{a*}', 'b': '{b*}', 'c': 'x y'} scheme://%7Ba%2A%7D/%7Bb%2A%7D/x%20y
fails: 1500

fails: 0

src/fastmcp/client/mixins/prompts.py             |  1 +
 src/fastmcp/client/mixins/resources.py           |  2 +-
 src/fastmcp/client/mixins/tools.py               | 13 +++++--
 src/fastmcp/client/telemetry.py                  | 29 ++++++++++++----
 src/fastmcp/resources/template.py                | 44 +++++++++++++++++++++++-
 src/fastmcp/server/providers/fastmcp_provider.py | 29 +++-------------
 src/fastmcp/server/providers/proxy.py            | 12 +++++--
 src/fastmcp/server/server.py                     | 16 +++++++--
 src/fastmcp/server/telemetry.py                  | 15 +++++---
 src/fastmcp/telemetry.py                         | 16 ++++++++-
 tests/client/telemetry/test_client_tracing.py    | 25 ++++++--------
 tests/server/telemetry/test_server_tracing.py    | 25 ++++----------

 12 files changed, 148 insertions(+), 79 deletions(-)
-- Docs: https://docs.pytest.org/en/stable/how-to/capture-warnings.html
236 passed, 1 skipped, 1 warning in 3.21s

diff --git a/src/fastmcp/client/mixins/tools.py b/src/fastmcp/client/mixins/tools.py
index aec5950..8fe1880 100644
--- a/src/fastmcp/client/mixins/tools.py
+++ b/src/fastmcp/client/mixins/tools.py
@@ -15,7 +15,7 @@ if TYPE_CHECKING:
     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.client.telemetry import client_span, set_result_error_status
 from fastmcp.exceptions import ToolError
 from fastmcp.telemetry import inject_trace_context

 from fastmcp.utilities.json_schema_type import json_schema_to_type
@@ -144,7 +144,8 @@ class ClientToolsMixin:
             "tools/call",
             name,
             session_id=self.transport.get_session_id(),
-        ):
+            tool_name=name,
+        ) as span:
           
…[3614 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:

src/fastmcp/client/mixins/prompts.py:129:            f"prompts/get {name}",
src/fastmcp/client/mixins/tools.py:143:            f"tools/call {name}",
src/fastmcp/server/providers/proxy.py:122:            f"tools/call {backend_name}",
src/fastmcp/server/providers/proxy.py:456:            f"prompts/get {backend_name}",
src/fastmcp/server/server.py:1207:                f"tools/call {name}",
src/fastmcp/server/server.py:1514:                f"prompts/get {name}",

…[169 chars omitted]…
s flag isError results as ERROR/tool_error. Updated the two existing tracing test modules to the new spec; all other test failures verified pre-existing on baseline."}
submitted.