ceos/fastmcp
1
0
Fork 0
mirror of https://github.com/PrefectHQ/fastmcp.git synced 2026-08-23 14:04:18 +02:00
Code Issues Projects Releases Packages Wiki Activity

Migrate mcp.types imports to mcp_types

Browse source
This commit is contained in:
Jeremiah Lowin 2026-07-05 18:03:43 -04:00
commit 2f49f9f7c0
No known key found for this signature in database
168 changed files with 777 additions and 777 deletions
Download patch file Download diff file Expand all files Collapse all files

2
fastmcp_slim/fastmcp/apps/app.py
View file

@ -32,7 +32,7 @@ from collections.abc import AsyncIterator, Callable, Sequence
from contextlib import asynccontextmanager
from typing import TYPE_CHECKING, Any, Literal, TypeVar, overload
from mcp.types import AnyFunction, Icon, ToolAnnotations
from mcp_types import AnyFunction, Icon, ToolAnnotations
from fastmcp.server.providers.base import Provider
from fastmcp.utilities.authorization import AuthCheck

36
fastmcp_slim/fastmcp/cli/client.py
View file

@ -8,7 +8,7 @@ from pathlib import Path
from typing import Annotated, Any, Literal
import cyclopts
import mcp.types
import mcp_types
from rich.console import Console
from rich.markup import escape as escape_rich_markup
@ -177,7 +177,7 @@ async def _terminal_elicitation_handler(
Prints the server's message and prompts for each field in the schema.
The user can type 'decline' or 'cancel' instead of a value to abort.
"""
from mcp.types import ElicitRequestFormParams
from mcp_types import ElicitRequestFormParams
console.print(f"\n[bold yellow]Server asks:[/bold yellow] {message}")
@ -367,7 +367,7 @@ def _json_schema_type_to_str(schema: dict[str, Any]) -> str:
return _JSON_SCHEMA_TYPE_MAP.get(schema_type, schema_type)
def format_tool_signature(tool: mcp.types.Tool) -> str:
def format_tool_signature(tool: mcp_types.Tool) -> str:
"""Build ``name(param: type, ...) -> return_type`` from a tool's JSON schemas."""
params: list[str] = []
@ -422,7 +422,7 @@ def _format_call_result_text(result: CallToolResult) -> None:
if result.is_error:
for block in result.content:
if isinstance(block, mcp.types.TextContent):
if isinstance(block, mcp_types.TextContent):
console.print(
f"[bold red]Error:[/bold red] {_sanitize_untrusted_text(block.text)}"
)
@ -437,25 +437,25 @@ def _format_call_result_text(result: CallToolResult) -> None:
return
for block in result.content:
if isinstance(block, mcp.types.TextContent):
if isinstance(block, mcp_types.TextContent):
console.print(_sanitize_untrusted_text(block.text))
elif isinstance(block, mcp.types.ImageContent):
elif isinstance(block, mcp_types.ImageContent):
size = len(block.data) * 3 // 4 # rough decoded size
console.print(f"[dim][Image: {block.mimeType}, ~{size} bytes][/dim]")
elif isinstance(block, mcp.types.AudioContent):
elif isinstance(block, mcp_types.AudioContent):
size = len(block.data) * 3 // 4
console.print(f"[dim][Audio: {block.mimeType}, ~{size} bytes][/dim]")
else:
console.print(_sanitize_untrusted_text(str(block)))
def _content_block_to_dict(block: mcp.types.ContentBlock) -> dict[str, Any]:
def _content_block_to_dict(block: mcp_types.ContentBlock) -> dict[str, Any]:
"""Serialize a single content block to a JSON-safe dict."""
if isinstance(block, mcp.types.TextContent):
if isinstance(block, mcp_types.TextContent):
return {"type": "text", "text": block.text}
if isinstance(block, mcp.types.ImageContent):
if isinstance(block, mcp_types.ImageContent):
return {"type": "image", "mimeType": block.mimeType, "data": block.data}
if isinstance(block, mcp.types.AudioContent):
if isinstance(block, mcp_types.AudioContent):
return {"type": "audio", "mimeType": block.mimeType, "data": block.data}
return {"type": "unknown", "value": str(block)}
@ -470,7 +470,7 @@ def _call_result_to_dict(result: CallToolResult) -> dict[str, Any]:
return out
def _tools_to_json(tools: list[mcp.types.Tool]) -> list[dict[str, Any]]:
def _tools_to_json(tools: list[mcp_types.Tool]) -> list[dict[str, Any]]:
"""Serialize a list of tools to JSON-safe dicts."""
return [
@ -549,7 +549,7 @@ async def _handle_resource(
if json_output:
data = []
for block in contents:
if isinstance(block, mcp.types.TextResourceContents):
if isinstance(block, mcp_types.TextResourceContents):
data.append(
{
"uri": str(block.uri),
@ -557,7 +557,7 @@ async def _handle_resource(
"text": block.text,
}
)
elif isinstance(block, mcp.types.BlobResourceContents):
elif isinstance(block, mcp_types.BlobResourceContents):
data.append(
{
"uri": str(block.uri),
@ -569,9 +569,9 @@ async def _handle_resource(
return
for block in contents:
if isinstance(block, mcp.types.TextResourceContents):
if isinstance(block, mcp_types.TextResourceContents):
console.print(_sanitize_untrusted_text(block.text))
elif isinstance(block, mcp.types.BlobResourceContents):
elif isinstance(block, mcp_types.BlobResourceContents):
size = len(block.blob) * 3 // 4
console.print(f"[dim][Blob: {block.mimeType}, ~{size} bytes][/dim]")
@ -621,9 +621,9 @@ async def _handle_prompt(
for msg in result.messages:
console.print(f"[bold]{_sanitize_untrusted_text(msg.role)}:[/bold]")
if isinstance(msg.content, mcp.types.TextContent):
if isinstance(msg.content, mcp_types.TextContent):
console.print(f" {_sanitize_untrusted_text(msg.content.text)}")
elif isinstance(msg.content, mcp.types.ImageContent):
elif isinstance(msg.content, mcp_types.ImageContent):
size = len(msg.content.data) * 3 // 4
console.print(
f" [dim][Image: {msg.content.mimeType}, ~{size} bytes][/dim]"

28
fastmcp_slim/fastmcp/cli/generate.py
View file

@ -9,7 +9,7 @@ from typing import Annotated, Any
from urllib.parse import urlparse
import cyclopts
import mcp.types
import mcp_types
import pydantic_core
from mcp import McpError
from rich.console import Console
@ -163,7 +163,7 @@ def _to_python_identifier(name: str) -> str:
return safe
def _tool_function_source(tool: mcp.types.Tool) -> str:
def _tool_function_source(tool: mcp_types.Tool) -> str:
"""Generate the source for a single ``@call_tool_app.command`` function."""
schema = tool.inputSchema
properties: dict[str, Any] = schema.get("properties", {})
@ -285,7 +285,7 @@ def generate_cli_script(
server_spec: str,
transport_code: str,
extra_imports: set[str],
tools: list[mcp.types.Tool],
tools: list[mcp_types.Tool],
) -> str:
"""Generate the full CLI script source code."""
@ -309,7 +309,7 @@ def generate_cli_script(
lines.append("from typing import Annotated")
lines.append("")
lines.append("import cyclopts")
lines.append("import mcp.types")
lines.append("import mcp_types")
lines.append("from rich.console import Console")
lines.append("")
lines.append("from fastmcp import Client")
@ -346,7 +346,7 @@ def generate_cli_script(
def _print_tool_result(result):
if result.is_error:
for block in result.content:
if isinstance(block, mcp.types.TextContent):
if isinstance(block, mcp_types.TextContent):
console.print(f"[bold red]Error:[/bold red] {block.text}")
else:
console.print(f"[bold red]Error:[/bold red] {block}")
@ -357,12 +357,12 @@ def generate_cli_script(
return
for block in result.content:
if isinstance(block, mcp.types.TextContent):
if isinstance(block, mcp_types.TextContent):
console.print(block.text)
elif isinstance(block, mcp.types.ImageContent):
elif isinstance(block, mcp_types.ImageContent):
size = len(block.data) * 3 // 4
console.print(f"[dim][Image: {block.mimeType}, ~{size} bytes][/dim]")
elif isinstance(block, mcp.types.AudioContent):
elif isinstance(block, mcp_types.AudioContent):
size = len(block.data) * 3 // 4
console.print(f"[dim][Audio: {block.mimeType}, ~{size} bytes][/dim]")
@ -439,9 +439,9 @@ def generate_cli_script(
async with Client(CLIENT_SPEC) as client:
contents = await client.read_resource(uri)
for block in contents:
if isinstance(block, mcp.types.TextResourceContents):
if isinstance(block, mcp_types.TextResourceContents):
console.print(block.text)
elif isinstance(block, mcp.types.BlobResourceContents):
elif isinstance(block, mcp_types.BlobResourceContents):
size = len(block.blob) * 3 // 4
console.print(f"[dim][Blob: {block.mimeType}, ~{size} bytes][/dim]")
@ -483,9 +483,9 @@ def generate_cli_script(
result = await client.get_prompt(name, parsed or None)
for msg in result.messages:
console.print(f"[bold]{msg.role}:[/bold]")
if isinstance(msg.content, mcp.types.TextContent):
if isinstance(msg.content, mcp_types.TextContent):
console.print(f" {msg.content.text}")
elif isinstance(msg.content, mcp.types.ImageContent):
elif isinstance(msg.content, mcp_types.ImageContent):
size = len(msg.content.data) * 3 // 4
console.print(f" [dim][Image: {msg.content.mimeType}, ~{size} bytes][/dim]")
else:
@ -564,7 +564,7 @@ def _schema_type_label(prop_schema: dict[str, Any]) -> str:
return label
def _tool_skill_section(tool: mcp.types.Tool, cli_filename: str) -> str:
def _tool_skill_section(tool: mcp_types.Tool, cli_filename: str) -> str:
"""Generate a SKILL.md section for a single tool."""
schema = tool.inputSchema
properties: dict[str, Any] = schema.get("properties", {})
@ -619,7 +619,7 @@ def _tool_skill_section(tool: mcp.types.Tool, cli_filename: str) -> str:
def generate_skill_content(
server_name: str,
cli_filename: str,
tools: list[mcp.types.Tool],
tools: list[mcp_types.Tool],
) -> str:
"""Generate a SKILL.md file for a generated CLI script."""
skill_name = (

48
fastmcp_slim/fastmcp/client/client.py
View file

@ -14,10 +14,10 @@ from typing import TYPE_CHECKING, Any, Generic, Literal, TypeVar, cast, overload
import anyio
import httpx
import mcp.types
import mcp_types
from exceptiongroup import catch
from mcp import ClientSession, McpError
from mcp.types import GetTaskResult, TaskStatusNotification
from mcp_types import GetTaskResult, TaskStatusNotification
from pydantic import AnyUrl
import fastmcp as fastmcp
@ -113,14 +113,14 @@ class ClientSessionState:
session_task: asyncio.Task | None = None
ready_event: anyio.Event = field(default_factory=anyio.Event)
stop_event: anyio.Event = field(default_factory=anyio.Event)
initialize_result: mcp.types.InitializeResult | None = None
initialize_result: mcp_types.InitializeResult | None = None
@dataclass
class CallToolResult:
"""Parsed result from a tool call."""
content: list[mcp.types.ContentBlock]
content: list[mcp_types.ContentBlock]
structured_content: dict[str, Any] | None
meta: dict[str, Any] | None
data: Any = None
@ -256,7 +256,7 @@ class Client(
name: str | None = None,
roots: RootsList | RootsHandler | None = None,
sampling_handler: SamplingHandler | None = None,
sampling_capabilities: mcp.types.SamplingCapability | None = None,
sampling_capabilities: mcp_types.SamplingCapability | None = None,
elicitation_handler: ElicitationHandler | None = None,
log_handler: LogHandler | None = None,
message_handler: MessageHandlerT | MessageHandler | None = None,
@ -264,7 +264,7 @@ class Client(
timeout: datetime.timedelta | float | int | None = None,
auto_initialize: bool = True,
init_timeout: datetime.timedelta | float | int | None = None,
client_info: mcp.types.Implementation | None = None,
client_info: mcp_types.Implementation | None = None,
auth: httpx.Auth | Literal["oauth"] | str | None = None,
verify: ssl.SSLContext | bool | str | None = None,
) -> None:
@ -334,7 +334,7 @@ class Client(
self._session_kwargs["sampling_capabilities"] = (
sampling_capabilities
if sampling_capabilities is not None
else mcp.types.SamplingCapability()
else mcp_types.SamplingCapability()
)
if elicitation_handler is not None:
@ -384,7 +384,7 @@ class Client(
return self._session_state.session
@property
def initialize_result(self) -> mcp.types.InitializeResult | None:
def initialize_result(self) -> mcp_types.InitializeResult | None:
"""Get the result of the initialization request."""
return self._session_state.initialize_result
@ -395,7 +395,7 @@ class Client(
def set_sampling_callback(
self,
sampling_callback: SamplingHandler,
sampling_capabilities: mcp.types.SamplingCapability | None = None,
sampling_capabilities: mcp_types.SamplingCapability | None = None,
) -> None:
"""Set the sampling callback for the client."""
self._session_kwargs["sampling_callback"] = create_sampling_callback(
@ -404,7 +404,7 @@ class Client(
self._session_kwargs["sampling_capabilities"] = (
sampling_capabilities
if sampling_capabilities is not None
else mcp.types.SamplingCapability()
else mcp_types.SamplingCapability()
)
def set_elicitation_callback(
@ -483,7 +483,7 @@ class Client(
async def initialize(
self,
timeout: datetime.timedelta | float | int | None = None,
) -> mcp.types.InitializeResult:
) -> mcp_types.InitializeResult:
"""Send an initialize request to the server.
This method performs the MCP initialization handshake with the server,
@ -804,7 +804,7 @@ class Client(
async def ping(self) -> bool:
"""Send a ping request."""
result = await self._await_with_session_monitoring(self.session.send_ping())
return isinstance(result, mcp.types.EmptyResult)
return isinstance(result, mcp_types.EmptyResult)
async def cancel(
self,
@ -812,10 +812,10 @@ class Client(
reason: str | None = None,
) -> None:
"""Send a cancellation notification for an in-progress request."""
notification = mcp.types.ClientNotification(
root=mcp.types.CancelledNotification(
notification = mcp_types.ClientNotification(
root=mcp_types.CancelledNotification(
method="notifications/cancelled",
params=mcp.types.CancelledNotificationParams(
params=mcp_types.CancelledNotificationParams(
requestId=request_id,
reason=reason,
),
@ -835,7 +835,7 @@ class Client(
progress_token, progress, total, message
)
async def set_logging_level(self, level: mcp.types.LoggingLevel) -> None:
async def set_logging_level(self, level: mcp_types.LoggingLevel) -> None:
"""Send a logging/setLevel request."""
await self._await_with_session_monitoring(self.session.set_logging_level(level))
@ -847,20 +847,20 @@ class Client(
async def complete_mcp(
self,
ref: mcp.types.ResourceTemplateReference | mcp.types.PromptReference,
ref: mcp_types.ResourceTemplateReference | mcp_types.PromptReference,
argument: dict[str, str],
context_arguments: dict[str, Any] | None = None,
) -> mcp.types.CompleteResult:
) -> mcp_types.CompleteResult:
"""Send a completion request and return the complete MCP protocol result.
Args:
ref (mcp.types.ResourceTemplateReference | mcp.types.PromptReference): The reference to complete.
ref (mcp_types.ResourceTemplateReference | mcp_types.PromptReference): The reference to complete.
argument (dict[str, str]): Arguments to pass to the completion request.
context_arguments (dict[str, Any] | None, optional): Optional context arguments to
include with the completion request. Defaults to None.
Returns:
mcp.types.CompleteResult: The complete response object from the protocol,
mcp_types.CompleteResult: The complete response object from the protocol,
containing the completion and any additional metadata.
Raises:
@ -878,20 +878,20 @@ class Client(
async def complete(
self,
ref: mcp.types.ResourceTemplateReference | mcp.types.PromptReference,
ref: mcp_types.ResourceTemplateReference | mcp_types.PromptReference,
argument: dict[str, str],
context_arguments: dict[str, Any] | None = None,
) -> mcp.types.Completion:
) -> mcp_types.Completion:
"""Send a completion request to the server.
Args:
ref (mcp.types.ResourceTemplateReference | mcp.types.PromptReference): The reference to complete.
ref (mcp_types.ResourceTemplateReference | mcp_types.PromptReference): The reference to complete.
argument (dict[str, str]): Arguments to pass to the completion request.
context_arguments (dict[str, Any] | None, optional): Optional context arguments to
include with the completion request. Defaults to None.
Returns:
mcp.types.Completion: The completion object.
mcp_types.Completion: The completion object.
Raises:
RuntimeError: If called while the client is not connected.

12
fastmcp_slim/fastmcp/client/elicitation.py
View file

@ -3,12 +3,12 @@ from __future__ import annotations
from collections.abc import Awaitable, Callable
from typing import Any, Generic, TypeAlias
import mcp.types
import mcp_types
from mcp import ClientSession
from mcp.client.session import ElicitationFnT
from mcp.shared.context import LifespanContextT, RequestContext
from mcp.types import ElicitRequestFormParams, ElicitRequestParams
from mcp.types import ElicitResult as MCPElicitResult
from mcp_types import ElicitRequestFormParams, ElicitRequestParams
from mcp_types import ElicitResult as MCPElicitResult
from pydantic_core import to_jsonable_python
from typing_extensions import TypeVar
@ -41,7 +41,7 @@ def create_elicitation_callback(
async def _elicitation_handler(
context: RequestContext[ClientSession, LifespanContextT],
params: ElicitRequestParams,
) -> MCPElicitResult | mcp.types.ErrorData:
) -> MCPElicitResult | mcp_types.ErrorData:
try:
# requestedSchema only exists on ElicitRequestFormParams, not ElicitRequestURLParams
if isinstance(params, ElicitRequestFormParams):
@ -80,8 +80,8 @@ def create_elicitation_callback(
)
except Exception as e:
return mcp.types.ErrorData(
code=mcp.types.INTERNAL_ERROR,
return mcp_types.ErrorData(
code=mcp_types.INTERNAL_ERROR,
message=str(e),
)

2
fastmcp_slim/fastmcp/client/logging.py
View file

@ -3,7 +3,7 @@ from logging import Logger
from typing import TypeAlias
from mcp.client.session import LoggingFnT
from mcp.types import LoggingMessageNotificationParams
from mcp_types import LoggingMessageNotificationParams
from fastmcp.utilities.logging import get_logger

56
fastmcp_slim/fastmcp/client/messages.py
View file

@ -1,12 +1,12 @@
from typing import TypeAlias
import mcp.types
import mcp_types
from mcp.client.session import MessageHandlerFnT
from mcp.shared.session import RequestResponder
Message: TypeAlias = (
RequestResponder[mcp.types.ServerRequest, mcp.types.ClientResult]
| mcp.types.ServerNotification
RequestResponder[mcp_types.ServerRequest, mcp_types.ClientResult]
| mcp_types.ServerNotification
| Exception
)
@ -21,8 +21,8 @@ class MessageHandler:
async def __call__(
self,
message: RequestResponder[mcp.types.ServerRequest, mcp.types.ClientResult]
| mcp.types.ServerNotification
message: RequestResponder[mcp_types.ServerRequest, mcp_types.ClientResult]
| mcp_types.ServerNotification
| Exception,
) -> None:
return await self.dispatch(message)
@ -41,33 +41,33 @@ class MessageHandler:
# handle specific requests
# TODO(ty): remove type ignores when ty supports match statement narrowing
match message.request.root: # type: ignore[union-attr] # ty:ignore[unresolved-attribute]
case mcp.types.PingRequest():
case mcp_types.PingRequest():
await self.on_ping(message.request.root) # type: ignore[union-attr] # ty:ignore[unresolved-attribute]
case mcp.types.ListRootsRequest():
case mcp_types.ListRootsRequest():
await self.on_list_roots(message.request.root) # type: ignore[union-attr] # ty:ignore[unresolved-attribute]
case mcp.types.CreateMessageRequest():
case mcp_types.CreateMessageRequest():
await self.on_create_message(message.request.root) # type: ignore[union-attr] # ty:ignore[unresolved-attribute]
# notifications
case mcp.types.ServerNotification():
case mcp_types.ServerNotification():
# handle all notifications
await self.on_notification(message)
# handle specific notifications
match message.root:
case mcp.types.CancelledNotification():
case mcp_types.CancelledNotification():
await self.on_cancelled(message.root)
case mcp.types.ProgressNotification():
case mcp_types.ProgressNotification():
await self.on_progress(message.root)
case mcp.types.LoggingMessageNotification():
case mcp_types.LoggingMessageNotification():
await self.on_logging_message(message.root)
case mcp.types.ToolListChangedNotification():
case mcp_types.ToolListChangedNotification():
await self.on_tool_list_changed(message.root)
case mcp.types.ResourceListChangedNotification():
case mcp_types.ResourceListChangedNotification():
await self.on_resource_list_changed(message.root)
case mcp.types.PromptListChangedNotification():
case mcp_types.PromptListChangedNotification():
await self.on_prompt_list_changed(message.root)
case mcp.types.ResourceUpdatedNotification():
case mcp_types.ResourceUpdatedNotification():
await self.on_resource_updated(message.root)
case Exception():
@ -77,52 +77,52 @@ class MessageHandler:
pass
async def on_request(
self, message: RequestResponder[mcp.types.ServerRequest, mcp.types.ClientResult]
self, message: RequestResponder[mcp_types.ServerRequest, mcp_types.ClientResult]
) -> None:
pass
async def on_ping(self, message: mcp.types.PingRequest) -> None:
async def on_ping(self, message: mcp_types.PingRequest) -> None:
pass
async def on_list_roots(self, message: mcp.types.ListRootsRequest) -> None:
async def on_list_roots(self, message: mcp_types.ListRootsRequest) -> None:
pass
async def on_create_message(self, message: mcp.types.CreateMessageRequest) -> None:
async def on_create_message(self, message: mcp_types.CreateMessageRequest) -> None:
pass
async def on_notification(self, message: mcp.types.ServerNotification) -> None:
async def on_notification(self, message: mcp_types.ServerNotification) -> None:
pass
async def on_exception(self, message: Exception) -> None:
pass
async def on_progress(self, message: mcp.types.ProgressNotification) -> None:
async def on_progress(self, message: mcp_types.ProgressNotification) -> None:
pass
async def on_logging_message(
self, message: mcp.types.LoggingMessageNotification
self, message: mcp_types.LoggingMessageNotification
) -> None:
pass
async def on_tool_list_changed(
self, message: mcp.types.ToolListChangedNotification
self, message: mcp_types.ToolListChangedNotification
) -> None:
pass
async def on_resource_list_changed(
self, message: mcp.types.ResourceListChangedNotification
self, message: mcp_types.ResourceListChangedNotification
) -> None:
pass
async def on_prompt_list_changed(
self, message: mcp.types.PromptListChangedNotification
self, message: mcp_types.PromptListChangedNotification
) -> None:
pass
async def on_resource_updated(
self, message: mcp.types.ResourceUpdatedNotification
self, message: mcp_types.ResourceUpdatedNotification
) -> None:
pass
async def on_cancelled(self, message: mcp.types.CancelledNotification) -> None:
async def on_cancelled(self, message: mcp_types.CancelledNotification) -> None:
pass

44
fastmcp_slim/fastmcp/client/mixins/prompts.py
View file

@ -6,7 +6,7 @@ import uuid
import weakref
from typing import TYPE_CHECKING, Any, Literal, cast, overload
import mcp.types
import mcp_types
import pydantic_core
from pydantic import RootModel
@ -24,7 +24,7 @@ AUTO_PAGINATION_MAX_PAGES = 250
# Type alias for task response union (SEP-1686 graceful degradation)
PromptTaskResponseUnion = RootModel[
mcp.types.CreateTaskResult | mcp.types.GetPromptResult
mcp_types.CreateTaskResult | mcp_types.GetPromptResult
]
@ -35,14 +35,14 @@ class ClientPromptsMixin:
async def list_prompts_mcp(
self: Client, *, cursor: str | None = None
) -> mcp.types.ListPromptsResult:
) -> mcp_types.ListPromptsResult:
"""Send a prompts/list request and return the complete MCP protocol result.
Args:
cursor: Optional pagination cursor from a previous request's nextCursor.
Returns:
mcp.types.ListPromptsResult: The complete response object from the protocol,
mcp_types.ListPromptsResult: The complete response object from the protocol,
containing the list of prompts and any additional metadata.
Raises:
@ -65,7 +65,7 @@ class ClientPromptsMixin:
async def list_prompts(
self: Client,
max_pages: int = AUTO_PAGINATION_MAX_PAGES,
) -> list[mcp.types.Prompt]:
) -> list[mcp_types.Prompt]:
"""Retrieve all prompts available on the server.
This method automatically fetches all pages if the server paginates results,
@ -76,13 +76,13 @@ class ClientPromptsMixin:
max_pages: Maximum number of pages to fetch before raising. Defaults to 250.
Returns:
list[mcp.types.Prompt]: A list of all Prompt objects.
list[mcp_types.Prompt]: A list of all Prompt objects.
Raises:
RuntimeError: If the page limit is reached before pagination completes.
McpError: If the request results in a TimeoutError | JSONRPCError
"""
all_prompts: list[mcp.types.Prompt] = []
all_prompts: list[mcp_types.Prompt] = []
cursor: str | None = None
seen_cursors: set[str] = set()
@ -115,7 +115,7 @@ class ClientPromptsMixin:
name: str,
arguments: dict[str, Any] | None = None,
meta: dict[str, Any] | None = None,
) -> mcp.types.GetPromptResult:
) -> mcp_types.GetPromptResult:
"""Send a prompts/get request and return the complete MCP protocol result.
Args:
@ -124,7 +124,7 @@ class ClientPromptsMixin:
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,
mcp_types.GetPromptResult: The complete response object from the protocol,
containing the prompt messages and any additional metadata.
Raises:
@ -155,23 +155,23 @@ class ClientPromptsMixin:
# Inject trace context into meta for propagation to server
propagated_meta = inject_trace_context(meta)
request_meta = cast(mcp.types.RequestParams.Meta | None, propagated_meta)
request_meta = cast(mcp_types.RequestParams.Meta | None, propagated_meta)
# If meta provided, use send_request for SEP-1686 task support
if propagated_meta:
task_dict = propagated_meta.get("modelcontextprotocol.io/task")
request = mcp.types.GetPromptRequest(
params=mcp.types.GetPromptRequestParams(
request = mcp_types.GetPromptRequest(
params=mcp_types.GetPromptRequestParams(
name=name,
arguments=serialized_arguments,
task=mcp.types.TaskMetadata(**task_dict) if task_dict else None,
task=mcp_types.TaskMetadata(**task_dict) if task_dict else None,
_meta=request_meta, # type: ignore[unknown-argument] # pydantic alias
)
)
result = await self._await_with_session_monitoring(
self.session.send_request(
request=request, # type: ignore[arg-type] # ty:ignore[invalid-argument-type]
result_type=mcp.types.GetPromptResult,
result_type=mcp_types.GetPromptResult,
)
)
else:
@ -189,7 +189,7 @@ class ClientPromptsMixin:
version: str | None = None,
meta: dict[str, Any] | None = None,
task: Literal[False] = False,
) -> mcp.types.GetPromptResult: ...
) -> mcp_types.GetPromptResult: ...
@overload
async def get_prompt(
@ -214,7 +214,7 @@ class ClientPromptsMixin:
task: bool = False,
task_id: str | None = None,
ttl: int = 60000,
) -> mcp.types.GetPromptResult | PromptTask:
) -> mcp_types.GetPromptResult | PromptTask:
"""Retrieve a rendered prompt message list from the server.
Args:
@ -227,7 +227,7 @@ class ClientPromptsMixin:
ttl (int): Time to keep results available in milliseconds (default 60s).
Returns:
mcp.types.GetPromptResult | PromptTask: The complete response object if task=False,
mcp_types.GetPromptResult | PromptTask: The complete response object if task=False,
or a PromptTask object if task=True.
Raises:
@ -277,7 +277,7 @@ class ClientPromptsMixin:
# Per SEP-1686 final spec: client sends only ttl, server generates taskId
# Inject trace context into meta for propagation to server
propagated_meta = inject_trace_context(meta)
request_meta = cast(mcp.types.RequestParams.Meta | None, propagated_meta)
request_meta = cast(mcp_types.RequestParams.Meta | None, propagated_meta)
# Serialize arguments for MCP protocol
serialized_arguments: dict[str, str] | None = None
@ -291,11 +291,11 @@ class ClientPromptsMixin:
"utf-8"
)
request = mcp.types.GetPromptRequest(
params=mcp.types.GetPromptRequestParams(
request = mcp_types.GetPromptRequest(
params=mcp_types.GetPromptRequestParams(
name=name,
arguments=serialized_arguments,
task=mcp.types.TaskMetadata(ttl=ttl),
task=mcp_types.TaskMetadata(ttl=ttl),
_meta=request_meta, # type: ignore[unknown-argument] # pydantic alias
)
)
@ -309,7 +309,7 @@ class ClientPromptsMixin:
)
raw_result = wrapped_result.root
if isinstance(raw_result, mcp.types.CreateTaskResult):
if isinstance(raw_result, mcp_types.CreateTaskResult):
# Task was accepted - extract task info from CreateTaskResult
server_task_id = raw_result.task.taskId
self._submitted_task_ids.add(server_task_id)

54
fastmcp_slim/fastmcp/client/mixins/resources.py
View file

@ -6,7 +6,7 @@ import uuid
import weakref
from typing import TYPE_CHECKING, Any, Literal, cast, overload
import mcp.types
import mcp_types
from pydantic import AnyUrl, RootModel
if TYPE_CHECKING:
@ -23,7 +23,7 @@ AUTO_PAGINATION_MAX_PAGES = 250
# Type alias for task response union (SEP-1686 graceful degradation)
ResourceTaskResponseUnion = RootModel[
mcp.types.CreateTaskResult | mcp.types.ReadResourceResult
mcp_types.CreateTaskResult | mcp_types.ReadResourceResult
]
@ -34,14 +34,14 @@ class ClientResourcesMixin:
async def list_resources_mcp(
self: Client, *, cursor: str | None = None
) -> mcp.types.ListResourcesResult:
) -> mcp_types.ListResourcesResult:
"""Send a resources/list request and return the complete MCP protocol result.
Args:
cursor: Optional pagination cursor from a previous request's nextCursor.
Returns:
mcp.types.ListResourcesResult: The complete response object from the protocol,
mcp_types.ListResourcesResult: The complete response object from the protocol,
containing the list of resources and any additional metadata.
Raises:
@ -64,7 +64,7 @@ class ClientResourcesMixin:
async def list_resources(
self: Client,
max_pages: int = AUTO_PAGINATION_MAX_PAGES,
) -> list[mcp.types.Resource]:
) -> list[mcp_types.Resource]:
"""Retrieve all resources available on the server.
This method automatically fetches all pages if the server paginates results,
@ -75,13 +75,13 @@ class ClientResourcesMixin:
max_pages: Maximum number of pages to fetch before raising. Defaults to 250.
Returns:
list[mcp.types.Resource]: A list of all Resource objects.
list[mcp_types.Resource]: A list of all Resource objects.
Raises:
RuntimeError: If the page limit is reached before pagination completes.
McpError: If the request results in a TimeoutError | JSONRPCError
"""
all_resources: list[mcp.types.Resource] = []
all_resources: list[mcp_types.Resource] = []
cursor: str | None = None
seen_cursors: set[str] = set()
@ -110,14 +110,14 @@ class ClientResourcesMixin:
async def list_resource_templates_mcp(
self: Client, *, cursor: str | None = None
) -> mcp.types.ListResourceTemplatesResult:
) -> mcp_types.ListResourceTemplatesResult:
"""Send a resources/listResourceTemplates request and return the complete MCP protocol result.
Args:
cursor: Optional pagination cursor from a previous request's nextCursor.
Returns:
mcp.types.ListResourceTemplatesResult: The complete response object from the protocol,
mcp_types.ListResourceTemplatesResult: The complete response object from the protocol,
containing the list of resource templates and any additional metadata.
Raises:
@ -140,7 +140,7 @@ class ClientResourcesMixin:
async def list_resource_templates(
self: Client,
max_pages: int = AUTO_PAGINATION_MAX_PAGES,
) -> list[mcp.types.ResourceTemplate]:
) -> list[mcp_types.ResourceTemplate]:
"""Retrieve all resource templates available on the server.
This method automatically fetches all pages if the server paginates results,
@ -152,13 +152,13 @@ class ClientResourcesMixin:
max_pages: Maximum number of pages to fetch before raising. Defaults to 250.
Returns:
list[mcp.types.ResourceTemplate]: A list of all ResourceTemplate objects.
list[mcp_types.ResourceTemplate]: A list of all ResourceTemplate objects.
Raises:
RuntimeError: If the page limit is reached before pagination completes.
McpError: If the request results in a TimeoutError | JSONRPCError
"""
all_templates: list[mcp.types.ResourceTemplate] = []
all_templates: list[mcp_types.ResourceTemplate] = []
cursor: str | None = None
seen_cursors: set[str] = set()
@ -188,7 +188,7 @@ class ClientResourcesMixin:
async def read_resource_mcp(
self: Client, uri: AnyUrl | str, meta: dict[str, Any] | None = None
) -> mcp.types.ReadResourceResult:
) -> mcp_types.ReadResourceResult:
"""Send a resources/read request and return the complete MCP protocol result.
Args:
@ -196,7 +196,7 @@ class ClientResourcesMixin:
meta (dict[str, Any] | None, optional): Request metadata (e.g., for SEP-1686 tasks). Defaults to None.
Returns:
mcp.types.ReadResourceResult: The complete response object from the protocol,
mcp_types.ReadResourceResult: The complete response object from the protocol,
containing the resource contents and any additional metadata.
Raises:
@ -218,22 +218,22 @@ class ClientResourcesMixin:
# Inject trace context into meta for propagation to server
propagated_meta = inject_trace_context(meta)
request_meta = cast(mcp.types.RequestParams.Meta | None, propagated_meta)
request_meta = cast(mcp_types.RequestParams.Meta | None, propagated_meta)
# If meta provided, use send_request for SEP-1686 task support
if propagated_meta:
task_dict = propagated_meta.get("modelcontextprotocol.io/task")
request = mcp.types.ReadResourceRequest(
params=mcp.types.ReadResourceRequestParams(
request = mcp_types.ReadResourceRequest(
params=mcp_types.ReadResourceRequestParams(
uri=uri,
task=mcp.types.TaskMetadata(**task_dict) if task_dict else None,
task=mcp_types.TaskMetadata(**task_dict) if task_dict else None,
_meta=request_meta, # type: ignore[unknown-argument] # pydantic alias
)
)
result = await self._await_with_session_monitoring(
self.session.send_request(
request=request, # type: ignore[arg-type] # ty:ignore[invalid-argument-type]
result_type=mcp.types.ReadResourceResult,
result_type=mcp_types.ReadResourceResult,
)
)
else:
@ -250,7 +250,7 @@ class ClientResourcesMixin:
version: str | None = None,
meta: dict[str, Any] | None = None,
task: Literal[False] = False,
) -> list[mcp.types.TextResourceContents | mcp.types.BlobResourceContents]: ...
) -> list[mcp_types.TextResourceContents | mcp_types.BlobResourceContents]: ...
@overload
async def read_resource(
@ -274,7 +274,7 @@ class ClientResourcesMixin:
task_id: str | None = None,
ttl: int = 60000,
) -> (
list[mcp.types.TextResourceContents | mcp.types.BlobResourceContents]
list[mcp_types.TextResourceContents | mcp_types.BlobResourceContents]
| ResourceTask
):
"""Read the contents of a resource or resolved template.
@ -288,7 +288,7 @@ class ClientResourcesMixin:
ttl (int): Time to keep results available in milliseconds (default 60s).
Returns:
list[mcp.types.TextResourceContents | mcp.types.BlobResourceContents] | ResourceTask:
list[mcp_types.TextResourceContents | mcp_types.BlobResourceContents] | ResourceTask:
A list of content objects if task=False, or a ResourceTask object if task=True.
Raises:
@ -341,15 +341,15 @@ class ClientResourcesMixin:
# Per SEP-1686 final spec: client sends only ttl, server generates taskId
# Inject trace context into meta for propagation to server
propagated_meta = inject_trace_context(meta)
request_meta = cast(mcp.types.RequestParams.Meta | None, propagated_meta)
request_meta = cast(mcp_types.RequestParams.Meta | None, propagated_meta)
if isinstance(uri, str):
uri = AnyUrl(uri)
request = mcp.types.ReadResourceRequest(
params=mcp.types.ReadResourceRequestParams(
request = mcp_types.ReadResourceRequest(
params=mcp_types.ReadResourceRequestParams(
uri=uri,
task=mcp.types.TaskMetadata(ttl=ttl),
task=mcp_types.TaskMetadata(ttl=ttl),
_meta=request_meta, # type: ignore[unknown-argument] # pydantic alias
)
)
@ -363,7 +363,7 @@ class ClientResourcesMixin:
)
raw_result = wrapped_result.root
if isinstance(raw_result, mcp.types.CreateTaskResult):
if isinstance(raw_result, mcp_types.CreateTaskResult):
# Task was accepted - extract task info from CreateTaskResult
server_task_id = raw_result.task.taskId
self._submitted_task_ids.add(server_task_id)

10
fastmcp_slim/fastmcp/client/mixins/task_management.py
View file

@ -4,12 +4,12 @@ from __future__ import annotations
from typing import TYPE_CHECKING, Any
import mcp.types
import mcp_types
from mcp import McpError
if TYPE_CHECKING:
from fastmcp.client.client import Client
from mcp.types import (
from mcp_types import (
CancelTaskRequest,
CancelTaskRequestParams,
GetTaskPayloadRequest,
@ -112,7 +112,7 @@ class ClientTaskManagementMixin:
server_response = await self._await_with_session_monitoring(
self.session.send_request(
request=request, # type: ignore[invalid-argument-type] # ty:ignore[invalid-argument-type]
result_type=mcp.types.ListTasksResult,
result_type=mcp_types.ListTasksResult,
)
)
@ -132,7 +132,7 @@ class ClientTaskManagementMixin:
return {"tasks": tasks, "nextCursor": None}
async def cancel_task(self: Client, task_id: str) -> mcp.types.CancelTaskResult:
async def cancel_task(self: Client, task_id: str) -> mcp_types.CancelTaskResult:
"""Cancel a task, transitioning it to cancelled state.
Sends a 'tasks/cancel' MCP protocol request. Task will halt execution
@ -152,6 +152,6 @@ class ClientTaskManagementMixin:
return await self._await_with_session_monitoring(
self.session.send_request(
request=request, # type: ignore[invalid-argument-type] # ty:ignore[invalid-argument-type]
result_type=mcp.types.CancelTaskResult,
result_type=mcp_types.CancelTaskResult,
)
)

40
fastmcp_slim/fastmcp/client/mixins/tools.py
View file

@ -6,7 +6,7 @@ import uuid
import weakref
from typing import TYPE_CHECKING, Any, Literal, cast, overload
import mcp.types
import mcp_types
from opentelemetry.trace import Status, StatusCode
from pydantic import RootModel
@ -29,7 +29,7 @@ logger = get_logger(__name__)
AUTO_PAGINATION_MAX_PAGES = 250
# Type alias for task response union (SEP-1686 graceful degradation)
ToolTaskResponseUnion = RootModel[mcp.types.CreateTaskResult | mcp.types.CallToolResult]
ToolTaskResponseUnion = RootModel[mcp_types.CreateTaskResult | mcp_types.CallToolResult]
class ClientToolsMixin:
@ -39,14 +39,14 @@ class ClientToolsMixin:
async def list_tools_mcp(
self: Client, *, cursor: str | None = None
) -> mcp.types.ListToolsResult:
) -> mcp_types.ListToolsResult:
"""Send a tools/list request and return the complete MCP protocol result.
Args:
cursor: Optional pagination cursor from a previous request's nextCursor.
Returns:
mcp.types.ListToolsResult: The complete response object from the protocol,
mcp_types.ListToolsResult: The complete response object from the protocol,
containing the list of tools and any additional metadata.
Raises:
@ -69,7 +69,7 @@ class ClientToolsMixin:
async def list_tools(
self: Client,
max_pages: int = AUTO_PAGINATION_MAX_PAGES,
) -> list[mcp.types.Tool]:
) -> list[mcp_types.Tool]:
"""Retrieve all tools available on the server.
This method automatically fetches all pages if the server paginates results,
@ -80,13 +80,13 @@ class ClientToolsMixin:
max_pages: Maximum number of pages to fetch before raising. Defaults to 250.
Returns:
list[mcp.types.Tool]: A list of all Tool objects.
list[mcp_types.Tool]: A list of all Tool objects.
Raises:
RuntimeError: If the page limit is reached before pagination completes.
McpError: If the request results in a TimeoutError | JSONRPCError
"""
all_tools: list[mcp.types.Tool] = []
all_tools: list[mcp_types.Tool] = []
cursor: str | None = None
seen_cursors: set[str] = set()
@ -122,7 +122,7 @@ class ClientToolsMixin:
progress_handler: ProgressHandler | None = None,
timeout: datetime.timedelta | float | int | None = None,
meta: dict[str, Any] | None = None,
) -> mcp.types.CallToolResult:
) -> 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
@ -139,7 +139,7 @@ class ClientToolsMixin:
can access this via `context.request_context.meta`. Defaults to None.
Returns:
mcp.types.CallToolResult: The complete response object from the protocol,
mcp_types.CallToolResult: The complete response object from the protocol,
containing the tool result and any additional metadata.
Raises:
@ -174,7 +174,7 @@ class ClientToolsMixin:
span.set_attribute("error.type", "tool_error")
description = ""
if result.content and isinstance(
result.content[0], mcp.types.TextContent
result.content[0], mcp_types.TextContent
):
description = result.content[0].text
span.set_status(Status(StatusCode.ERROR, description))
@ -184,10 +184,10 @@ class ClientToolsMixin:
async def _parse_call_tool_result(
self: Client,
name: str,
result: mcp.types.CallToolResult,
result: mcp_types.CallToolResult,
raise_on_error: bool = False,
) -> CallToolResult:
"""Parse an mcp.types.CallToolResult into our CallToolResult dataclass.
"""Parse an mcp_types.CallToolResult into our CallToolResult dataclass.
Args:
name: Tool name (for schema lookup)
@ -342,14 +342,14 @@ class ClientToolsMixin:
# Per SEP-1686 final spec: client sends only ttl, server generates taskId
# Inject trace context into meta for propagation to server
propagated_meta = inject_trace_context(meta)
request_meta = cast(mcp.types.RequestParams.Meta | None, propagated_meta)
request_meta = cast(mcp_types.RequestParams.Meta | None, propagated_meta)
# Build request with task metadata
request = mcp.types.CallToolRequest(
params=mcp.types.CallToolRequestParams(
request = mcp_types.CallToolRequest(
params=mcp_types.CallToolRequestParams(
name=name,
arguments=arguments or {},
task=mcp.types.TaskMetadata(ttl=ttl),
task=mcp_types.TaskMetadata(ttl=ttl),
_meta=request_meta, # type: ignore[unknown-argument] # pydantic alias
)
)
@ -364,7 +364,7 @@ class ClientToolsMixin:
)
raw_result = wrapped_result.root
if isinstance(raw_result, mcp.types.CreateTaskResult):
if isinstance(raw_result, mcp_types.CreateTaskResult):
# Task was accepted - extract task info from CreateTaskResult
server_task_id = raw_result.task.taskId
self._submitted_task_ids.add(server_task_id)
@ -393,13 +393,13 @@ class ClientToolsMixin:
async def _parse_call_tool_result(
name: str,
result: mcp.types.CallToolResult,
result: mcp_types.CallToolResult,
tool_output_schemas: dict[str, dict[str, Any] | None],
list_tools_fn: Any, # Callable[[], Awaitable[None]]
client_name: str | None = None,
raise_on_error: bool = False,
) -> CallToolResult:
"""Parse an mcp.types.CallToolResult into our CallToolResult dataclass.
"""Parse an mcp_types.CallToolResult into our CallToolResult dataclass.
Args:
name: Tool name (for schema lookup)
@ -419,7 +419,7 @@ async def _parse_call_tool_result(
data = None
if result.isError and raise_on_error:
if result.content and isinstance(result.content[0], mcp.types.TextContent):
if result.content and isinstance(result.content[0], mcp_types.TextContent):
msg = result.content[0].text
else:
msg = f"Tool '{name}' returned an error"

24
fastmcp_slim/fastmcp/client/roots.py
View file

@ -2,13 +2,13 @@ import inspect
from collections.abc import Awaitable, Callable
from typing import TypeAlias, cast
import mcp.types
import mcp_types
import pydantic
from mcp import ClientSession
from mcp.client.session import ListRootsFnT
from mcp.shared.context import LifespanContextT, RequestContext
RootsList: TypeAlias = list[str] | list[mcp.types.Root] | list[str | mcp.types.Root]
RootsList: TypeAlias = list[str] | list[mcp_types.Root] | list[str | mcp_types.Root]
RootsHandler: TypeAlias = (
Callable[[RequestContext[ClientSession, LifespanContextT]], RootsList]
@ -16,15 +16,15 @@ RootsHandler: TypeAlias = (
)
def convert_roots_list(roots: RootsList) -> list[mcp.types.Root]:
def convert_roots_list(roots: RootsList) -> list[mcp_types.Root]:
roots_list = []
for r in roots:
if isinstance(r, mcp.types.Root):
if isinstance(r, mcp_types.Root):
roots_list.append(r)
elif isinstance(r, pydantic.FileUrl):
roots_list.append(mcp.types.Root(uri=r))
roots_list.append(mcp_types.Root(uri=r))
elif isinstance(r, str):
roots_list.append(mcp.types.Root(uri=pydantic.FileUrl(r)))
roots_list.append(mcp_types.Root(uri=pydantic.FileUrl(r)))
else:
raise ValueError(f"Invalid root: {r}")
return roots_list
@ -49,8 +49,8 @@ def _create_roots_callback_from_roots(
async def _roots_callback(
context: RequestContext[ClientSession, LifespanContextT],
) -> mcp.types.ListRootsResult:
return mcp.types.ListRootsResult(roots=roots)
) -> mcp_types.ListRootsResult:
return mcp_types.ListRootsResult(roots=roots)
return _roots_callback
@ -61,17 +61,17 @@ def _create_roots_callback_from_fn(
) -> ListRootsFnT:
async def _roots_callback(
context: RequestContext[ClientSession, LifespanContextT],
) -> mcp.types.ListRootsResult | mcp.types.ErrorData:
) -> mcp_types.ListRootsResult | mcp_types.ErrorData:
try:
roots = fn(context)
if inspect.isawaitable(roots):
roots = await roots
return mcp.types.ListRootsResult(
return mcp_types.ListRootsResult(
roots=convert_roots_list(cast(RootsList, roots))
)
except Exception as e:
return mcp.types.ErrorData(
code=mcp.types.INTERNAL_ERROR,
return mcp_types.ErrorData(
code=mcp_types.INTERNAL_ERROR,
message=str(e),
)

14
fastmcp_slim/fastmcp/client/sampling/__init__.py
View file

@ -2,13 +2,13 @@ import inspect
from collections.abc import Awaitable, Callable
from typing import TypeAlias, TypeVar, cast
import mcp.types
import mcp_types
from mcp import ClientSession, CreateMessageResult
from mcp.client.session import SamplingFnT
from mcp.server.session import ServerSession
from mcp.shared.context import LifespanContextT, RequestContext
from mcp.types import CreateMessageRequestParams as SamplingParams
from mcp.types import CreateMessageResultWithTools, SamplingMessage
from mcp_types import CreateMessageRequestParams as SamplingParams
from mcp_types import CreateMessageResultWithTools, SamplingMessage
# Result type that handlers can return
SamplingHandlerResult: TypeAlias = (
@ -47,7 +47,7 @@ def create_sampling_callback(
async def _sampling_handler(
context,
params: SamplingParams,
) -> CreateMessageResult | CreateMessageResultWithTools | mcp.types.ErrorData:
) -> CreateMessageResult | CreateMessageResultWithTools | mcp_types.ErrorData:
try:
result = sampling_handler(params.messages, params, context)
if inspect.isawaitable(result):
@ -59,12 +59,12 @@ def create_sampling_callback(
result = CreateMessageResult(
role="assistant",
model="fastmcp-slim",
content=mcp.types.TextContent(type="text", text=result),
content=mcp_types.TextContent(type="text", text=result),
)
return result
except Exception as e:
return mcp.types.ErrorData(
code=mcp.types.INTERNAL_ERROR,
return mcp_types.ErrorData(
code=mcp_types.INTERNAL_ERROR,
message=str(e),
)

4
fastmcp_slim/fastmcp/client/sampling/handlers/anthropic.py
View file

@ -3,7 +3,7 @@
from collections.abc import Iterator, Sequence
from typing import Any
from mcp.types import (
from mcp_types import (
AudioContent,
CreateMessageResult,
CreateMessageResultWithTools,
@ -18,7 +18,7 @@ from mcp.types import (
ToolResultContent,
ToolUseContent,
)
from mcp.types import CreateMessageRequestParams as SamplingParams
from mcp_types import CreateMessageRequestParams as SamplingParams
try:
from anthropic import AsyncAnthropic

6
fastmcp_slim/fastmcp/client/sampling/handlers/google_genai.py
View file

@ -33,7 +33,7 @@ except ImportError as e:
from mcp import ClientSession, ServerSession
from mcp.shared.context import LifespanContextT, RequestContext
from mcp.types import (
from mcp_types import (
AudioContent,
CreateMessageResult,
CreateMessageResultWithTools,
@ -47,8 +47,8 @@ from mcp.types import (
ToolResultContent,
ToolUseContent,
)
from mcp.types import CreateMessageRequestParams as SamplingParams
from mcp.types import Tool as MCPTool
from mcp_types import CreateMessageRequestParams as SamplingParams
from mcp_types import Tool as MCPTool
__all__ = ["GoogleGenaiSamplingHandler"]

4
fastmcp_slim/fastmcp/client/sampling/handlers/openai.py
View file

@ -6,7 +6,7 @@ from typing import Any, Literal, get_args
from mcp import ClientSession, ServerSession
from mcp.shared.context import LifespanContextT, RequestContext
from mcp.types import (
from mcp_types import (
AudioContent,
CreateMessageResult,
CreateMessageResultWithTools,
@ -20,7 +20,7 @@ from mcp.types import (
ToolResultContent,
ToolUseContent,
)
from mcp.types import CreateMessageRequestParams as SamplingParams
from mcp_types import CreateMessageRequestParams as SamplingParams
try:
from openai import AsyncOpenAI

34
fastmcp_slim/fastmcp/client/tasks.py
View file

@ -11,8 +11,8 @@ from collections.abc import Awaitable, Callable
from datetime import datetime, timezone
from typing import TYPE_CHECKING, Generic, TypeVar
import mcp.types
from mcp.types import GetTaskResult, TaskStatusNotification
import mcp_types
from mcp_types import GetTaskResult, TaskStatusNotification
from fastmcp.client.messages import Message, MessageHandler
from fastmcp.exceptions import ToolError
@ -33,7 +33,7 @@ class TaskNotificationHandler(MessageHandler):
async def dispatch(self, message: Message) -> None:
"""Dispatch messages, including task status notifications."""
if isinstance(message, mcp.types.ServerNotification):
if isinstance(message, mcp_types.ServerNotification):
if isinstance(message.root, TaskStatusNotification):
client = self._client_ref()
if client:
@ -370,7 +370,7 @@ class ToolTask(Task["CallToolResult"]):
result = self._immediate_result
if result.is_error and self._raise_on_error:
if result.content and isinstance(
result.content[0], mcp.types.TextContent
result.content[0], mcp_types.TextContent
):
msg = result.content[0].text
else:
@ -389,13 +389,13 @@ class ToolTask(Task["CallToolResult"]):
# Convert to CallToolResult if needed and parse
if isinstance(raw_result, dict):
# Raw dict from get_task_result - parse as CallToolResult
mcp_result = mcp.types.CallToolResult.model_validate(raw_result)
mcp_result = mcp_types.CallToolResult.model_validate(raw_result)
result = await self._client._parse_call_tool_result(
self._tool_name,
mcp_result,
raise_on_error=self._raise_on_error,
)
elif isinstance(raw_result, mcp.types.CallToolResult):
elif isinstance(raw_result, mcp_types.CallToolResult):
# Already a CallToolResult from MCP protocol - parse it
result = await self._client._parse_call_tool_result(
self._tool_name,
@ -407,7 +407,7 @@ class ToolTask(Task["CallToolResult"]):
if hasattr(raw_result, "content") and hasattr(
raw_result, "structured_content"
):
mcp_result = mcp.types.CallToolResult(
mcp_result = mcp_types.CallToolResult(
content=raw_result.content,
structuredContent=raw_result.structured_content,
_meta=raw_result.meta, # type: ignore[call-arg] # _meta is Pydantic alias for meta field
@ -426,7 +426,7 @@ class ToolTask(Task["CallToolResult"]):
return result
class PromptTask(Task[mcp.types.GetPromptResult]):
class PromptTask(Task[mcp_types.GetPromptResult]):
"""
Represents a prompt call that may execute in background or immediately.
@ -443,7 +443,7 @@ class PromptTask(Task[mcp.types.GetPromptResult]):
client: Client,
task_id: str,
prompt_name: str,
immediate_result: mcp.types.GetPromptResult | None = None,
immediate_result: mcp_types.GetPromptResult | None = None,
):
"""
Create a PromptTask wrapper.
@ -457,7 +457,7 @@ class PromptTask(Task[mcp.types.GetPromptResult]):
super().__init__(client, task_id, immediate_result)
self._prompt_name = prompt_name
async def result(self) -> mcp.types.GetPromptResult:
async def result(self) -> mcp_types.GetPromptResult:
"""Wait for and return the prompt result.
If server executed immediately, returns the immediate result.
@ -484,7 +484,7 @@ class PromptTask(Task[mcp.types.GetPromptResult]):
mcp_result = await self._client.get_task_result(self._task_id)
# Parse as GetPromptResult
result = mcp.types.GetPromptResult.model_validate(mcp_result)
result = mcp_types.GetPromptResult.model_validate(mcp_result)
# Cache before returning
self._cached_result = result
@ -492,7 +492,7 @@ class PromptTask(Task[mcp.types.GetPromptResult]):
class ResourceTask(
Task[list[mcp.types.TextResourceContents | mcp.types.BlobResourceContents]]
Task[list[mcp_types.TextResourceContents | mcp_types.BlobResourceContents]]
):
"""
Represents a resource read that may execute in background or immediately.
@ -511,7 +511,7 @@ class ResourceTask(
task_id: str,
uri: str,
immediate_result: list[
mcp.types.TextResourceContents | mcp.types.BlobResourceContents
mcp_types.TextResourceContents | mcp_types.BlobResourceContents
]
| None = None,
):
@ -529,7 +529,7 @@ class ResourceTask(
async def result(
self,
) -> list[mcp.types.TextResourceContents | mcp.types.BlobResourceContents]:
) -> list[mcp_types.TextResourceContents | mcp_types.BlobResourceContents]:
"""Wait for and return the resource contents.
If server executed immediately, returns the immediate result.
@ -556,7 +556,7 @@ class ResourceTask(
mcp_result = await self._client.get_task_result(self._task_id)
# Parse as ReadResourceResult or extract contents
if isinstance(mcp_result, mcp.types.ReadResourceResult):
if isinstance(mcp_result, mcp_types.ReadResourceResult):
# Already parsed by TasksResponse - extract contents
result = list(mcp_result.contents)
elif isinstance(mcp_result, dict) and "contents" in mcp_result:
@ -566,11 +566,11 @@ class ResourceTask(
if isinstance(item, dict):
if "blob" in item:
parsed_contents.append(
mcp.types.BlobResourceContents.model_validate(item)
mcp_types.BlobResourceContents.model_validate(item)
)
else:
parsed_contents.append(
mcp.types.TextResourceContents.model_validate(item)
mcp_types.TextResourceContents.model_validate(item)
)
else:
parsed_contents.append(item)

6
fastmcp_slim/fastmcp/client/transports/base.py
View file

@ -5,7 +5,7 @@ from collections.abc import AsyncIterator
from typing import Literal, TypeVar
import httpx
import mcp.types
import mcp_types
from mcp import ClientSession
from mcp.client.session import (
ElicitationFnT,
@ -25,12 +25,12 @@ class SessionKwargs(TypedDict, total=False):
read_timeout_seconds: datetime.timedelta | None
sampling_callback: SamplingFnT | None
sampling_capabilities: mcp.types.SamplingCapability | None
sampling_capabilities: mcp_types.SamplingCapability | None
list_roots_callback: ListRootsFnT | None
logging_callback: LoggingFnT | None
elicitation_callback: ElicitationFnT | None
message_handler: MessageHandlerFnT | None
client_info: mcp.types.Implementation | None
client_info: mcp_types.Implementation | None
class ClientTransport(abc.ABC):

2
fastmcp_slim/fastmcp/contrib/bulk_tool_caller/bulk_tool_caller.py
View file

@ -1,6 +1,6 @@
from typing import Any
from mcp.types import CallToolResult, TextContent
from mcp_types import CallToolResult, TextContent
from pydantic import BaseModel, Field
from fastmcp import FastMCP

2
fastmcp_slim/fastmcp/experimental/transforms/code_mode.py
View file

@ -7,7 +7,7 @@ from typing import TYPE_CHECKING, Annotated, Any, Literal, Protocol
if TYPE_CHECKING:
from pydantic_monty import ResourceLimits
from mcp.types import TextContent
from mcp_types import TextContent
from pydantic import Field
from fastmcp.exceptions import NotFoundError, ToolError

12
fastmcp_slim/fastmcp/prompts/base.py
View file

@ -14,9 +14,9 @@ if TYPE_CHECKING:
from docket.execution import Execution
from fastmcp.prompts.function_prompt import FunctionPrompt
import mcp.types
import mcp_types
from mcp import GetPromptResult
from mcp.types import (
from mcp_types import (
AudioContent,
EmbeddedResource,
Icon,
@ -24,8 +24,8 @@ from mcp.types import (
PromptMessage,
TextContent,
)
from mcp.types import Prompt as SDKPrompt
from mcp.types import PromptArgument as SDKPromptArgument
from mcp_types import Prompt as SDKPrompt
from mcp_types import PromptArgument as SDKPromptArgument
from pydantic import Field
from pydantic.json_schema import SkipJsonSchema
@ -330,13 +330,13 @@ class Prompt(FastMCPComponent):
self,
arguments: dict[str, Any] | None,
task_meta: TaskMeta,
) -> mcp.types.CreateTaskResult: ...
) -> mcp_types.CreateTaskResult: ...
async def _render(
self,
arguments: dict[str, Any] | None = None,
task_meta: TaskMeta | None = None,
) -> PromptResult | mcp.types.CreateTaskResult:
) -> PromptResult | mcp_types.CreateTaskResult:
"""Server entry point that handles task routing.
This allows ANY Prompt subclass to support background execution by setting

2
fastmcp_slim/fastmcp/prompts/function_prompt.py
View file

@ -21,7 +21,7 @@ from typing import (
)
import pydantic_core
from mcp.types import Icon
from mcp_types import Icon
from pydantic.json_schema import SkipJsonSchema
import fastmcp

20
fastmcp_slim/fastmcp/resources/base.py
View file

@ -7,7 +7,7 @@ import json
from collections.abc import Callable
from typing import TYPE_CHECKING, Annotated, Any, ClassVar, overload
import mcp.types
import mcp_types
if TYPE_CHECKING:
from docket import Docket
@ -17,8 +17,8 @@ if TYPE_CHECKING:
import pydantic
import pydantic_core
from mcp.types import Annotations, Icon
from mcp.types import Resource as SDKResource
from mcp_types import Annotations, Icon
from mcp_types import Resource as SDKResource
from pydantic import (
AnyUrl,
ConfigDict,
@ -93,7 +93,7 @@ class ResourceContent(pydantic.BaseModel):
def to_mcp_resource_contents(
self, uri: AnyUrl | str
) -> mcp.types.TextResourceContents | mcp.types.BlobResourceContents:
) -> mcp_types.TextResourceContents | mcp_types.BlobResourceContents:
"""Convert to MCP resource contents type.
Args:
@ -103,14 +103,14 @@ class ResourceContent(pydantic.BaseModel):
TextResourceContents for str content, BlobResourceContents for bytes
"""
if isinstance(self.content, str):
return mcp.types.TextResourceContents(
return mcp_types.TextResourceContents(
uri=AnyUrl(uri) if isinstance(uri, str) else uri,
text=self.content,
mimeType=self.mime_type or "text/plain",
_meta=self.meta, # type: ignore[call-arg] # _meta is Pydantic alias for meta field
)
else:
return mcp.types.BlobResourceContents(
return mcp_types.BlobResourceContents(
uri=AnyUrl(uri) if isinstance(uri, str) else uri,
blob=base64.b64encode(self.content).decode(),
mimeType=self.mime_type or "application/octet-stream",
@ -199,7 +199,7 @@ class ResourceResult(pydantic.BaseModel):
f"contents must be str, bytes, or list[ResourceContent], got {type(contents).__name__}"
)
def to_mcp_result(self, uri: AnyUrl | str) -> mcp.types.ReadResourceResult:
def to_mcp_result(self, uri: AnyUrl | str) -> mcp_types.ReadResourceResult:
"""Convert to MCP ReadResourceResult.
Args:
@ -209,7 +209,7 @@ class ResourceResult(pydantic.BaseModel):
MCP ReadResourceResult with converted contents
"""
mcp_contents = [item.to_mcp_resource_contents(uri) for item in self.contents]
return mcp.types.ReadResourceResult(
return mcp_types.ReadResourceResult(
contents=mcp_contents,
_meta=self.meta, # type: ignore[call-arg] # _meta is Pydantic alias for meta field
)
@ -366,11 +366,11 @@ class Resource(FastMCPComponent):
async def _read(self, task_meta: None = None) -> ResourceResult: ...
@overload
async def _read(self, task_meta: TaskMeta) -> mcp.types.CreateTaskResult: ...
async def _read(self, task_meta: TaskMeta) -> mcp_types.CreateTaskResult: ...
async def _read(
self, task_meta: TaskMeta | None = None
) -> ResourceResult | mcp.types.CreateTaskResult:
) -> ResourceResult | mcp_types.CreateTaskResult:
"""Server entry point that handles task routing.
This allows ANY Resource subclass to support background execution by setting

2
fastmcp_slim/fastmcp/resources/function_resource.py
View file

@ -18,7 +18,7 @@ from typing import (
runtime_checkable,
)
from mcp.types import Annotations, Icon
from mcp_types import Annotations, Icon
from pydantic import AnyUrl
from pydantic.json_schema import SkipJsonSchema

14
fastmcp_slim/fastmcp/resources/template.py
View file

@ -9,14 +9,14 @@ 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
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 mcp_types import ResourceTemplate as SDKResourceTemplate
from pydantic import (
Field,
field_validator,
@ -264,11 +264,11 @@ class ResourceTemplate(FastMCPComponent):
@overload
async def _read(
self, uri: str, params: dict[str, Any], task_meta: TaskMeta
) -> mcp.types.CreateTaskResult: ...
) -> mcp_types.CreateTaskResult: ...
async def _read(
self, uri: str, params: dict[str, Any], task_meta: TaskMeta | None = None
) -> ResourceResult | mcp.types.CreateTaskResult:
) -> ResourceResult | mcp_types.CreateTaskResult:
"""Server entry point that handles task routing.
This allows ANY ResourceTemplate subclass to support background execution
@ -402,11 +402,11 @@ class FunctionResourceTemplate(ResourceTemplate):
@overload
async def _read(
self, uri: str, params: dict[str, Any], task_meta: TaskMeta
) -> mcp.types.CreateTaskResult: ...
) -> mcp_types.CreateTaskResult: ...
async def _read(
self, uri: str, params: dict[str, Any], task_meta: TaskMeta | None = None
) -> ResourceResult | mcp.types.CreateTaskResult:
) -> ResourceResult | mcp_types.CreateTaskResult:
"""Optimized server entry point that skips ephemeral resource creation.
For FunctionResourceTemplate, we can call read() directly instead of

26
fastmcp_slim/fastmcp/server/context.py
View file

@ -10,18 +10,18 @@ from dataclasses import dataclass
from logging import Logger
from typing import Any, Literal, overload
import mcp.types
import mcp_types
from mcp import LoggingLevel, ServerSession
from mcp.server.lowlevel.server import request_ctx
from mcp.shared.context import RequestContext
from mcp.types import (
from mcp_types import (
GetPromptResult,
ModelPreferences,
Root,
SamplingMessage,
)
from mcp.types import Prompt as SDKPrompt
from mcp.types import Resource as SDKResource
from mcp_types import Prompt as SDKPrompt
from mcp_types import Resource as SDKResource
from pydantic.networks import AnyUrl
from starlette.requests import Request
from typing_extensions import TypeVar
@ -486,8 +486,8 @@ class Context:
List of Resource objects available on the server
"""
return await self._paginate_list(
request_factory=lambda cursor: mcp.types.ListResourcesRequest(
params=mcp.types.PaginatedRequestParams(cursor=cursor)
request_factory=lambda cursor: mcp_types.ListResourcesRequest(
params=mcp_types.PaginatedRequestParams(cursor=cursor)
if cursor
else None
),
@ -502,8 +502,8 @@ class Context:
List of Prompt objects available on the server
"""
return await self._paginate_list(
request_factory=lambda cursor: mcp.types.ListPromptsRequest(
params=mcp.types.PaginatedRequestParams(cursor=cursor)
request_factory=lambda cursor: mcp_types.ListPromptsRequest(
params=mcp_types.PaginatedRequestParams(cursor=cursor)
if cursor
else None
),
@ -524,7 +524,7 @@ class Context:
The prompt result
"""
result = await self.fastmcp.render_prompt(name, arguments)
if isinstance(result, mcp.types.CreateTaskResult):
if isinstance(result, mcp_types.CreateTaskResult):
raise RuntimeError(
"Unexpected CreateTaskResult: Context calls should not have task metadata"
)
@ -540,7 +540,7 @@ class Context:
ResourceResult with contents
"""
result = await self.fastmcp.read_resource(str(uri))
if isinstance(result, mcp.types.CreateTaskResult):
if isinstance(result, mcp_types.CreateTaskResult):
raise RuntimeError(
"Unexpected CreateTaskResult: Context calls should not have task metadata"
)
@ -787,14 +787,14 @@ class Context:
return result.roots
async def send_notification(
self, notification: mcp.types.ServerNotificationType
self, notification: mcp_types.ServerNotificationType
) -> None:
"""Send a notification to the client immediately.
Args:
notification: An MCP notification instance (e.g., ToolListChangedNotification())
"""
await self.session.send_notification(mcp.types.ServerNotification(notification))
await self.session.send_notification(mcp_types.ServerNotification(notification))
async def close_sse_stream(self) -> None:
"""Close the current response stream to trigger client reconnection.
@ -1206,7 +1206,7 @@ class Context:
self,
message: str,
schema: dict[str, Any],
) -> mcp.types.ElicitResult:
) -> mcp_types.ElicitResult:
"""Send an elicitation request from a background task (SEP-1686).
This method handles elicitation when running in a Docket worker context,

2
fastmcp_slim/fastmcp/server/event_store.py
View file

@ -15,7 +15,7 @@ from key_value.aio.protocols import AsyncKeyValue
from key_value.aio.stores.memory import MemoryStore
from mcp.server.streamable_http import EventCallback, EventId, EventMessage, StreamId
from mcp.server.streamable_http import EventStore as SDKEventStore
from mcp.types import JSONRPCMessage
from mcp_types import JSONRPCMessage
from fastmcp.utilities.logging import get_logger
from fastmcp.utilities.types import FastMCPBaseModel

48
fastmcp_slim/fastmcp/server/low_level.py
View file

@ -6,7 +6,7 @@ from contextlib import AsyncExitStack
from typing import TYPE_CHECKING, Any, cast
import anyio
import mcp.types
import mcp_types
from anyio.streams.memory import MemoryObjectReceiveStream, MemoryObjectSendStream
from mcp import LoggingLevel, McpError
from mcp.server.lowlevel.server import (
@ -74,7 +74,7 @@ class MiddlewareServerSession(ServerSession):
async def _received_request(
self,
responder: RequestResponder[mcp.types.ClientRequest, mcp.types.ServerResult],
responder: RequestResponder[mcp_types.ClientRequest, mcp_types.ServerResult],
):
"""
Override the _received_request method to route special requests
@ -85,7 +85,7 @@ class MiddlewareServerSession(ServerSession):
import fastmcp.server.context
from fastmcp.server.middleware.middleware import MiddlewareContext
if isinstance(responder.request.root, mcp.types.InitializeRequest):
if isinstance(responder.request.root, mcp_types.InitializeRequest):
# The MCP SDK's ServerSession._received_request() handles the
# initialize request internally by calling responder.respond()
# to send the InitializeResult directly to the write stream, then
@ -96,11 +96,11 @@ class MiddlewareServerSession(ServerSession):
# capabilities), we wrap responder.respond() to capture the
# InitializeResult before it's sent, then return it from
# call_original_handler so it flows back through the middleware chain.
captured_response: mcp.types.ServerResult | None = None
captured_response: mcp_types.ServerResult | None = None
original_respond = responder.respond
async def capturing_respond(
response: mcp.types.ServerResult,
response: mcp_types.ServerResult,
) -> None:
nonlocal captured_response
captured_response = response
@ -110,10 +110,10 @@ class MiddlewareServerSession(ServerSession):
async def call_original_handler(
ctx: MiddlewareContext,
) -> mcp.types.InitializeResult | None:
) -> mcp_types.InitializeResult | None:
await super(MiddlewareServerSession, self)._received_request(responder)
if captured_response is not None and isinstance(
captured_response.root, mcp.types.InitializeResult
captured_response.root, mcp_types.InitializeResult
):
return captured_response.root
return None
@ -198,7 +198,7 @@ class LowLevelServer(_Server[LifespanResultT, RequestT]):
self,
notification_options: NotificationOptions,
experimental_capabilities: dict[str, dict[str, Any]],
) -> mcp.types.ServerCapabilities:
) -> mcp_types.ServerCapabilities:
"""Override to set capabilities.tasks as a first-class field per SEP-1686.
This ensures task capabilities appear in capabilities.tasks instead of
@ -273,12 +273,12 @@ class LowLevelServer(_Server[LifespanResultT, RequestT]):
[
Callable[
[AnyUrl],
Awaitable[mcp.types.ReadResourceResult | mcp.types.CreateTaskResult],
Awaitable[mcp_types.ReadResourceResult | mcp_types.CreateTaskResult],
]
],
Callable[
[AnyUrl],
Awaitable[mcp.types.ReadResourceResult | mcp.types.CreateTaskResult],
Awaitable[mcp_types.ReadResourceResult | mcp_types.CreateTaskResult],
],
]:
"""
@ -294,19 +294,19 @@ class LowLevelServer(_Server[LifespanResultT, RequestT]):
def decorator(
func: Callable[
[AnyUrl],
Awaitable[mcp.types.ReadResourceResult | mcp.types.CreateTaskResult],
Awaitable[mcp_types.ReadResourceResult | mcp_types.CreateTaskResult],
],
) -> Callable[
[AnyUrl],
Awaitable[mcp.types.ReadResourceResult | mcp.types.CreateTaskResult],
Awaitable[mcp_types.ReadResourceResult | mcp_types.CreateTaskResult],
]:
async def handler(
req: mcp.types.ReadResourceRequest,
) -> mcp.types.ServerResult:
req: mcp_types.ReadResourceRequest,
) -> mcp_types.ServerResult:
result = await func(req.params.uri)
return mcp.types.ServerResult(result)
return mcp_types.ServerResult(result)
self.request_handlers[mcp.types.ReadResourceRequest] = handler
self.request_handlers[mcp_types.ReadResourceRequest] = handler
return func
return decorator
@ -317,12 +317,12 @@ class LowLevelServer(_Server[LifespanResultT, RequestT]):
[
Callable[
[str, dict[str, Any] | None],
Awaitable[mcp.types.GetPromptResult | mcp.types.CreateTaskResult],
Awaitable[mcp_types.GetPromptResult | mcp_types.CreateTaskResult],
]
],
Callable[
[str, dict[str, Any] | None],
Awaitable[mcp.types.GetPromptResult | mcp.types.CreateTaskResult],
Awaitable[mcp_types.GetPromptResult | mcp_types.CreateTaskResult],
],
]:
"""
@ -338,19 +338,19 @@ class LowLevelServer(_Server[LifespanResultT, RequestT]):
def decorator(
func: Callable[
[str, dict[str, Any] | None],
Awaitable[mcp.types.GetPromptResult | mcp.types.CreateTaskResult],
Awaitable[mcp_types.GetPromptResult | mcp_types.CreateTaskResult],
],
) -> Callable[
[str, dict[str, Any] | None],
Awaitable[mcp.types.GetPromptResult | mcp.types.CreateTaskResult],
Awaitable[mcp_types.GetPromptResult | mcp_types.CreateTaskResult],
]:
async def handler(
req: mcp.types.GetPromptRequest,
) -> mcp.types.ServerResult:
req: mcp_types.GetPromptRequest,
) -> mcp_types.ServerResult:
result = await func(req.params.name, req.params.arguments)
return mcp.types.ServerResult(result)
return mcp_types.ServerResult(result)
self.request_handlers[mcp.types.GetPromptRequest] = handler
self.request_handlers[mcp_types.GetPromptRequest] = handler
return func
return decorator

2
fastmcp_slim/fastmcp/server/middleware/authorization.py
View file

@ -26,7 +26,7 @@ from __future__ import annotations
import logging
from collections.abc import Sequence
import mcp.types as mt
import mcp_types as mt
from fastmcp.exceptions import AuthorizationError
from fastmcp.prompts.base import Prompt, PromptResult

42
fastmcp_slim/fastmcp/server/middleware/caching.py
View file

@ -5,7 +5,7 @@ from collections.abc import Sequence
from logging import Logger
from typing import Any, TypedDict
import mcp.types
import mcp_types
import pydantic_core
from key_value.aio.adapters.pydantic import PydanticAdapter
from key_value.aio.protocols.key_value import AsyncKeyValue
@ -79,7 +79,7 @@ class CachableResourceResult(FastMCPBaseModel):
class CachableToolResult(FastMCPBaseModel):
content: list[mcp.types.ContentBlock]
content: list[mcp_types.ContentBlock]
structured_content: dict[str, Any] | None
meta: dict[str, Any] | None
is_error: bool = False
@ -107,10 +107,10 @@ class CachableMessage(FastMCPBaseModel):
role: str
content: (
mcp.types.TextContent
| mcp.types.ImageContent
| mcp.types.AudioContent
| mcp.types.EmbeddedResource
mcp_types.TextContent
| mcp_types.ImageContent
| mcp_types.AudioContent
| mcp_types.EmbeddedResource
)
@ -298,8 +298,8 @@ class ResponseCachingMiddleware(Middleware):
@override
async def on_list_tools(
self,
context: MiddlewareContext[mcp.types.ListToolsRequest],
call_next: CallNext[mcp.types.ListToolsRequest, Sequence[Tool]],
context: MiddlewareContext[mcp_types.ListToolsRequest],
call_next: CallNext[mcp_types.ListToolsRequest, Sequence[Tool]],
) -> Sequence[Tool]:
"""List tools from the cache, if caching is enabled, and the result is in the cache. Otherwise,
otherwise call the next middleware and store the result in the cache if caching is enabled."""
@ -339,8 +339,8 @@ class ResponseCachingMiddleware(Middleware):
@override
async def on_list_resources(
self,
context: MiddlewareContext[mcp.types.ListResourcesRequest],
call_next: CallNext[mcp.types.ListResourcesRequest, Sequence[Resource]],
context: MiddlewareContext[mcp_types.ListResourcesRequest],
call_next: CallNext[mcp_types.ListResourcesRequest, Sequence[Resource]],
) -> Sequence[Resource]:
"""List resources from the cache, if caching is enabled, and the result is in the cache. Otherwise,
otherwise call the next middleware and store the result in the cache if caching is enabled."""
@ -380,8 +380,8 @@ class ResponseCachingMiddleware(Middleware):
@override
async def on_list_prompts(
self,
context: MiddlewareContext[mcp.types.ListPromptsRequest],
call_next: CallNext[mcp.types.ListPromptsRequest, Sequence[Prompt]],
context: MiddlewareContext[mcp_types.ListPromptsRequest],
call_next: CallNext[mcp_types.ListPromptsRequest, Sequence[Prompt]],
) -> Sequence[Prompt]:
"""List prompts from the cache, if caching is enabled, and the result is in the cache. Otherwise,
otherwise call the next middleware and store the result in the cache if caching is enabled."""
@ -419,8 +419,8 @@ class ResponseCachingMiddleware(Middleware):
@override
async def on_call_tool(
self,
context: MiddlewareContext[mcp.types.CallToolRequestParams],
call_next: CallNext[mcp.types.CallToolRequestParams, ToolResult],
context: MiddlewareContext[mcp_types.CallToolRequestParams],
call_next: CallNext[mcp_types.CallToolRequestParams, ToolResult],
) -> ToolResult:
"""Call a tool from the cache, if caching is enabled, and the result is in the cache. Otherwise,
otherwise call the next middleware and store the result in the cache if caching is enabled."""
@ -454,8 +454,8 @@ class ResponseCachingMiddleware(Middleware):
@override
async def on_read_resource(
self,
context: MiddlewareContext[mcp.types.ReadResourceRequestParams],
call_next: CallNext[mcp.types.ReadResourceRequestParams, ResourceResult],
context: MiddlewareContext[mcp_types.ReadResourceRequestParams],
call_next: CallNext[mcp_types.ReadResourceRequestParams, ResourceResult],
) -> ResourceResult:
"""Read a resource from the cache, if caching is enabled, and the result is in the cache. Otherwise,
otherwise call the next middleware and store the result in the cache if caching is enabled."""
@ -484,8 +484,8 @@ class ResponseCachingMiddleware(Middleware):
@override
async def on_get_prompt(
self,
context: MiddlewareContext[mcp.types.GetPromptRequestParams],
call_next: CallNext[mcp.types.GetPromptRequestParams, PromptResult],
context: MiddlewareContext[mcp_types.GetPromptRequestParams],
call_next: CallNext[mcp_types.GetPromptRequestParams, PromptResult],
) -> PromptResult:
"""Get a prompt from the cache, if caching is enabled, and the result is in the cache. Otherwise,
otherwise call the next middleware and store the result in the cache if caching is enabled."""
@ -570,7 +570,7 @@ def _get_auth_partition_key() -> str:
def _make_call_tool_cache_key(
msg: mcp.types.CallToolRequestParams, auth_key: str = ANONYMOUS_AUTH_KEY
msg: mcp_types.CallToolRequestParams, auth_key: str = ANONYMOUS_AUTH_KEY
) -> str:
"""Make a cache key for a tool call using a stable hash of name and arguments."""
@ -578,7 +578,7 @@ def _make_call_tool_cache_key(
def _make_read_resource_cache_key(
msg: mcp.types.ReadResourceRequestParams, auth_key: str = ANONYMOUS_AUTH_KEY
msg: mcp_types.ReadResourceRequestParams, auth_key: str = ANONYMOUS_AUTH_KEY
) -> str:
"""Make a cache key for a resource read using a stable hash of URI."""
@ -586,7 +586,7 @@ def _make_read_resource_cache_key(
def _make_get_prompt_cache_key(
msg: mcp.types.GetPromptRequestParams, auth_key: str = ANONYMOUS_AUTH_KEY
msg: mcp_types.GetPromptRequestParams, auth_key: str = ANONYMOUS_AUTH_KEY
) -> str:
"""Make a cache key for a prompt get using a stable hash of name and arguments."""

2
fastmcp_slim/fastmcp/server/middleware/dereference.py
View file

@ -3,7 +3,7 @@
from collections.abc import Sequence
from typing import Any
import mcp.types as mt
import mcp_types as mt
from typing_extensions import override
from fastmcp.resources.template import ResourceTemplate

2
fastmcp_slim/fastmcp/server/middleware/error_handling.py
View file

@ -8,7 +8,7 @@ from typing import Any
import anyio
from mcp import McpError
from mcp.types import ErrorData
from mcp_types import ErrorData
from fastmcp.exceptions import NotFoundError

2
fastmcp_slim/fastmcp/server/middleware/middleware.py
View file

@ -13,7 +13,7 @@ from typing import (
runtime_checkable,
)
import mcp.types as mt
import mcp_types as mt
from typing_extensions import TypeVar
from fastmcp.prompts.base import Prompt, PromptResult

2
fastmcp_slim/fastmcp/server/middleware/rate_limiting.py
View file

@ -8,7 +8,7 @@ from typing import Any, cast
import anyio
from mcp import McpError
from mcp.types import ErrorData
from mcp_types import ErrorData
from .middleware import CallNext, Middleware, MiddlewareContext

4
fastmcp_slim/fastmcp/server/middleware/response_limiting.py
View file

@ -5,9 +5,9 @@ from __future__ import annotations
import logging
from typing import Any
import mcp.types as mt
import mcp_types as mt
import pydantic_core
from mcp.types import TextContent
from mcp_types import TextContent
from fastmcp.tools.base import ToolResult

16
fastmcp_slim/fastmcp/server/middleware/tool_injection.py
View file

@ -5,8 +5,8 @@ from collections.abc import Sequence
from logging import Logger
from typing import Annotated, Any
import mcp.types
from mcp.types import Prompt
import mcp_types
from mcp_types import Prompt
from pydantic import AnyUrl
from typing_extensions import override
@ -34,8 +34,8 @@ class ToolInjectionMiddleware(Middleware):
@override
async def on_list_tools(
self,
context: MiddlewareContext[mcp.types.ListToolsRequest],
call_next: CallNext[mcp.types.ListToolsRequest, Sequence[Tool]],
context: MiddlewareContext[mcp_types.ListToolsRequest],
call_next: CallNext[mcp_types.ListToolsRequest, Sequence[Tool]],
) -> Sequence[Tool]:
"""Inject tools into the response."""
return [*self._tools_to_inject, *await call_next(context)]
@ -43,8 +43,8 @@ class ToolInjectionMiddleware(Middleware):
@override
async def on_call_tool(
self,
context: MiddlewareContext[mcp.types.CallToolRequestParams],
call_next: CallNext[mcp.types.CallToolRequestParams, ToolResult],
context: MiddlewareContext[mcp_types.CallToolRequestParams],
call_next: CallNext[mcp_types.CallToolRequestParams, ToolResult],
) -> ToolResult:
"""Intercept tool calls to injected tools."""
if context.message.name in self._tools_to_inject_by_name:
@ -70,7 +70,7 @@ async def get_prompt(
arguments: Annotated[
dict[str, Any] | None, "The arguments to pass to the prompt."
] = None,
) -> mcp.types.GetPromptResult:
) -> mcp_types.GetPromptResult:
"""Render a prompt available on the server."""
return await context.get_prompt(name=name, arguments=arguments)
@ -99,7 +99,7 @@ class PromptToolMiddleware(ToolInjectionMiddleware):
super().__init__(tools=tools)
async def list_resources(context: Context) -> list[mcp.types.Resource]:
async def list_resources(context: Context) -> list[mcp_types.Resource]:
"""List resources available on the server."""
return await context.list_resources()

2
fastmcp_slim/fastmcp/server/mixins/lifespan.py
View file

@ -248,7 +248,7 @@ class LifespanMixin:
if not is_docket_available():
return
from mcp.types import (
from mcp_types import (
CancelTaskRequest,
GetTaskPayloadRequest,
GetTaskRequest,

58
fastmcp_slim/fastmcp/server/mixins/mcp_operations.py
View file

@ -5,9 +5,9 @@ from __future__ import annotations
from collections.abc import Awaitable, Callable, Sequence
from typing import TYPE_CHECKING, Any, TypeVar, cast
import mcp.types
import mcp_types
from mcp.shared.exceptions import McpError
from mcp.types import ContentBlock
from mcp_types import ContentBlock
from pydantic import AnyUrl
from fastmcp.exceptions import DisabledError, NotFoundError
@ -38,7 +38,7 @@ def _apply_pagination(
try:
return paginate_sequence(items, cursor, page_size)
except ValueError as e:
raise McpError(mcp.types.ErrorData(code=-32602, message=str(e))) from e
raise McpError(mcp_types.ErrorData(code=-32602, message=str(e))) from e
class MCPOperationsMixin:
@ -70,7 +70,7 @@ class MCPOperationsMixin:
# list_resource_templates SDK decorator doesn't pass the request to handlers,
# so we register directly to get cursor access for pagination
self._mcp_server.request_handlers[mcp.types.ListResourceTemplatesRequest] = (
self._mcp_server.request_handlers[mcp_types.ListResourceTemplatesRequest] = (
self._wrap_list_handler(self._list_resource_templates_mcp)
)
@ -86,18 +86,18 @@ class MCPOperationsMixin:
def _wrap_list_handler(
self: FastMCP, handler: Callable[..., Awaitable[Any]]
) -> Callable[..., Awaitable[mcp.types.ServerResult]]:
) -> Callable[..., Awaitable[mcp_types.ServerResult]]:
"""Wrap a list handler to pass the request and return ServerResult."""
async def wrapper(request: Any) -> mcp.types.ServerResult:
async def wrapper(request: Any) -> mcp_types.ServerResult:
result = await handler(request)
return mcp.types.ServerResult(result)
return mcp_types.ServerResult(result)
return wrapper
async def _list_tools_mcp(
self, request: mcp.types.ListToolsRequest
) -> mcp.types.ListToolsResult:
self, request: mcp_types.ListToolsRequest
) -> mcp_types.ListToolsResult:
"""
List all available tools, in the format expected by the low-level MCP
server. Supports pagination when list_page_size is configured.
@ -115,11 +115,11 @@ class MCPOperationsMixin:
request.params.cursor if request is not None and request.params else None
)
page, next_cursor = _apply_pagination(sdk_tools, cursor, server._list_page_size)
return mcp.types.ListToolsResult(tools=page, nextCursor=next_cursor)
return mcp_types.ListToolsResult(tools=page, nextCursor=next_cursor)
async def _list_resources_mcp(
self, request: mcp.types.ListResourcesRequest
) -> mcp.types.ListResourcesResult:
self, request: mcp_types.ListResourcesRequest
) -> mcp_types.ListResourcesResult:
"""
List all available resources, in the format expected by the low-level MCP
server. Supports pagination when list_page_size is configured.
@ -138,11 +138,11 @@ class MCPOperationsMixin:
page, next_cursor = _apply_pagination(
sdk_resources, cursor, server._list_page_size
)
return mcp.types.ListResourcesResult(resources=page, nextCursor=next_cursor)
return mcp_types.ListResourcesResult(resources=page, nextCursor=next_cursor)
async def _list_resource_templates_mcp(
self, request: mcp.types.ListResourceTemplatesRequest
) -> mcp.types.ListResourceTemplatesResult:
self, request: mcp_types.ListResourceTemplatesRequest
) -> mcp_types.ListResourceTemplatesResult:
"""
List all available resource templates, in the format expected by the low-level MCP
server. Supports pagination when list_page_size is configured.
@ -161,13 +161,13 @@ class MCPOperationsMixin:
page, next_cursor = _apply_pagination(
sdk_templates, cursor, server._list_page_size
)
return mcp.types.ListResourceTemplatesResult(
return mcp_types.ListResourceTemplatesResult(
resourceTemplates=page, nextCursor=next_cursor
)
async def _list_prompts_mcp(
self, request: mcp.types.ListPromptsRequest
) -> mcp.types.ListPromptsResult:
self, request: mcp_types.ListPromptsRequest
) -> mcp_types.ListPromptsResult:
"""
List all available prompts, in the format expected by the low-level MCP
server. Supports pagination when list_page_size is configured.
@ -183,15 +183,15 @@ class MCPOperationsMixin:
page, next_cursor = _apply_pagination(
sdk_prompts, cursor, server._list_page_size
)
return mcp.types.ListPromptsResult(prompts=page, nextCursor=next_cursor)
return mcp_types.ListPromptsResult(prompts=page, nextCursor=next_cursor)
async def _call_tool_mcp(
self, key: str, arguments: dict[str, Any]
) -> (
list[ContentBlock]
| tuple[list[ContentBlock], dict[str, Any]]
| mcp.types.CallToolResult
| mcp.types.CreateTaskResult
| mcp_types.CallToolResult
| mcp_types.CreateTaskResult
):
"""
Handle MCP 'callTool' requests.
@ -236,7 +236,7 @@ class MCPOperationsMixin:
key, arguments, version=version, task_meta=task_meta
)
if isinstance(result, mcp.types.CreateTaskResult):
if isinstance(result, mcp_types.CreateTaskResult):
return result
return result.to_mcp_result()
@ -247,7 +247,7 @@ class MCPOperationsMixin:
async def _read_resource_mcp(
self, uri: AnyUrl | str
) -> mcp.types.ReadResourceResult | mcp.types.CreateTaskResult:
) -> mcp_types.ReadResourceResult | mcp_types.CreateTaskResult:
"""Handle MCP 'readResource' requests.
Extracts task metadata from MCP request context and passes it explicitly
@ -287,23 +287,23 @@ class MCPOperationsMixin:
str(uri), version=version, task_meta=task_meta
)
if isinstance(result, mcp.types.CreateTaskResult):
if isinstance(result, mcp_types.CreateTaskResult):
return result
return result.to_mcp_result(uri)
except DisabledError as e:
raise McpError(
mcp.types.ErrorData(
mcp_types.ErrorData(
code=-32002, message=f"Resource not found: {str(uri)!r}"
)
) from e
except NotFoundError as e:
raise McpError(
mcp.types.ErrorData(code=-32002, message=f"Resource not found: {e}")
mcp_types.ErrorData(code=-32002, message=f"Resource not found: {e}")
) from e
async def _get_prompt_mcp(
self, name: str, arguments: dict[str, Any] | None
) -> mcp.types.GetPromptResult | mcp.types.CreateTaskResult:
) -> mcp_types.GetPromptResult | mcp_types.CreateTaskResult:
"""Handle MCP 'getPrompt' requests.
Extracts task metadata from MCP request context and passes it explicitly
@ -346,7 +346,7 @@ class MCPOperationsMixin:
name, arguments, version=version, task_meta=task_meta
)
if isinstance(result, mcp.types.CreateTaskResult):
if isinstance(result, mcp_types.CreateTaskResult):
return result
return result.to_mcp_prompt_result()
except DisabledError as e:
@ -354,7 +354,7 @@ class MCPOperationsMixin:
except NotFoundError:
raise
async def _set_logging_level_mcp(self, level: mcp.types.LoggingLevel) -> None:
async def _set_logging_level_mcp(self, level: mcp_types.LoggingLevel) -> None:
"""Handle MCP 'logging/setLevel' requests.
Stores the requested minimum log level on the session so that

26
fastmcp_slim/fastmcp/server/providers/fastmcp_provider.py
View file

@ -14,8 +14,8 @@ 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
import mcp_types
from mcp_types import AnyUrl
from fastmcp.prompts.base import Prompt, PromptResult
from fastmcp.resources.base import Resource, ResourceResult
@ -92,13 +92,13 @@ class FastMCPProviderTool(Tool):
self,
arguments: dict[str, Any],
task_meta: TaskMeta,
) -> mcp.types.CreateTaskResult: ...
) -> mcp_types.CreateTaskResult: ...
async def _run(
self,
arguments: dict[str, Any],
task_meta: TaskMeta | None = None,
) -> ToolResult | mcp.types.CreateTaskResult:
) -> ToolResult | mcp_types.CreateTaskResult:
"""Delegate to child server's call_tool() with task_meta.
Passes task_meta through to the child server so it can handle
@ -134,7 +134,7 @@ class FastMCPProviderTool(Tool):
self._original_name, arguments, version=version
)
# Result from call_tool should always be ToolResult when no task_meta
if isinstance(result, mcp.types.CreateTaskResult):
if isinstance(result, mcp_types.CreateTaskResult):
raise RuntimeError(
"Unexpected CreateTaskResult from call_tool without task_meta"
)
@ -190,11 +190,11 @@ class FastMCPProviderResource(Resource):
async def _read(self, task_meta: None = None) -> ResourceResult: ...
@overload
async def _read(self, task_meta: TaskMeta) -> mcp.types.CreateTaskResult: ...
async def _read(self, task_meta: TaskMeta) -> mcp_types.CreateTaskResult: ...
async def _read(
self, task_meta: TaskMeta | None = None
) -> ResourceResult | mcp.types.CreateTaskResult:
) -> ResourceResult | mcp_types.CreateTaskResult:
"""Delegate to child server's read_resource() with task_meta.
Passes task_meta through to the child server so it can handle
@ -270,13 +270,13 @@ class FastMCPProviderPrompt(Prompt):
self,
arguments: dict[str, Any] | None,
task_meta: TaskMeta,
) -> mcp.types.CreateTaskResult: ...
) -> mcp_types.CreateTaskResult: ...
async def _render(
self,
arguments: dict[str, Any] | None = None,
task_meta: TaskMeta | None = None,
) -> PromptResult | mcp.types.CreateTaskResult:
) -> PromptResult | mcp_types.CreateTaskResult:
"""Delegate to child server's render_prompt() with task_meta.
Passes task_meta through to the child server so it can handle
@ -309,7 +309,7 @@ class FastMCPProviderPrompt(Prompt):
self._original_name, arguments, version=version
)
# Result from render_prompt should always be PromptResult when no task_meta
if isinstance(result, mcp.types.CreateTaskResult):
if isinstance(result, mcp_types.CreateTaskResult):
raise RuntimeError(
"Unexpected CreateTaskResult from render_prompt without task_meta"
)
@ -396,11 +396,11 @@ class FastMCPProviderResourceTemplate(ResourceTemplate):
@overload
async def _read(
self, uri: str, params: dict[str, Any], task_meta: TaskMeta
) -> mcp.types.CreateTaskResult: ...
) -> mcp_types.CreateTaskResult: ...
async def _read(
self, uri: str, params: dict[str, Any], task_meta: TaskMeta | None = None
) -> ResourceResult | mcp.types.CreateTaskResult:
) -> ResourceResult | mcp_types.CreateTaskResult:
"""Delegate to child server's read_resource() with task_meta.
Passes task_meta through to the child server so it can handle
@ -437,7 +437,7 @@ class FastMCPProviderResourceTemplate(ResourceTemplate):
# Read from the wrapped server
result = await self._server.read_resource(original_uri, version=version)
if isinstance(result, mcp.types.CreateTaskResult):
if isinstance(result, mcp_types.CreateTaskResult):
raise RuntimeError("Unexpected CreateTaskResult during Docket execution")
return result

10
fastmcp_slim/fastmcp/server/providers/local_provider/decorators/prompts.py
View file

@ -11,8 +11,8 @@ from collections.abc import Callable
from functools import partial
from typing import TYPE_CHECKING, Any, TypeVar, overload
import mcp.types
from mcp.types import AnyFunction
import mcp_types
from mcp_types import AnyFunction
import fastmcp
from fastmcp.prompts.base import Prompt
@ -79,7 +79,7 @@ class PromptDecoratorMixin:
version: str | int | None = None,
title: str | None = None,
description: str | None = None,
icons: list[mcp.types.Icon] | None = None,
icons: list[mcp_types.Icon] | None = None,
tags: set[str] | None = None,
enabled: bool = True,
meta: dict[str, Any] | None = None,
@ -96,7 +96,7 @@ class PromptDecoratorMixin:
version: str | int | None = None,
title: str | None = None,
description: str | None = None,
icons: list[mcp.types.Icon] | None = None,
icons: list[mcp_types.Icon] | None = None,
tags: set[str] | None = None,
enabled: bool = True,
meta: dict[str, Any] | None = None,
@ -112,7 +112,7 @@ class PromptDecoratorMixin:
version: str | int | None = None,
title: str | None = None,
description: str | None = None,
icons: list[mcp.types.Icon] | None = None,
icons: list[mcp_types.Icon] | None = None,
tags: set[str] | None = None,
enabled: bool = True,
meta: dict[str, Any] | None = None,

6
fastmcp_slim/fastmcp/server/providers/local_provider/decorators/resources.py
View file

@ -10,8 +10,8 @@ import inspect
from collections.abc import Callable
from typing import TYPE_CHECKING, Any, TypeVar
import mcp.types
from mcp.types import Annotations, AnyFunction
import mcp_types
from mcp_types import Annotations, AnyFunction
import fastmcp
from fastmcp.resources.base import Resource
@ -112,7 +112,7 @@ class ResourceDecoratorMixin:
version: str | int | None = None,
title: str | None = None,
description: str | None = None,
icons: list[mcp.types.Icon] | None = None,
icons: list[mcp_types.Icon] | None = None,
mime_type: str | None = None,
tags: set[str] | None = None,
enabled: bool = True,

10
fastmcp_slim/fastmcp/server/providers/local_provider/decorators/tools.py
View file

@ -23,8 +23,8 @@ from typing import (
overload,
)
import mcp.types
from mcp.types import AnyFunction, ToolAnnotations
import mcp_types
from mcp_types import AnyFunction, ToolAnnotations
import fastmcp
from fastmcp.exceptions import FastMCPDeprecationWarning
@ -184,7 +184,7 @@ class ToolDecoratorMixin:
version: str | int | None = None,
title: str | None = None,
description: str | None = None,
icons: list[mcp.types.Icon] | None = None,
icons: list[mcp_types.Icon] | None = None,
tags: set[str] | None = None,
output_schema: dict[str, Any] | NotSetT | None = NotSet,
annotations: ToolAnnotations | dict[str, Any] | None = None,
@ -207,7 +207,7 @@ class ToolDecoratorMixin:
version: str | int | None = None,
title: str | None = None,
description: str | None = None,
icons: list[mcp.types.Icon] | None = None,
icons: list[mcp_types.Icon] | None = None,
tags: set[str] | None = None,
output_schema: dict[str, Any] | NotSetT | None = NotSet,
annotations: ToolAnnotations | dict[str, Any] | None = None,
@ -233,7 +233,7 @@ class ToolDecoratorMixin:
version: str | int | None = None,
title: str | None = None,
description: str | None = None,
icons: list[mcp.types.Icon] | None = None,
icons: list[mcp_types.Icon] | None = None,
tags: set[str] | None = None,
output_schema: dict[str, Any] | NotSetT | None = NotSet,
annotations: ToolAnnotations | dict[str, Any] | None = None,

2
fastmcp_slim/fastmcp/server/providers/openapi/components.py
View file

@ -9,7 +9,7 @@ from collections.abc import Callable
from typing import TYPE_CHECKING, Any
import httpx
from mcp.types import ToolAnnotations
from mcp_types import ToolAnnotations
from pydantic.networks import AnyUrl
import fastmcp

44
fastmcp_slim/fastmcp/server/providers/proxy.py
View file

@ -15,13 +15,13 @@ from typing import TYPE_CHECKING, Any, cast
import anyio
import httpx
import mcp.types
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 (
from mcp_types import (
METHOD_NOT_FOUND,
BlobResourceContents,
ElicitRequestFormParams,
@ -68,8 +68,8 @@ ClientFactoryT = Callable[[], Client] | Callable[[], Awaitable[Client]]
def _proxy_upstream_error(error: Exception) -> McpError:
return McpError(
mcp.types.ErrorData(
code=mcp.types.INTERNAL_ERROR,
mcp_types.ErrorData(
code=mcp_types.INTERNAL_ERROR,
message=str(error),
)
)
@ -81,12 +81,12 @@ class ProxyInitializeMiddleware(Middleware):
async def on_initialize(
self,
context: MiddlewareContext[mcp.types.InitializeRequest],
context: MiddlewareContext[mcp_types.InitializeRequest],
call_next: CallNext[
mcp.types.InitializeRequest,
mcp.types.InitializeResult | None,
mcp_types.InitializeRequest,
mcp_types.InitializeResult | None,
],
) -> mcp.types.InitializeResult | None:
) -> mcp_types.InitializeResult | None:
client = await self.proxy._get_client()
try:
if isinstance(client, StatefulProxyClient):
@ -146,7 +146,7 @@ class ProxyTool(Tool):
@classmethod
def from_mcp_tool(
cls, client_factory: ClientFactoryT, mcp_tool: mcp.types.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(
@ -269,7 +269,7 @@ class ProxyResource(Resource):
def from_mcp_resource(
cls,
client_factory: ClientFactoryT,
mcp_resource: mcp.types.Resource,
mcp_resource: mcp_types.Resource,
) -> ProxyResource:
"""Factory method to create a ProxyResource from a raw MCP resource schema."""
@ -366,7 +366,7 @@ class ProxyTemplate(ResourceTemplate):
@classmethod
def from_mcp_template( # type: ignore[override]
cls, client_factory: ClientFactoryT, mcp_template: mcp.types.ResourceTemplate
cls, client_factory: ClientFactoryT, mcp_template: mcp_types.ResourceTemplate
) -> ProxyTemplate: # ty:ignore[invalid-method-override]
"""Factory method to create a ProxyTemplate from a raw MCP template schema."""
@ -481,7 +481,7 @@ class ProxyPrompt(Prompt):
@classmethod
def from_mcp_prompt(
cls, client_factory: ClientFactoryT, mcp_prompt: mcp.types.Prompt
cls, client_factory: ClientFactoryT, mcp_prompt: mcp_types.Prompt
) -> ProxyPrompt:
"""Factory method to create a ProxyPrompt from a raw MCP prompt schema."""
arguments = [
@ -919,14 +919,14 @@ class FastMCPProxy(FastMCP):
def _setup_proxy_ping_handler(self) -> None:
async def ping_remote(
_request: mcp.types.PingRequest,
) -> mcp.types.ServerResult:
_request: mcp_types.PingRequest,
) -> mcp_types.ServerResult:
client = await self._get_client()
async with client:
await client.ping()
return mcp.types.ServerResult(mcp.types.EmptyResult())
return mcp_types.ServerResult(mcp_types.EmptyResult())
self._mcp_server.request_handlers[mcp.types.PingRequest] = ping_remote
self._mcp_server.request_handlers[mcp_types.PingRequest] = ping_remote
# -----------------------------------------------------------------------------
@ -943,10 +943,10 @@ async def default_proxy_roots_handler(
async def default_proxy_sampling_handler(
messages: list[mcp.types.SamplingMessage],
params: mcp.types.CreateMessageRequestParams,
messages: list[mcp_types.SamplingMessage],
params: mcp_types.CreateMessageRequestParams,
context: RequestContext[ClientSession, LifespanContextT],
) -> mcp.types.CreateMessageResult:
) -> mcp_types.CreateMessageResult:
"""Forward sampling request from remote server to proxy's connected clients."""
ctx = get_context()
result = await ctx.sample(
@ -956,8 +956,8 @@ async def default_proxy_sampling_handler(
max_tokens=params.maxTokens,
model_preferences=params.modelPreferences,
)
content = mcp.types.TextContent(type="text", text=result.text or "")
return mcp.types.CreateMessageResult(
content = mcp_types.TextContent(type="text", text=result.text or "")
return mcp_types.CreateMessageResult(
role="assistant",
model="fastmcp-client",
# TODO(ty): remove when ty supports isinstance exclusion narrowing
@ -968,7 +968,7 @@ async def default_proxy_sampling_handler(
async def default_proxy_elicitation_handler(
message: str,
response_type: type,
params: mcp.types.ElicitRequestParams,
params: mcp_types.ElicitRequestParams,
context: RequestContext[ClientSession, LifespanContextT],
) -> ElicitResult:
"""Forward elicitation request from remote server to proxy's connected clients."""

6
fastmcp_slim/fastmcp/server/sampling/run.py
View file

@ -9,7 +9,7 @@ from dataclasses import dataclass
from typing import TYPE_CHECKING, Any, Generic, Literal, cast
import anyio
from mcp.types import (
from mcp_types import (
ClientCapabilities,
CreateMessageResult,
CreateMessageResultWithTools,
@ -24,8 +24,8 @@ from mcp.types import (
ToolResultContent,
ToolUseContent,
)
from mcp.types import CreateMessageRequestParams as SamplingParams
from mcp.types import Tool as SDKTool
from mcp_types import CreateMessageRequestParams as SamplingParams
from mcp_types import Tool as SDKTool
from opentelemetry.trace import SpanKind, Status, StatusCode
from pydantic import ValidationError
from typing_extensions import TypeVar

6
fastmcp_slim/fastmcp/server/sampling/sampling_tool.py
View file

@ -6,8 +6,8 @@ import inspect
from collections.abc import Callable
from typing import Any
from mcp.types import TextContent
from mcp.types import Tool as SDKTool
from mcp_types import TextContent
from mcp_types import Tool as SDKTool
from pydantic import ConfigDict
from fastmcp.exceptions import AuthorizationError
@ -69,7 +69,7 @@ class SamplingTool(FastMCPBaseModel):
return result
def _to_sdk_tool(self) -> SDKTool:
"""Convert to an mcp.types.Tool for SDK compatibility.
"""Convert to an mcp_types.Tool for SDK compatibility.
This is used internally when passing tools to the MCP SDK's
create_message() method.

50
fastmcp_slim/fastmcp/server/server.py
View file

@ -22,13 +22,13 @@ from pathlib import Path
from typing import TYPE_CHECKING, Any, Generic, Literal, TypeVar, cast, overload
import httpx
import mcp.types
import mcp_types
from key_value.aio.adapters.pydantic import PydanticAdapter
from key_value.aio.protocols import AsyncKeyValue
from key_value.aio.stores.memory import MemoryStore
from mcp.server.lowlevel.server import LifespanResultT
from mcp.shared.exceptions import McpError
from mcp.types import (
from mcp_types import (
Annotations,
AnyFunction,
CallToolRequestParams,
@ -103,7 +103,7 @@ logger = get_logger(__name__)
def _version_request_meta(
version: VersionSpec | None,
) -> mcp.types.RequestParams.Meta | None:
) -> mcp_types.RequestParams.Meta | None:
if version is None:
return None
@ -123,7 +123,7 @@ def _version_request_meta(
if not version_value:
return None
return mcp.types.RequestParams.Meta.model_validate(
return mcp_types.RequestParams.Meta.model_validate(
{"fastmcp": {"version": version_value}}
)
@ -325,7 +325,7 @@ class FastMCP(
*,
version: str | int | float | None = None,
website_url: str | None = None,
icons: list[mcp.types.Icon] | None = None,
icons: list[mcp_types.Icon] | None = None,
auth: AuthProvider | None = None,
middleware: Sequence[Middleware] | None = None,
providers: Sequence[Provider] | None = None,
@ -341,7 +341,7 @@ class FastMCP(
session_state_store: AsyncKeyValue | None = None,
sampling_handler: SamplingHandler | None = None,
sampling_handler_behavior: Literal["always", "fallback"] | None = None,
client_log_level: mcp.types.LoggingLevel | None = None,
client_log_level: mcp_types.LoggingLevel | None = None,
experimental_capabilities: dict[str, dict[str, Any]] | None = None,
**kwargs: Any,
):
@ -435,7 +435,7 @@ class FastMCP(
else fastmcp.settings.strict_input_validation
)
self.client_log_level: mcp.types.LoggingLevel | None = (
self.client_log_level: mcp_types.LoggingLevel | None = (
client_log_level
if client_log_level is not None
else fastmcp.settings.client_log_level
@ -486,7 +486,7 @@ class FastMCP(
return self._mcp_server.website_url
@property
def icons(self) -> list[mcp.types.Icon]:
def icons(self) -> list[mcp_types.Icon]:
if self._mcp_server.icons is None:
return []
else:
@ -658,7 +658,7 @@ class FastMCP(
async with fastmcp.server.context.Context(fastmcp=self) as ctx:
if run_middleware:
mw_context = MiddlewareContext(
message=mcp.types.ListToolsRequest(method="tools/list"),
message=mcp_types.ListToolsRequest(method="tools/list"),
source="client",
type="request",
method="tools/list",
@ -1195,7 +1195,7 @@ class FastMCP(
version: VersionSpec | None = None,
run_middleware: bool = True,
task_meta: TaskMeta,
) -> mcp.types.CreateTaskResult: ...
) -> mcp_types.CreateTaskResult: ...
async def call_tool(
self,
@ -1205,7 +1205,7 @@ class FastMCP(
version: VersionSpec | None = None,
run_middleware: bool = True,
task_meta: TaskMeta | None = None,
) -> ToolResult | mcp.types.CreateTaskResult:
) -> ToolResult | mcp_types.CreateTaskResult:
"""Call a tool by name.
This is the public API for executing tools. By default, middleware is applied.
@ -1248,7 +1248,7 @@ class FastMCP(
async with fastmcp.server.context.Context(fastmcp=self) as ctx:
if run_middleware:
mw_context = MiddlewareContext[CallToolRequestParams](
message=mcp.types.CallToolRequestParams(
message=mcp_types.CallToolRequestParams(
name=name,
arguments=arguments or {},
_meta=_version_request_meta(version), # type: ignore[unknown-argument] # pydantic alias
@ -1375,7 +1375,7 @@ class FastMCP(
version: VersionSpec | None = None,
run_middleware: bool = True,
task_meta: TaskMeta,
) -> mcp.types.CreateTaskResult: ...
) -> mcp_types.CreateTaskResult: ...
async def read_resource(
self,
@ -1384,7 +1384,7 @@ class FastMCP(
version: VersionSpec | None = None,
run_middleware: bool = True,
task_meta: TaskMeta | None = None,
) -> ResourceResult | mcp.types.CreateTaskResult:
) -> ResourceResult | mcp_types.CreateTaskResult:
"""Read a resource by URI.
This is the public API for reading resources. By default, middleware is applied.
@ -1418,7 +1418,7 @@ class FastMCP(
if run_middleware:
uri_param = AnyUrl(uri)
mw_context = MiddlewareContext(
message=mcp.types.ReadResourceRequestParams(
message=mcp_types.ReadResourceRequestParams(
uri=uri_param,
_meta=_version_request_meta(version), # type: ignore[unknown-argument] # pydantic alias
),
@ -1557,7 +1557,7 @@ class FastMCP(
version: VersionSpec | None = None,
run_middleware: bool = True,
task_meta: TaskMeta,
) -> mcp.types.CreateTaskResult: ...
) -> mcp_types.CreateTaskResult: ...
async def render_prompt(
self,
@ -1567,7 +1567,7 @@ class FastMCP(
version: VersionSpec | None = None,
run_middleware: bool = True,
task_meta: TaskMeta | None = None,
) -> PromptResult | mcp.types.CreateTaskResult:
) -> PromptResult | mcp_types.CreateTaskResult:
"""Render a prompt by name.
This is the public API for rendering prompts. By default, middleware is applied.
@ -1594,7 +1594,7 @@ class FastMCP(
async with fastmcp.server.context.Context(fastmcp=self) as ctx:
if run_middleware:
mw_context = MiddlewareContext(
message=mcp.types.GetPromptRequestParams(
message=mcp_types.GetPromptRequestParams(
name=name,
arguments=arguments,
_meta=_version_request_meta(version), # type: ignore[unknown-argument] # pydantic alias
@ -1699,7 +1699,7 @@ class FastMCP(
version: str | int | None = None,
title: str | None = None,
description: str | None = None,
icons: list[mcp.types.Icon] | None = None,
icons: list[mcp_types.Icon] | None = None,
tags: set[str] | None = None,
output_schema: dict[str, Any] | NotSetT | None = NotSet,
annotations: ToolAnnotations | dict[str, Any] | None = None,
@ -1721,7 +1721,7 @@ class FastMCP(
version: str | int | None = None,
title: str | None = None,
description: str | None = None,
icons: list[mcp.types.Icon] | None = None,
icons: list[mcp_types.Icon] | None = None,
tags: set[str] | None = None,
output_schema: dict[str, Any] | NotSetT | None = NotSet,
annotations: ToolAnnotations | dict[str, Any] | None = None,
@ -1742,7 +1742,7 @@ class FastMCP(
version: str | int | None = None,
title: str | None = None,
description: str | None = None,
icons: list[mcp.types.Icon] | None = None,
icons: list[mcp_types.Icon] | None = None,
tags: set[str] | None = None,
output_schema: dict[str, Any] | NotSetT | None = NotSet,
annotations: ToolAnnotations | dict[str, Any] | None = None,
@ -1867,7 +1867,7 @@ class FastMCP(
version: str | int | None = None,
title: str | None = None,
description: str | None = None,
icons: list[mcp.types.Icon] | None = None,
icons: list[mcp_types.Icon] | None = None,
mime_type: str | None = None,
tags: set[str] | None = None,
annotations: Annotations | dict[str, Any] | None = None,
@ -1998,7 +1998,7 @@ class FastMCP(
version: str | int | None = None,
title: str | None = None,
description: str | None = None,
icons: list[mcp.types.Icon] | None = None,
icons: list[mcp_types.Icon] | None = None,
tags: set[str] | None = None,
meta: dict[str, Any] | None = None,
task: bool | TaskConfig | None = None,
@ -2014,7 +2014,7 @@ class FastMCP(
version: str | int | None = None,
title: str | None = None,
description: str | None = None,
icons: list[mcp.types.Icon] | None = None,
icons: list[mcp_types.Icon] | None = None,
tags: set[str] | None = None,
meta: dict[str, Any] | None = None,
task: bool | TaskConfig | None = None,
@ -2029,7 +2029,7 @@ class FastMCP(
version: str | int | None = None,
title: str | None = None,
description: str | None = None,
icons: list[mcp.types.Icon] | None = None,
icons: list[mcp_types.Icon] | None = None,
tags: set[str] | None = None,
meta: dict[str, Any] | None = None,
task: bool | TaskConfig | None = None,

2
fastmcp_slim/fastmcp/server/tasks/capabilities.py
View file

@ -1,6 +1,6 @@
"""SEP-1686 task capabilities declaration."""
from mcp.types import (
from mcp_types import (
ServerTasksCapability,
ServerTasksRequestsCapability,
TasksCallCapability,

12
fastmcp_slim/fastmcp/server/tasks/elicitation.py
View file

@ -21,7 +21,7 @@ import uuid
from datetime import datetime, timezone
from typing import TYPE_CHECKING, Any
import mcp.types
import mcp_types
from mcp import ServerSession
from fastmcp.server.tasks.context import get_task_context, get_task_session_id
@ -50,7 +50,7 @@ async def elicit_for_task(
message: str,
schema: dict[str, Any],
fastmcp: FastMCP,
) -> mcp.types.ElicitResult:
) -> mcp_types.ElicitResult:
"""Send an elicitation request from a background task.
This function handles the complexity of eliciting user input when running
@ -154,7 +154,7 @@ async def elicit_for_task(
"No session_id available for task %s, cannot deliver elicitation notification",
task_id,
)
return mcp.types.ElicitResult(action="cancel", content=None)
return mcp_types.ElicitResult(action="cancel", content=None)
try:
await push_notification(session_id, notification_dict, docket)
@ -175,7 +175,7 @@ async def elicit_for_task(
)
except Exception:
pass # Keys will expire via TTL
return mcp.types.ElicitResult(action="cancel", content=None)
return mcp_types.ElicitResult(action="cancel", content=None)
# Wait for response using BLPOP (blocking pop)
# This is much more efficient than polling - single Redis round-trip
@ -203,7 +203,7 @@ async def elicit_for_task(
)
# Convert to ElicitResult
return mcp.types.ElicitResult(
return mcp_types.ElicitResult(
action=response.get("action", "accept"),
content=response.get("content"),
)
@ -230,7 +230,7 @@ async def elicit_for_task(
cleanup_error,
)
return mcp.types.ElicitResult(action="cancel", content=None)
return mcp_types.ElicitResult(action="cancel", content=None)
async def relay_elicitation(

14
fastmcp_slim/fastmcp/server/tasks/handlers.py
View file

@ -10,9 +10,9 @@ from contextlib import suppress
from datetime import datetime, timezone
from typing import TYPE_CHECKING, Any, Literal
import mcp.types
import mcp_types
from mcp.shared.exceptions import McpError
from mcp.types import INTERNAL_ERROR, ErrorData
from mcp_types import INTERNAL_ERROR, ErrorData
from fastmcp.server.dependencies import (
_current_docket,
@ -46,7 +46,7 @@ async def submit_to_docket(
component: Tool | Resource | ResourceTemplate | Prompt,
arguments: dict[str, Any] | None = None,
task_meta: TaskMeta | None = None,
) -> mcp.types.CreateTaskResult:
) -> mcp_types.CreateTaskResult:
"""Submit any component to Docket for background execution (SEP-1686).
Unified handler for all component types. Called by component's internal
@ -144,7 +144,7 @@ async def submit_to_docket(
# Send an initial tasks/status notification before queueing.
# This guarantees clients can observe task creation immediately.
notification = mcp.types.TaskStatusNotification.model_validate(
notification = mcp_types.TaskStatusNotification.model_validate(
{
"method": "notifications/tasks/status",
"params": {
@ -163,7 +163,7 @@ async def submit_to_docket(
},
}
)
server_notification = mcp.types.ServerNotification(notification)
server_notification = mcp_types.ServerNotification(notification)
with suppress(Exception):
# Don't let notification failures break task creation
await ctx.session.send_notification(server_notification)
@ -226,8 +226,8 @@ async def submit_to_docket(
# Return CreateTaskResult with proper Task object
# Tasks MUST begin in "working" status per SEP-1686 final spec (line 381)
return mcp.types.CreateTaskResult(
task=mcp.types.Task(
return mcp_types.CreateTaskResult(
task=mcp_types.Task(
taskId=server_task_id,
status="working",
createdAt=created_at,

6
fastmcp_slim/fastmcp/server/tasks/notifications.py
View file

@ -25,7 +25,7 @@ from contextlib import suppress
from datetime import datetime, timezone
from typing import TYPE_CHECKING, Any
import mcp.types
import mcp_types
if TYPE_CHECKING:
from docket import Docket
@ -186,14 +186,14 @@ async def _send_mcp_notification(
if method != "notifications/tasks/status":
raise ValueError(f"Unsupported notification method for subscriber: {method}")
notification = mcp.types.TaskStatusNotification.model_validate(
notification = mcp_types.TaskStatusNotification.model_validate(
{
"method": "notifications/tasks/status",
"params": notification_dict.get("params", {}),
"_meta": notification_dict.get("_meta"),
}
)
server_notification = mcp.types.ServerNotification(notification)
server_notification = mcp_types.ServerNotification(notification)
await session.send_notification(server_notification)

14
fastmcp_slim/fastmcp/server/tasks/requests.py
View file

@ -11,10 +11,10 @@ from __future__ import annotations
from datetime import datetime, timedelta, timezone
from typing import TYPE_CHECKING, Any, Literal
import mcp.types
import mcp_types
from docket.execution import ExecutionState
from mcp.shared.exceptions import McpError
from mcp.types import (
from mcp_types import (
INTERNAL_ERROR,
INVALID_PARAMS,
CancelTaskResult,
@ -294,8 +294,8 @@ async def tasks_result_handler(server: FastMCP, params: dict[str, Any]) -> Any:
raw_value = await execution.get_result(timeout=timedelta(seconds=0))
except Exception as error:
# Task failed - return error result
return mcp.types.CallToolResult(
content=[mcp.types.TextContent(type="text", text=str(error))],
return mcp_types.CallToolResult(
content=[mcp_types.TextContent(type="text", text=str(error))],
isError=True,
_meta={ # type: ignore[call-arg] # _meta is Pydantic alias for meta field
"io.modelcontextprotocol/related-task": {
@ -351,18 +351,18 @@ async def tasks_result_handler(server: FastMCP, params: dict[str, Any]) -> Any:
if isinstance(component, Tool):
fastmcp_result = component.convert_result(raw_value)
mcp_result = fastmcp_result.to_mcp_result()
if isinstance(mcp_result, mcp.types.CallToolResult):
if isinstance(mcp_result, mcp_types.CallToolResult):
merged = {**(mcp_result.meta or {}), **related_task_meta}
mcp_result._meta = merged # type: ignore[attr-defined] # ty:ignore[unresolved-attribute]
elif isinstance(mcp_result, tuple):
content, structured_content = mcp_result
mcp_result = mcp.types.CallToolResult(
mcp_result = mcp_types.CallToolResult(
content=content,
structuredContent=structured_content,
_meta=related_task_meta, # type: ignore[call-arg] # _meta is Pydantic alias for meta field
)
else:
mcp_result = mcp.types.CallToolResult(
mcp_result = mcp_types.CallToolResult(
content=mcp_result,
_meta=related_task_meta, # type: ignore[call-arg] # _meta is Pydantic alias for meta field
)

6
fastmcp_slim/fastmcp/server/tasks/routing.py
View file

@ -7,9 +7,9 @@ from __future__ import annotations
from typing import TYPE_CHECKING, Any, Literal
import mcp.types
import mcp_types
from mcp.shared.exceptions import McpError
from mcp.types import METHOD_NOT_FOUND, ErrorData
from mcp_types import METHOD_NOT_FOUND, ErrorData
from fastmcp.server.tasks.config import TaskMeta
from fastmcp.server.tasks.handlers import submit_to_docket
@ -28,7 +28,7 @@ async def check_background_task(
task_type: TaskType,
arguments: dict[str, Any] | None = None,
task_meta: TaskMeta | None = None,
) -> mcp.types.CreateTaskResult | None:
) -> mcp_types.CreateTaskResult | None:
"""Check task mode and submit to background if requested.
Args:

2
fastmcp_slim/fastmcp/server/tasks/subscriptions.py
View file

@ -13,7 +13,7 @@ from datetime import datetime, timezone
from typing import TYPE_CHECKING
from docket.execution import ExecutionState
from mcp.types import TaskStatusNotification, TaskStatusNotificationParams
from mcp_types import TaskStatusNotification, TaskStatusNotificationParams
from fastmcp.server.tasks.config import DEFAULT_TTL_MS
from fastmcp.server.tasks.keys import parse_task_key, task_redis_prefix

2
fastmcp_slim/fastmcp/server/transforms/prompts_as_tools.py
View file

@ -24,7 +24,7 @@ import json
from collections.abc import Sequence
from typing import TYPE_CHECKING, Annotated, Any
from mcp.types import TextContent
from mcp_types import TextContent
from fastmcp.server.dependencies import get_context
from fastmcp.server.transforms import GetToolNext, Transform

2
fastmcp_slim/fastmcp/server/transforms/resources_as_tools.py
View file

@ -25,7 +25,7 @@ import json
from collections.abc import Sequence
from typing import TYPE_CHECKING, Annotated, Any
from mcp.types import ToolAnnotations
from mcp_types import ToolAnnotations
from fastmcp.server.dependencies import get_context
from fastmcp.server.transforms import GetToolNext, Transform

8
fastmcp_slim/fastmcp/server/transforms/visibility.py
View file

@ -10,7 +10,7 @@ from __future__ import annotations
from collections.abc import Sequence
from typing import TYPE_CHECKING, Any, Literal, TypeVar
import mcp.types
import mcp_types
from fastmcp.resources.base import Resource
from fastmcp.resources.template import ResourceTemplate
@ -322,11 +322,11 @@ async def save_visibility_rules(
# Send notifications based on components hint
# Note: MCP has no separate template notification - templates use ResourceListChangedNotification
if components is None or "tool" in components:
await context.send_notification(mcp.types.ToolListChangedNotification())
await context.send_notification(mcp_types.ToolListChangedNotification())
if components is None or "resource" in components or "template" in components:
await context.send_notification(mcp.types.ResourceListChangedNotification())
await context.send_notification(mcp_types.ResourceListChangedNotification())
if components is None or "prompt" in components:
await context.send_notification(mcp.types.PromptListChangedNotification())
await context.send_notification(mcp_types.PromptListChangedNotification())
def create_visibility_transforms(rules: list[dict[str, Any]]) -> list[Visibility]:

10
fastmcp_slim/fastmcp/tools/base.py
View file

@ -11,10 +11,10 @@ from typing import (
overload,
)
import mcp.types
import mcp_types
import pydantic_core
from mcp.shared.tool_name_validation import validate_and_warn_tool_name
from mcp.types import (
from mcp_types import (
CallToolResult,
ContentBlock,
Icon,
@ -22,7 +22,7 @@ from mcp.types import (
ToolAnnotations,
ToolExecution,
)
from mcp.types import Tool as MCPTool
from mcp_types import Tool as MCPTool
from pydantic import BaseModel, Field, model_validator
from pydantic.json_schema import SkipJsonSchema
@ -380,13 +380,13 @@ class Tool(FastMCPComponent):
self,
arguments: dict[str, Any],
task_meta: TaskMeta,
) -> mcp.types.CreateTaskResult: ...
) -> mcp_types.CreateTaskResult: ...
async def _run(
self,
arguments: dict[str, Any],
task_meta: TaskMeta | None = None,
) -> ToolResult | mcp.types.CreateTaskResult:
) -> ToolResult | mcp_types.CreateTaskResult:
"""Server entry point that handles task routing.
This allows ANY Tool subclass to support background execution by setting

12
fastmcp_slim/fastmcp/tools/function_parsing.py
View file

@ -9,7 +9,7 @@ from collections.abc import Callable
from dataclasses import dataclass
from typing import Annotated, Any, Generic, Union, get_args, get_origin, get_type_hints
import mcp.types
import mcp_types
from pydantic import BaseModel, PydanticSchemaGenerationError
from typing_extensions import TypeVar as TypeVarExt
@ -317,11 +317,11 @@ class ParsedFunction:
Audio,
File,
ToolResult,
mcp.types.TextContent,
mcp.types.ImageContent,
mcp.types.AudioContent,
mcp.types.ResourceLink,
mcp.types.EmbeddedResource,
mcp_types.TextContent,
mcp_types.ImageContent,
mcp_types.AudioContent,
mcp_types.ResourceLink,
mcp_types.EmbeddedResource,
*_PREFAB_TYPES,
),
_UnserializableType,

2
fastmcp_slim/fastmcp/tools/function_tool.py
View file

@ -25,7 +25,7 @@ from typing import (
import anyio
from mcp.shared.exceptions import McpError
from mcp.types import ErrorData, Icon, ToolAnnotations
from mcp_types import ErrorData, Icon, ToolAnnotations
from pydantic import Field, TypeAdapter
from pydantic import ValidationError as PydanticValidationError
from pydantic.json_schema import SkipJsonSchema

2
fastmcp_slim/fastmcp/tools/tool_transform.py
View file

@ -9,7 +9,7 @@ from dataclasses import dataclass
from typing import Annotated, Any, Literal, cast
import pydantic_core
from mcp.types import ToolAnnotations
from mcp_types import ToolAnnotations
from pydantic import ConfigDict
from pydantic.fields import Field
from pydantic.functional_validators import BeforeValidator

2
fastmcp_slim/fastmcp/utilities/components.py
View file

@ -3,7 +3,7 @@ from __future__ import annotations
from collections.abc import Sequence
from typing import TYPE_CHECKING, Annotated, Any, ClassVar, TypedDict, cast
from mcp.types import Icon
from mcp_types import Icon
from pydantic import BeforeValidator, Field
from typing_extensions import Self, TypeVar

4
fastmcp_slim/fastmcp/utilities/exceptions.py
View file

@ -2,7 +2,7 @@ from collections.abc import Callable, Iterable, Mapping
from typing import Any
import httpx
import mcp.types
import mcp_types
from exceptiongroup import BaseExceptionGroup
from mcp import McpError
@ -21,7 +21,7 @@ def _exception_handler(group: BaseExceptionGroup):
for leaf in iter_exc(group):
if isinstance(leaf, httpx.ConnectTimeout):
raise McpError(
error=mcp.types.ErrorData(
error=mcp_types.ErrorData(
code=httpx.codes.REQUEST_TIMEOUT,
message="Timed out while waiting for response.",
)

8
fastmcp_slim/fastmcp/utilities/skills.py
View file

@ -8,7 +8,7 @@ from dataclasses import dataclass
from pathlib import Path
from typing import TYPE_CHECKING
import mcp.types
import mcp_types
if TYPE_CHECKING:
from fastmcp.client import Client
@ -104,7 +104,7 @@ async def get_skill_manifest(client: Client, skill_name: str) -> SkillManifest:
raise ValueError(f"Could not read manifest for skill: {skill_name}")
content = result[0]
if isinstance(content, mcp.types.TextResourceContents):
if isinstance(content, mcp_types.TextResourceContents):
try:
manifest_data = json.loads(content.text)
except json.JSONDecodeError as e:
@ -204,9 +204,9 @@ async def download_skill(
file_path.parent.mkdir(parents=True, exist_ok=True)
# Write content
if isinstance(content, mcp.types.TextResourceContents):
if isinstance(content, mcp_types.TextResourceContents):
file_path.write_text(content.text)
elif isinstance(content, mcp.types.BlobResourceContents):
elif isinstance(content, mcp_types.BlobResourceContents):
file_path.write_bytes(base64.b64decode(content.blob))
else:
# Skip unknown content types

20
fastmcp_slim/fastmcp/utilities/types.py
View file

@ -19,8 +19,8 @@ from typing import (
get_type_hints,
)
import mcp.types
from mcp.types import Annotations, ContentBlock, ModelPreferences, SamplingMessage
import mcp_types
from mcp_types import Annotations, ContentBlock, ModelPreferences, SamplingMessage
from pydantic import AnyUrl, BaseModel, ConfigDict, Field, TypeAdapter, UrlConstraints
from typing_extensions import TypeVar
@ -290,11 +290,11 @@ class Image:
self,
mime_type: str | None = None,
annotations: Annotations | None = None,
) -> mcp.types.ImageContent:
) -> mcp_types.ImageContent:
"""Convert to MCP ImageContent."""
data = self._get_data()
return mcp.types.ImageContent(
return mcp_types.ImageContent(
type="image",
data=data,
mimeType=mime_type or self._mime_type,
@ -348,7 +348,7 @@ class Audio:
self,
mime_type: str | None = None,
annotations: Annotations | None = None,
) -> mcp.types.AudioContent:
) -> mcp_types.AudioContent:
if self.path:
with open(self.path, "rb") as f:
data = base64.b64encode(f.read()).decode()
@ -357,7 +357,7 @@ class Audio:
else:
raise ValueError("No audio data available")
return mcp.types.AudioContent(
return mcp_types.AudioContent(
type="audio",
data=data,
mimeType=mime_type or self._mime_type,
@ -408,7 +408,7 @@ class File:
self,
mime_type: str | None = None,
annotations: Annotations | None = None,
) -> mcp.types.EmbeddedResource:
) -> mcp_types.EmbeddedResource:
if self.path:
with open(self.path, "rb") as f:
raw_data = f.read()
@ -431,20 +431,20 @@ class File:
text = raw_data.decode("utf-8")
except UnicodeDecodeError:
text = raw_data.decode("latin-1")
resource = mcp.types.TextResourceContents(
resource = mcp_types.TextResourceContents(
text=text,
mimeType=mime,
uri=uri,
)
else:
data = base64.b64encode(raw_data).decode()
resource = mcp.types.BlobResourceContents(
resource = mcp_types.BlobResourceContents(
blob=data,
mimeType=mime,
uri=uri,
)
return mcp.types.EmbeddedResource(
return mcp_types.EmbeddedResource(
type="resource",
resource=resource,
annotations=annotations or self.annotations,

10
tests/cli/test_client_commands.py
View file

@ -5,7 +5,7 @@ from pathlib import Path
from typing import Any
from unittest.mock import patch
import mcp.types
import mcp_types
import pytest
from fastmcp import FastMCP
@ -161,13 +161,13 @@ class TestFormatToolSignature:
required: list[str] | None = None,
output_schema: dict[str, Any] | None = None,
description: str | None = None,
) -> mcp.types.Tool:
) -> mcp_types.Tool:
input_schema: dict[str, Any] = {"type": "object"}
if properties is not None:
input_schema["properties"] = properties
if required is not None:
input_schema["required"] = required
return mcp.types.Tool(
return mcp_types.Tool(
name=name,
description=description,
inputSchema=input_schema,
@ -546,7 +546,7 @@ class TestFormatCallResult:
"""structured_content (raw dict) is used for display, not data (which may
be a non-serializable dataclass)."""
result = CallToolResult(
content=[mcp.types.TextContent(type="text", text="ok")],
content=[mcp_types.TextContent(type="text", text="ok")],
structured_content={"key": "value"},
meta=None,
data=object(), # non-serializable on purpose
@ -561,7 +561,7 @@ class TestFormatCallResult:
self, capsys: pytest.CaptureFixture[str]
):
result = CallToolResult(
content=[mcp.types.TextContent(type="text", text="[red]x[/red]\x1b[2J")],
content=[mcp_types.TextContent(type="text", text="[red]x[/red]\x1b[2J")],
structured_content=None,
meta=None,
data=None,

54
tests/cli/test_generate_cli.py
View file

@ -5,7 +5,7 @@ from pathlib import Path
from typing import Any
from unittest.mock import patch
import mcp.types
import mcp_types
import pytest
from fastmcp import FastMCP
@ -148,7 +148,7 @@ class TestSerializeTransport:
class TestToolFunctionSource:
def test_required_param(self):
tool = mcp.types.Tool(
tool = mcp_types.Tool(
name="greet",
inputSchema={
"properties": {"name": {"type": "string", "description": "Who"}},
@ -162,7 +162,7 @@ class TestToolFunctionSource:
assert "_call_tool('greet', {'name': name})" in source
def test_optional_param(self):
tool = mcp.types.Tool(
tool = mcp_types.Tool(
name="search",
inputSchema={
"properties": {
@ -178,7 +178,7 @@ class TestToolFunctionSource:
assert "= None" in source
def test_param_with_default(self):
tool = mcp.types.Tool(
tool = mcp_types.Tool(
name="fetch",
inputSchema={
"properties": {
@ -197,7 +197,7 @@ class TestToolFunctionSource:
assert "= 30" in source
def test_no_params(self):
tool = mcp.types.Tool(
tool = mcp_types.Tool(
name="ping",
inputSchema={"properties": {}},
)
@ -206,7 +206,7 @@ class TestToolFunctionSource:
assert "_call_tool('ping', {})" in source
def test_preserves_underscores(self):
tool = mcp.types.Tool(
tool = mcp_types.Tool(
name="get_forecast",
inputSchema={
"properties": {"city": {"type": "string"}},
@ -217,7 +217,7 @@ class TestToolFunctionSource:
assert "async def get_forecast(" in source
def test_sanitizes_tool_name(self):
tool = mcp.types.Tool(
tool = mcp_types.Tool(
name="my.tool/v2",
inputSchema={"properties": {}},
)
@ -226,7 +226,7 @@ class TestToolFunctionSource:
assert "name='my.tool/v2'" in source
def test_sanitizes_param_name(self):
tool = mcp.types.Tool(
tool = mcp_types.Tool(
name="fetch",
inputSchema={
"properties": {"content-type": {"type": "string", "description": "CT"}},
@ -238,7 +238,7 @@ class TestToolFunctionSource:
assert "'content-type': content_type" in source
def test_description_in_docstring(self):
tool = mcp.types.Tool(
tool = mcp_types.Tool(
name="greet",
description="Say hello to someone.",
inputSchema={
@ -250,7 +250,7 @@ class TestToolFunctionSource:
assert "'''Say hello to someone.'''" in source
def test_description_with_quotes(self):
tool = mcp.types.Tool(
tool = mcp_types.Tool(
name="fetch",
description="Fetch data from 'source' API.",
inputSchema={
@ -265,7 +265,7 @@ class TestToolFunctionSource:
compile(source, "<test>", "exec")
def test_array_of_strings_parameter(self):
tool = mcp.types.Tool(
tool = mcp_types.Tool(
name="tag_items",
description="Tag multiple items.",
inputSchema={
@ -285,7 +285,7 @@ class TestToolFunctionSource:
compile(source, "<test>", "exec")
def test_complex_object_parameter(self):
tool = mcp.types.Tool(
tool = mcp_types.Tool(
name="create_user",
description="Create a user.",
inputSchema={
@ -318,7 +318,7 @@ class TestToolFunctionSource:
compile(source, "<test>", "exec")
def test_nested_array_parameter(self):
tool = mcp.types.Tool(
tool = mcp_types.Tool(
name="batch_process",
description="Process batches.",
inputSchema={
@ -346,7 +346,7 @@ class TestToolFunctionSource:
def test_complex_type_with_default(self):
"""Test that complex types with defaults are JSON-serialized."""
tool = mcp.types.Tool(
tool = mcp_types.Tool(
name="configure",
inputSchema={
"properties": {
@ -367,7 +367,7 @@ class TestToolFunctionSource:
def test_name_collision_detection(self):
"""Test that parameter name collisions are detected."""
tool = mcp.types.Tool(
tool = mcp_types.Tool(
name="test",
inputSchema={
"properties": {
@ -409,9 +409,9 @@ class TestDeriveServerName:
class TestGenerateCliScript:
def _make_tools(self) -> list[mcp.types.Tool]:
def _make_tools(self) -> list[mcp_types.Tool]:
return [
mcp.types.Tool(
mcp_types.Tool(
name="greet",
description="Say hello",
inputSchema={
@ -421,7 +421,7 @@ class TestGenerateCliScript:
"required": ["name"],
},
),
mcp.types.Tool(
mcp_types.Tool(
name="add_numbers",
description="Add two numbers",
inputSchema={
@ -507,7 +507,7 @@ class TestGenerateCliScript:
def test_compiles_with_unusual_names(self):
tools = [
mcp.types.Tool(
mcp_types.Tool(
name="my.tool/v2",
description="A tool with dots and slashes",
inputSchema={
@ -771,7 +771,7 @@ class TestGenerateSkillContent:
def test_tool_sections(self):
tools = [
mcp.types.Tool(
mcp_types.Tool(
name="greet",
description="Say hello",
inputSchema={
@ -794,7 +794,7 @@ class TestGenerateSkillContent:
def test_frontmatter_with_tools_starts_at_column_zero(self):
tools = [
mcp.types.Tool(
mcp_types.Tool(
name="greet",
inputSchema={"type": "object", "properties": {}},
),
@ -804,7 +804,7 @@ class TestGenerateSkillContent:
def test_optional_param(self):
tools = [
mcp.types.Tool(
mcp_types.Tool(
name="search",
description="Search things",
inputSchema={
@ -824,7 +824,7 @@ class TestGenerateSkillContent:
def test_complex_json_param(self):
tools = [
mcp.types.Tool(
mcp_types.Tool(
name="create",
description="Create item",
inputSchema={
@ -844,7 +844,7 @@ class TestGenerateSkillContent:
def test_no_params_tool(self):
tools = [
mcp.types.Tool(
mcp_types.Tool(
name="ping",
description="Ping the server",
inputSchema={"type": "object", "properties": {}},
@ -863,7 +863,7 @@ class TestGenerateSkillContent:
def test_pipe_in_description_escaped(self):
tools = [
mcp.types.Tool(
mcp_types.Tool(
name="test",
description="Test",
inputSchema={
@ -879,7 +879,7 @@ class TestGenerateSkillContent:
def test_union_type_pipes_escaped(self):
tools = [
mcp.types.Tool(
mcp_types.Tool(
name="test",
description="Test",
inputSchema={
@ -896,7 +896,7 @@ class TestGenerateSkillContent:
def test_boolean_param_no_value_placeholder(self):
tools = [
mcp.types.Tool(
mcp_types.Tool(
name="run",
description="Run something",
inputSchema={

2
tests/client/auth/test_oauth_client.py
View file

@ -5,7 +5,7 @@ from urllib.parse import urlparse
import httpx
import pytest
from mcp.types import TextResourceContents
from mcp_types import TextResourceContents
import fastmcp.client.auth.oauth as oauth_module
import fastmcp.utilities.http as http_module

2
tests/client/client/test_client.py
View file

@ -8,7 +8,7 @@ from typing import Any, cast
import anyio
import pytest
from mcp import ClientSession, McpError
from mcp.types import TextContent
from mcp_types import TextContent
from pydantic import AnyUrl
import fastmcp

18
tests/client/client/test_error_handling.py
View file

@ -2,9 +2,9 @@
import logging
import mcp.types
import mcp_types
import pytest
from mcp.types import TextContent, ToolUseContent
from mcp_types import TextContent, ToolUseContent
from pydantic import AnyUrl
from fastmcp.client import Client
@ -207,7 +207,7 @@ class TestParseToolResultEdgeCases:
"""
async def test_error_with_empty_content_raises_with_fallback_message(self):
result = mcp.types.CallToolResult(content=[], isError=True)
result = mcp_types.CallToolResult(content=[], isError=True)
with pytest.raises(ToolError, match="Tool 'my_tool' returned an error"):
await _parse_call_tool_result(
@ -219,9 +219,9 @@ class TestParseToolResultEdgeCases:
)
async def test_error_with_non_text_content_raises_with_fallback_message(self):
result = mcp.types.CallToolResult(
result = mcp_types.CallToolResult(
content=[
mcp.types.ImageContent(type="image", data="abc", mimeType="image/png")
mcp_types.ImageContent(type="image", data="abc", mimeType="image/png")
],
isError=True,
)
@ -236,8 +236,8 @@ class TestParseToolResultEdgeCases:
)
async def test_error_with_text_content_raises_with_message(self):
result = mcp.types.CallToolResult(
content=[mcp.types.TextContent(type="text", text="custom error msg")],
result = mcp_types.CallToolResult(
content=[mcp_types.TextContent(type="text", text="custom error msg")],
isError=True,
)
@ -251,8 +251,8 @@ class TestParseToolResultEdgeCases:
)
async def test_error_with_structured_content_does_not_parse_data(self):
result = mcp.types.CallToolResult(
content=[mcp.types.TextContent(type="text", text="error happened")],
result = mcp_types.CallToolResult(
content=[mcp_types.TextContent(type="text", text="error happened")],
isError=True,
structuredContent={"key": "value"},
)

4
tests/client/sampling/handlers/test_anthropic_handler.py
View file

@ -4,7 +4,7 @@ from unittest.mock import MagicMock
import pytest
from anthropic import AsyncAnthropic
from anthropic.types import Message, TextBlock, ToolUseBlock, Usage
from mcp.types import (
from mcp_types import (
AudioContent,
CreateMessageResult,
CreateMessageResultWithTools,
@ -296,7 +296,7 @@ def test_convert_tool_choice_unknown_raises():
def test_convert_tools_to_anthropic():
from mcp.types import Tool
from mcp_types import Tool
tools = [
Tool(

2
tests/client/sampling/handlers/test_google_genai_handler.py
View file

@ -14,7 +14,7 @@ try:
Part,
UserContent,
)
from mcp.types import (
from mcp_types import (
AudioContent,
CreateMessageResult,
ImageContent,

2
tests/client/sampling/handlers/test_openai_handler.py
View file

@ -2,7 +2,7 @@ from typing import Any
from unittest.mock import AsyncMock, MagicMock
import pytest
from mcp.types import (
from mcp_types import (
AudioContent,
CreateMessageRequestParams,
CreateMessageResult,

2
tests/client/tasks/test_client_task_notifications.py
View file

@ -10,7 +10,7 @@ import time
from datetime import datetime, timezone
import pytest
from mcp.types import GetTaskResult
from mcp_types import GetTaskResult
from fastmcp import FastMCP
from fastmcp.client import Client

2
tests/client/test_elicitation.py
View file

@ -3,7 +3,7 @@ from enum import Enum
from typing import Any, Literal, cast
import pytest
from mcp.types import ElicitRequestFormParams, ElicitRequestParams
from mcp_types import ElicitRequestFormParams, ElicitRequestParams
from pydantic import BaseModel
from typing_extensions import TypedDict

12
tests/client/test_logs.py
View file

@ -2,7 +2,7 @@ import logging
import pytest
from mcp import LoggingLevel
from mcp.types import LoggingMessageNotificationParams
from mcp_types import LoggingMessageNotificationParams
from fastmcp import Client, Context, FastMCP
from fastmcp.client.logging import LogMessage, create_log_callback
@ -191,7 +191,7 @@ class TestDefaultLogHandler:
"""Test that default_log_handler routes server logs to appropriate Python log levels."""
from unittest.mock import MagicMock, patch
from mcp.types import LoggingMessageNotificationParams
from mcp_types import LoggingMessageNotificationParams
from fastmcp.client.logging import default_log_handler
@ -242,7 +242,7 @@ class TestDefaultLogHandler:
"""Test that default_log_handler works when logger name is None."""
from unittest.mock import MagicMock, patch
from mcp.types import LoggingMessageNotificationParams
from mcp_types import LoggingMessageNotificationParams
from fastmcp.client.logging import default_log_handler
@ -265,7 +265,7 @@ class TestDefaultLogHandler:
"""Test that default_log_handler handles dict data correctly."""
from unittest.mock import MagicMock, patch
from mcp.types import LoggingMessageNotificationParams
from mcp_types import LoggingMessageNotificationParams
from fastmcp.client.logging import default_log_handler
@ -291,7 +291,7 @@ class TestDefaultLogHandler:
"""Test that default_log_handler handles list data correctly."""
from unittest.mock import MagicMock, patch
from mcp.types import LoggingMessageNotificationParams
from mcp_types import LoggingMessageNotificationParams
from fastmcp.client.logging import default_log_handler
@ -316,7 +316,7 @@ class TestDefaultLogHandler:
"""Test that default_log_handler handles numeric data correctly."""
from unittest.mock import MagicMock, patch
from mcp.types import LoggingMessageNotificationParams
from mcp_types import LoggingMessageNotificationParams
from fastmcp.client.logging import default_log_handler

14
tests/client/test_notifications.py
View file

@ -1,7 +1,7 @@
from dataclasses import dataclass, field
from datetime import datetime
import mcp.types
import mcp_types
import pytest
from fastmcp import Client, FastMCP
@ -14,7 +14,7 @@ class NotificationRecording:
"""Record of a notification that was received."""
method: str
notification: mcp.types.ServerNotification
notification: mcp_types.ServerNotification
timestamp: datetime = field(default_factory=datetime.now)
@ -26,7 +26,7 @@ class RecordingMessageHandler(MessageHandler):
self.notifications: list[NotificationRecording] = []
self.name = name
async def on_notification(self, message: mcp.types.ServerNotification) -> None:
async def on_notification(self, message: mcp_types.ServerNotification) -> None:
"""Record all notifications with timestamp."""
self.notifications.append(
NotificationRecording(method=message.root.method, notification=message)
@ -83,7 +83,7 @@ class TestNotificationAPI:
@server.tool
async def trigger_notification(ctx: Context) -> str:
"""Send a notification using the async API."""
await ctx.send_notification(mcp.types.ToolListChangedNotification())
await ctx.send_notification(mcp_types.ToolListChangedNotification())
return "Notification sent"
async with Client(server, message_handler=recording_message_handler) as client:
@ -104,9 +104,9 @@ class TestNotificationAPI:
@server.tool
async def trigger_all_notifications(ctx: Context) -> str:
"""Send all notification types."""
await ctx.send_notification(mcp.types.ToolListChangedNotification())
await ctx.send_notification(mcp.types.ResourceListChangedNotification())
await ctx.send_notification(mcp.types.PromptListChangedNotification())
await ctx.send_notification(mcp_types.ToolListChangedNotification())
await ctx.send_notification(mcp_types.ResourceListChangedNotification())
await ctx.send_notification(mcp_types.PromptListChangedNotification())
return "All notifications sent"
async with Client(server, message_handler=recording_message_handler) as client:

2
tests/client/test_openapi.py
View file

@ -2,7 +2,7 @@ import json
import pytest
from fastapi import FastAPI, Request
from mcp.types import TextResourceContents
from mcp_types import TextResourceContents
from fastmcp import Client, FastMCP
from fastmcp.client.transports import SSETransport, StreamableHttpTransport

10
tests/client/test_sampling.py
View file

@ -3,7 +3,7 @@ from typing import cast
from unittest.mock import AsyncMock
import pytest
from mcp.types import TextContent
from mcp_types import TextContent
from pydantic_core import to_json
from fastmcp import Client, Context, FastMCP
@ -185,7 +185,7 @@ class TestSamplingDefaultCapabilities:
{"sampling": {"tools": {}}}, ensuring compatibility with servers
that don't recognize the tools sub-field (e.g. older Java MCP SDK).
"""
import mcp.types as mcp_types
import mcp_types
server = FastMCP()
@ -201,7 +201,7 @@ class TestSamplingDefaultCapabilities:
async def test_set_sampling_callback_default_capabilities_omit_tools(self):
"""set_sampling_callback should also default to no tools capability."""
import mcp.types as mcp_types
import mcp_types
server = FastMCP()
client = Client(server)
@ -212,7 +212,7 @@ class TestSamplingDefaultCapabilities:
async def test_explicit_tools_capability_is_preserved(self):
"""Explicitly passing tools capability should be respected."""
import mcp.types as mcp_types
import mcp_types
server = FastMCP()
@ -237,7 +237,7 @@ class TestSamplingWithTools:
async def test_sampling_with_tools_requires_capability(self):
"""Test that sampling with tools raises error when client lacks capability."""
import mcp.types as mcp_types
import mcp_types
from fastmcp.exceptions import ToolError

22
tests/client/test_sampling_result_types.py
View file

@ -1,5 +1,5 @@
import pytest
from mcp.types import CreateMessageResultWithTools, TextContent, ToolUseContent
from mcp_types import CreateMessageResultWithTools, TextContent, ToolUseContent
from fastmcp import Client, Context, FastMCP
from fastmcp.client.sampling import RequestContext, SamplingMessage, SamplingParams
@ -10,7 +10,7 @@ class TestSamplingResultType:
async def test_result_type_creates_final_response_tool(self):
"""Test that result_type creates a synthetic final_response tool."""
from mcp.types import CreateMessageResultWithTools, ToolUseContent
from mcp_types import CreateMessageResultWithTools, ToolUseContent
from pydantic import BaseModel
class MathResult(BaseModel):
@ -63,7 +63,7 @@ class TestSamplingResultType:
async def test_result_type_with_user_tools(self):
"""Test result_type works alongside user-provided tools."""
from mcp.types import CreateMessageResultWithTools, ToolUseContent
from mcp_types import CreateMessageResultWithTools, ToolUseContent
from pydantic import BaseModel
class SearchResult(BaseModel):
@ -138,7 +138,7 @@ class TestSamplingResultType:
async def test_result_type_validation_error_retries(self):
"""Test that validation errors are sent back to LLM for retry."""
from mcp.types import (
from mcp_types import (
CreateMessageResultWithTools,
ToolResultContent,
ToolUseContent,
@ -228,7 +228,7 @@ class TestSamplingResultType:
async def test_sampling_result_has_text_and_history(self):
"""Test that SamplingResult has text, result, and history attributes."""
from mcp.types import CreateMessageResultWithTools
from mcp_types import CreateMessageResultWithTools
def sampling_handler(
messages: list[SamplingMessage], params: SamplingParams, ctx: RequestContext
@ -262,7 +262,7 @@ class TestSampleStep:
async def test_sample_step_basic(self):
"""Test basic sample_step returns text response."""
from mcp.types import CreateMessageResultWithTools
from mcp_types import CreateMessageResultWithTools
def sampling_handler(
messages: list[SamplingMessage], params: SamplingParams, ctx: RequestContext
@ -290,7 +290,7 @@ class TestSampleStep:
async def test_sample_step_with_tool_execution(self):
"""Test sample_step executes tools by default."""
from mcp.types import CreateMessageResultWithTools, ToolUseContent
from mcp_types import CreateMessageResultWithTools, ToolUseContent
call_count = 0
@ -349,7 +349,7 @@ class TestSampleStep:
async def test_sample_step_execute_tools_false(self):
"""Test sample_step with execute_tools=False doesn't execute tools."""
from mcp.types import CreateMessageResultWithTools, ToolUseContent
from mcp_types import CreateMessageResultWithTools, ToolUseContent
tool_executed = False
@ -400,7 +400,7 @@ class TestSampleStep:
async def test_sample_step_history_includes_assistant_message(self):
"""Test that history includes assistant message when execute_tools=False."""
from mcp.types import CreateMessageResultWithTools, ToolUseContent
from mcp_types import CreateMessageResultWithTools, ToolUseContent
def sampling_handler(
messages: list[SamplingMessage], params: SamplingParams, ctx: RequestContext
@ -448,7 +448,7 @@ class TestTextResponseRetry:
@staticmethod
def _text_reply(text: str = "some text"):
from mcp.types import CreateMessageResultWithTools
from mcp_types import CreateMessageResultWithTools
return CreateMessageResultWithTools(
role="assistant",
@ -459,7 +459,7 @@ class TestTextResponseRetry:
@staticmethod
def _tool_reply(value: int):
from mcp.types import CreateMessageResultWithTools, ToolUseContent
from mcp_types import CreateMessageResultWithTools, ToolUseContent
return CreateMessageResultWithTools(
role="assistant",

22
tests/client/test_sampling_tool_loop.py
View file

@ -1,6 +1,6 @@
from typing import cast
from mcp.types import TextContent
from mcp_types import TextContent
from fastmcp import Client, Context, FastMCP
from fastmcp.client.sampling import RequestContext, SamplingMessage, SamplingParams
@ -12,7 +12,7 @@ class TestAutomaticToolLoop:
async def test_automatic_tool_loop_executes_tools(self):
"""Test that ctx.sample() automatically executes tool calls."""
from mcp.types import CreateMessageResultWithTools, ToolUseContent
from mcp_types import CreateMessageResultWithTools, ToolUseContent
call_count = 0
tool_was_called = False
@ -75,7 +75,7 @@ class TestAutomaticToolLoop:
async def test_automatic_tool_loop_multiple_tools(self):
"""Test that multiple tool calls in one response are all executed."""
from mcp.types import CreateMessageResultWithTools, ToolUseContent
from mcp_types import CreateMessageResultWithTools, ToolUseContent
executed_tools: list[str] = []
@ -135,7 +135,7 @@ class TestAutomaticToolLoop:
async def test_automatic_tool_loop_handles_unknown_tool(self):
"""Test that unknown tool names result in error being passed to LLM."""
from mcp.types import (
from mcp_types import (
CreateMessageResultWithTools,
ToolResultContent,
ToolUseContent,
@ -210,7 +210,7 @@ class TestAutomaticToolLoop:
async def test_automatic_tool_loop_handles_tool_exception(self):
"""Test that tool exceptions are caught and passed to LLM as errors."""
from mcp.types import (
from mcp_types import (
CreateMessageResultWithTools,
ToolResultContent,
ToolUseContent,
@ -287,7 +287,7 @@ class TestAutomaticToolLoop:
import asyncio
import time
from mcp.types import CreateMessageResultWithTools, ToolUseContent
from mcp_types import CreateMessageResultWithTools, ToolUseContent
execution_order: list[tuple[str, float]] = []
@ -367,7 +367,7 @@ class TestAutomaticToolLoop:
import asyncio
import time
from mcp.types import CreateMessageResultWithTools, ToolUseContent
from mcp_types import CreateMessageResultWithTools, ToolUseContent
execution_times: dict[str, dict[str, float]] = {}
@ -447,7 +447,7 @@ class TestAutomaticToolLoop:
import asyncio
import time
from mcp.types import CreateMessageResultWithTools, ToolUseContent
from mcp_types import CreateMessageResultWithTools, ToolUseContent
execution_order: list[tuple[str, float]] = []
@ -533,7 +533,7 @@ class TestAutomaticToolLoop:
import asyncio
import time
from mcp.types import CreateMessageResultWithTools, ToolUseContent
from mcp_types import CreateMessageResultWithTools, ToolUseContent
execution_order: list[tuple[str, float]] = []
@ -620,7 +620,7 @@ class TestAutomaticToolLoop:
async def test_concurrent_tool_execution_error_handling(self):
"""Test that errors are captured per-tool in parallel execution."""
from mcp.types import (
from mcp_types import (
CreateMessageResultWithTools,
ToolResultContent,
ToolUseContent,
@ -689,7 +689,7 @@ class TestAutomaticToolLoop:
"""Test that tool results maintain the same order as tool calls."""
import asyncio
from mcp.types import (
from mcp_types import (
CreateMessageResultWithTools,
ToolResultContent,
ToolUseContent,

2
tests/client/test_sse.py
View file

@ -4,7 +4,7 @@ import sys
import pytest
from mcp import McpError
from mcp.types import TextResourceContents
from mcp_types import TextResourceContents
from fastmcp.client import Client
from fastmcp.client.transports import SSETransport

2
tests/client/test_streamable_http.py
View file

@ -6,7 +6,7 @@ from unittest.mock import AsyncMock, call
import pytest
from mcp import McpError
from mcp.types import TextResourceContents
from mcp_types import TextResourceContents
from fastmcp import Context
from fastmcp.client import Client

10
tests/conformance/server.py
View file

@ -10,8 +10,8 @@ import json
import sys
from enum import Enum as PyEnum
import mcp.types
from mcp.types import EmbeddedResource, ImageContent, TextContent
import mcp_types
from mcp_types import EmbeddedResource, ImageContent, TextContent
from pydantic import AnyUrl, BaseModel, Field
from fastmcp import FastMCP
@ -76,7 +76,7 @@ async def test_embedded_resource() -> list:
return [
EmbeddedResource(
type="resource",
resource=mcp.types.TextResourceContents(
resource=mcp_types.TextResourceContents(
uri=AnyUrl("test://embedded-resource"),
mimeType="text/plain",
text="This is an embedded resource content.",
@ -97,7 +97,7 @@ async def test_multiple_content_types() -> list:
),
EmbeddedResource(
type="resource",
resource=mcp.types.TextResourceContents(
resource=mcp_types.TextResourceContents(
uri=AnyUrl("test://mixed-content-resource"),
mimeType="application/json",
text='{"test":"data","value":123}',
@ -347,7 +347,7 @@ async def test_prompt_with_embedded_resource(resourceUri: str) -> list:
Message(
EmbeddedResource(
type="resource",
resource=mcp.types.TextResourceContents(
resource=mcp_types.TextResourceContents(
uri=AnyUrl(resourceUri),
mimeType="text/plain",
text=f"Content of resource {resourceUri}",

2
tests/conftest.py
View file

@ -198,7 +198,7 @@ def tool_server():
"""Fixture that creates a FastMCP server with comprehensive tool set for provider tests."""
import base64
from mcp.types import (
from mcp_types import (
BlobResourceContents,
EmbeddedResource,
ImageContent,

2
tests/contrib/test_bulk_tool_caller.py
View file

@ -2,7 +2,7 @@ from typing import Any
import pytest
from inline_snapshot import snapshot
from mcp.types import TextContent
from mcp_types import TextContent
from fastmcp import FastMCP
from fastmcp.contrib.bulk_tool_caller.bulk_tool_caller import (

2
tests/contrib/test_mcp_mixin.py
View file

@ -276,7 +276,7 @@ class TestMCPMixin:
async def test_tool_with_title_and_meta(self):
"""Test that title (via annotations) and meta arguments are properly passed through."""
from mcp.types import ToolAnnotations
from mcp_types import ToolAnnotations
mcp = FastMCP()

2
tests/deprecated/test_import_server.py
View file

@ -1,7 +1,7 @@
import json
from urllib.parse import quote
from mcp.types import TextContent, TextResourceContents
from mcp_types import TextContent, TextResourceContents
from fastmcp.client.client import Client
from fastmcp.server.server import FastMCP

4
tests/deprecated/test_tool_injection_middleware.py
View file

@ -2,8 +2,8 @@
import pytest
from inline_snapshot import snapshot
from mcp.types import TextContent
from mcp.types import Tool as SDKTool
from mcp_types import TextContent
from mcp_types import Tool as SDKTool
from fastmcp import FastMCP
from fastmcp.client import Client

2
tests/deprecated/test_tool_serializer.py
View file

@ -8,7 +8,7 @@ import warnings
import pytest
from inline_snapshot import snapshot
from mcp.types import TextContent
from mcp_types import TextContent
from fastmcp import FastMCP
from fastmcp.contrib.mcp_mixin import mcp_tool

2
tests/experimental/transforms/test_code_mode.py
View file

@ -5,7 +5,7 @@ import json
from typing import Any
import pytest
from mcp.types import ImageContent, TextContent
from mcp_types import ImageContent, TextContent
from fastmcp import Client, FastMCP
from fastmcp.exceptions import ToolError

2
tests/experimental/transforms/test_code_mode_discovery.py
View file

@ -1,7 +1,7 @@
import json
from typing import Any
from mcp.types import TextContent
from mcp_types import TextContent
from fastmcp import FastMCP
from fastmcp.experimental.transforms.code_mode import (

2
tests/integration_tests/test_github_mcp_remote.py
View file

@ -3,7 +3,7 @@ import os
import pytest
from mcp import McpError
from mcp.types import Resource, TextContent, Tool
from mcp_types import Resource, TextContent, Tool
from fastmcp import Client
from fastmcp.client import StreamableHttpTransport

20
tests/prompts/test_prompt.py
View file

@ -1,5 +1,5 @@
import pytest
from mcp.types import EmbeddedResource, TextResourceContents
from mcp_types import EmbeddedResource, TextResourceContents
from pydantic import FileUrl
from fastmcp.prompts.base import (
@ -580,7 +580,7 @@ class TestPromptArgumentDescriptions:
class TestMessage:
def test_message_string_content(self):
"""Test Message with string content."""
from mcp.types import TextContent
from mcp_types import TextContent
msg = Message("Hello, world!")
assert msg.role == "user"
@ -589,7 +589,7 @@ class TestMessage:
def test_message_with_role(self):
"""Test Message with explicit role."""
from mcp.types import TextContent
from mcp_types import TextContent
msg = Message("I can help.", role="assistant")
assert msg.role == "assistant"
@ -598,7 +598,7 @@ class TestMessage:
def test_message_auto_serializes_dict(self):
"""Test Message auto-serializes dicts to JSON."""
from mcp.types import TextContent
from mcp_types import TextContent
msg = Message({"key": "value", "nested": {"a": 1}})
assert msg.role == "user"
@ -608,7 +608,7 @@ class TestMessage:
def test_message_auto_serializes_list(self):
"""Test Message auto-serializes lists to JSON."""
from mcp.types import TextContent
from mcp_types import TextContent
msg = Message(["item1", "item2", "item3"])
assert isinstance(msg.content, TextContent)
@ -616,7 +616,7 @@ class TestMessage:
def test_message_to_mcp_prompt_message(self):
"""Test conversion to MCP PromptMessage."""
from mcp.types import TextContent
from mcp_types import TextContent
msg = Message("Hello", role="assistant")
mcp_msg = msg.to_mcp_prompt_message()
@ -626,7 +626,7 @@ class TestMessage:
def test_message_passthrough_image_content(self):
"""Test Message passes through ImageContent without JSON serialization."""
from mcp.types import ImageContent
from mcp_types import ImageContent
img = ImageContent(type="image", data="base64data", mimeType="image/png")
msg = Message(img, role="user")
@ -636,7 +636,7 @@ class TestMessage:
def test_message_passthrough_audio_content(self):
"""Test Message passes through AudioContent without JSON serialization."""
from mcp.types import AudioContent
from mcp_types import AudioContent
audio = AudioContent(type="audio", data="base64audio", mimeType="audio/wav")
msg = Message(audio, role="user")
@ -646,7 +646,7 @@ class TestMessage:
def test_message_image_content_to_mcp_prompt_message(self):
"""Test that ImageContent round-trips through to_mcp_prompt_message."""
from mcp.types import ImageContent
from mcp_types import ImageContent
img = ImageContent(type="image", data="base64data", mimeType="image/png")
msg = Message(img, role="user")
@ -658,7 +658,7 @@ class TestMessage:
class TestPromptResult:
def test_promptresult_from_string(self):
"""Test PromptResult accepts string and wraps as Message."""
from mcp.types import TextContent
from mcp_types import TextContent
result = PromptResult("Hello!")
assert len(result.messages) == 1

2
tests/resources/test_resource_template_meta.py
View file

@ -1,4 +1,4 @@
from mcp.types import Annotations, Icon
from mcp_types import Annotations, Icon
from fastmcp import FastMCP
from fastmcp.resources import ResourceTemplate

10
tests/resources/test_resources.py
View file

@ -1,4 +1,4 @@
import mcp.types
import mcp_types
import pytest
from pydantic import AnyUrl, BaseModel
@ -174,7 +174,7 @@ class TestResourceContent:
content="hello", mime_type="text/plain", meta={"k": "v"}
)
mcp_content = content.to_mcp_resource_contents("resource://test")
assert isinstance(mcp_content, mcp.types.TextResourceContents)
assert isinstance(mcp_content, mcp_types.TextResourceContents)
assert mcp_content.text == "hello"
assert mcp_content.mimeType == "text/plain"
assert str(mcp_content.uri) == "resource://test"
@ -186,7 +186,7 @@ class TestResourceContent:
content=b"\x00\x01\x02", mime_type="application/octet-stream"
)
mcp_content = content.to_mcp_resource_contents("resource://binary")
assert isinstance(mcp_content, mcp.types.BlobResourceContents)
assert isinstance(mcp_content, mcp_types.BlobResourceContents)
assert mcp_content.blob == "AAEC" # base64 of \x00\x01\x02
assert mcp_content.mimeType == "application/octet-stream"
@ -250,9 +250,9 @@ class TestResourceResult:
meta={"source": "test"},
)
mcp_result = result.to_mcp_result("resource://test")
assert isinstance(mcp_result, mcp.types.ReadResourceResult)
assert isinstance(mcp_result, mcp_types.ReadResourceResult)
assert len(mcp_result.contents) == 1
assert isinstance(mcp_result.contents[0], mcp.types.TextResourceContents)
assert isinstance(mcp_result.contents[0], mcp_types.TextResourceContents)
assert mcp_result.contents[0].text == "hello"
assert str(mcp_result.contents[0].uri) == "resource://test"
assert mcp_result.meta == {"source": "test"}

2
tests/server/auth/test_authorization.py
View file

@ -2,7 +2,7 @@
from unittest.mock import Mock
import mcp.types as mcp_types
import mcp_types
import pytest
from mcp.server.auth.middleware.auth_context import auth_context_var
from mcp.server.auth.middleware.bearer_auth import AuthenticatedUser

2
tests/server/auth/test_enhanced_error_responses.py
View file

@ -152,7 +152,7 @@ class TestEnhancedAuthorizationHandler:
def test_html_error_includes_server_branding(self, oauth_proxy):
"""Test that HTML error page includes server branding from FastMCP instance."""
from mcp.types import Icon
from mcp_types import Icon
# Create FastMCP server with custom branding
mcp = FastMCP(

2
tests/server/auth/test_oauth_consent_page.py
View file

@ -10,7 +10,7 @@ import pytest
from key_value.aio.stores.memory import MemoryStore
from mcp.server.auth.provider import AuthorizationParams
from mcp.shared.auth import OAuthClientInformationFull
from mcp.types import Icon
from mcp_types import Icon
from pydantic import AnyUrl
from starlette.applications import Starlette
from starlette.testclient import TestClient

2
tests/server/http/test_http_dependencies.py
View file

@ -1,7 +1,7 @@
import json
import pytest
from mcp.types import TextContent, TextResourceContents
from mcp_types import TextContent, TextResourceContents
from starlette.requests import Request
from fastmcp.client import Client

Some files were not shown because too many files have changed in this diff Show more