Parse Docket task key to extract metadata. Args: task_key: Encoded task key from Docket Returns: Dict with keys: ``task_scop

Build a tool-call argument dict from CLI inputs. A single JSON object argument is treated as the full argument dict. ``--input-json`` provide

Send a resources/read request and return the complete MCP protocol result. Args: uri (AnyUrl | str): The URI of the resource to r

Check if this component supports task execution.

Validate URL for SSRF and resolve to IPs. Args: url: URL to validate require_path: If True, require non-root path (for CIMD)

Verify a Google OAuth token using the tokeninfo endpoint. Calls ``https://oauth2.googleapis.com/tokeninfo?access_token=TOKEN`` to val

Get the actual resource URL being protected. Uses ``resource_base_url`` if set; otherwise falls back to ``base_url``. Args:

Build a JWKS document from an RSA key pair's public key.

Parse an mcpServers-style JSON file into discovered servers.

Convert a JSON Schema to a Python type annotation. Returns (type_annotation, needs_json_parsing).

Build Docket task key with embedded metadata. When ``task_scope`` is ``None`` the task is anonymous and lives in the ``anon`` keyspace. Othe

Convert a raw result to ToolResult. Handles ToolResult passthrough and converts raw values using the tool's attributes (output_schema

Enable components matching criteria for this session only. Session rules override global transforms. Rules accumulate - each call add

Get the current HTTP request. Tries MCP SDK's request_ctx first, then falls back to FastMCP's HTTP context.

Send an initialize request to the server. This method performs the MCP initialization handshake with the server, exchanging capabilit

Load a FastMCP configuration from a fastmcp.json file. Args: config_path: Path to fastmcp.json file Returns: MCPServerConfig

Build a responder for the standard M2M discovery + token exchange flow. Returns the responder and a dict that captures the token request and the

Read the resource by calling the wrapped function.

Report progress for the current operation. Works in both foreground (MCP progress notifications) and background (Docket task executio

Require all of the given roles, read from the token's claims. Roles and groups are not part of OIDC, so every identity provider puts them som

Return the Redis key prefix that owns a given scope. Authenticated tasks live under ``fastmcp:task:auth:{enc_scope}``; anonymous tasks live u

Validate a redirect URI against allowed patterns. Args: redirect_uri: The redirect URI to validate allowed_patterns: List of allo

Temporarily replace sys.argv if args provided. This context manager is used at the CLI boundary to inject server arguments when needed, witho

Bind this OAuth provider to a specific MCP server URL. Called automatically when mcp_url is provided to __init__, or by the transport

Convert a result to a sequence of content objects.

Build a mock httpx2.AsyncClient whose stream() yields a canned response. The returned client's ``.stream.call_args`` exposes the request that was

Convert an AppConfig or dict to the wire-format dict for ``meta["ui"]``.

Call a tool, read a resource, or get a prompt on an MCP server. By default the target is treated as a tool name. If the target contains ``://

Send a completion request to the server. Args: ref (mcp_types.ResourceTemplateReference | mcp_types.PromptReference): The referen

Create a styled HTML response for OAuth callbacks.

A parent schema with a discriminator mapping onto two allOf subtypes.

Download a skill and all its files to a local directory. Creates a subdirectory named after the skill containing all files. Args: cl

Execute tool calls using Python code.

Exchange an authorization grant for tokens at the token endpoint. Falsy parameters are dropped from the request body, matching authlib.

Get the session ID for this transport, if available.

Load and return the FastMCP server instance. Must be called after prepare() if the source requires preparation. All information neede

Attempt to open a Cursor deeplink URL using the system's default handler. Args: deeplink: The deeplink URL to open Returns:

Resolve $ref at root level to meet MCP spec requirements. MCP specification requires outputSchema to have "type": "object" at the root level.

Run a MCP server or connect to a remote one. Args: server_spec: Python file, object specification (file:obj), config file, or URL

Emit or enrich a SERVER span with standard MCP attributes and auth context. When the current active span is the request's seam span (opened by

Store an event and return its ID. Args: stream_id: ID of the stream the event belongs to message: The JSON-RPC messag

Resolve the effective telemetry mode for the current context. This is `fastmcp.settings.telemetry_mode`, except that an active `suppress_fast

Build the server and return the generated input schema for create_pet.

Strip the SDK's `serverInfo` stamp from a result's `_meta`. Every 2026-era result carries `io.modelcontextprotocol/serverInfo` (spec #3002),

Validate OIDC proxy.

Verify a token by trying the server, then each verifier in order. Each source is tried independently. If a source raises an exception,

Wrap a Tool to delegate execution to the server's middleware.

Convert MCP messages to Google GenAI content.

A single-field form elicitation request keyed by ``key``.

A single-field form elicitation for *field*.

Attempts to connect to the Hue bridge using settings.

Bind a request context carrying the tasks opt-in for a `tools/call`.

Prefix unprefixed custom API scopes with identifier_uri for Azure. This helper centralizes the scope prefixing logic used in both aut

Convert Google GenAI response to CreateMessageResultWithTools.

Return a deep copy of *obj* with non-local ``$ref`` values removed. Local refs (starting with ``#``) are kept intact. Remote refs (``http://

Transform non-MCP errors to proper MCP errors.

Add a resource to the server. Args: resource: A Resource instance or @resource-decorated function to add Returns:

Build a client-facing authorization redirect that carries exactly one `iss`. Every redirect this server sends back to an OAuth client from the

Check if a newer version of FastMCP is available. Returns: The latest version string if newer than current, None otherwise.

Decode JWT header without signature verification. Useful for extracting the key ID (kid) for JWKS lookup. Args: token: JWT token str

Fetch a well-known document from a mounted authenticated server.

Build ``name(param: type, ...) -> return_type`` from a tool's JSON schemas.

Generate the full CLI script source code.

Generate a Goose deeplink for installing an MCP extension. Args: name: Human-readable display name for the extension. command: Th

Return HTTP headers from an ambient server request, when available. The standalone client package has no server request context. When the full

Atomically increment the current progress value.

Inject current trace context into a meta dict for MCP request propagation. Args: meta: Optional existing meta dict to merge with trace co

Check if a client_id looks like a CIMD URL. CIMD URLs must be HTTPS with a host and non-root path.

Check if an IP address is allowed (must be globally routable unicast). Uses ip.is_global which catches: - Private (10.x, 172.16-31.x, 192.168

Set `fastmcp.settings.telemetry_mode` for the duration of a test.

Normalize a timeout value to seconds (float). Args: value: Timeout value as int/float (seconds), timedelta, or None. Zero val

Read the resource content. Subclasses implement this to return resource data. Supported return types: - str: Text content

Resolve a server name (or ``source:name``) to a transport. Raises :class:`ValueError` when the name is not found or is ambiguous.

Set the total/target value for progress tracking.

Validate JWT assertion from client. Args: assertion: The JWT assertion string client_id: Expected client_id (must mat

Validate an OIDC configuration against the source dict.

Create a wrapper function without injected parameters. Returns a wrapper that excludes Context and Docket dependency parameters, making it sa

Get the current Docket instance managed by FastMCP. This dependency provides access to the Docket instance that FastMCP automatically creates

Combines parameter and request body schemas into a single schema. Handles parameter name collisions by adding location suffixes. This is

Get all additional HTTP routes including from mounted servers. Collects custom HTTP routes registered via ``@server.custom_route()``

Check if a JSON schema represents an object type.