fast-agent-mcp 0.2.58__py3-none-any.whl → 0.3.1__py3-none-any.whl

mcp_agent/mcp/helpers/__init__.py

@@ -1,25 +0,0 @@
-"""
-Helper modules for working with MCP content.
-"""
-
-from .content_helpers import (
-    get_image_data,
-    get_resource_text,
-    get_resource_uri,
-    get_text,
-    is_image_content,
-    is_resource_content,
-    is_resource_link,
-    is_text_content,
-)
-
-__all__ = [
-    "get_text",
-    "get_image_data",
-    "get_resource_uri",
-    "is_text_content",
-    "is_image_content",
-    "is_resource_content",
-    "is_resource_link",
-    "get_resource_text",
-]

mcp_agent/mcp/helpers/content_helpers.py

@@ -1,187 +0,0 @@
-"""
-Helper functions for working with content objects.
-
-These utilities simplify extracting content from content structures
-without repetitive type checking.
-"""
-
-from typing import Optional, Union
-
-from mcp.types import (
-    BlobResourceContents,
-    ContentBlock,
-    EmbeddedResource,
-    ImageContent,
-    ReadResourceResult,
-    ResourceLink,
-    TextContent,
-    TextResourceContents,
-)
-
-
-def get_text(content: ContentBlock) -> Optional[str]:
-    """
-    Extract text content from a content object if available.
-
-    Args:
-        content: A content object ContentBlock
-
-    Returns:
-        The text content as a string or None if not a text content
-    """
-    if isinstance(content, TextContent):
-        return content.text
-
-    if isinstance(content, TextResourceContents):
-        return content.text
-
-    if isinstance(content, EmbeddedResource):
-        if isinstance(content.resource, TextResourceContents):
-            return content.resource.text
-
-    return None
-
-
-def get_image_data(content: ContentBlock) -> Optional[str]:
-    """
-    Extract image data from a content object if available.
-
-    Args:
-        content: A content object ContentBlock
-
-    Returns:
-        The image data as a base64 string or None if not an image content
-    """
-    if isinstance(content, ImageContent):
-        return content.data
-
-    if isinstance(content, EmbeddedResource):
-        if isinstance(content.resource, BlobResourceContents):
-            # This assumes the blob might be an image, which isn't always true
-            # Consider checking the mimeType if needed
-            return content.resource.blob
-
-    return None
-
-
-def get_resource_uri(content: ContentBlock) -> Optional[str]:
-    """
-    Extract resource URI from an EmbeddedResource if available.
-
-    Args:
-        content: A content object ContentBlock
-
-    Returns:
-        The resource URI as a string or None if not an embedded resource
-    """
-    if isinstance(content, EmbeddedResource):
-        return str(content.resource.uri)
-
-    return None
-
-
-def is_text_content(content: ContentBlock) -> bool:
-    """
-    Check if the content is text content.
-
-    Args:
-        content: A content object ContentBlock
-
-    Returns:
-        True if the content is TextContent, False otherwise
-    """
-    return isinstance(content, TextContent) or isinstance(content, TextResourceContents)
-
-
-def is_image_content(content: Union[TextContent, ImageContent, EmbeddedResource]) -> bool:
-    """
-    Check if the content is image content.
-
-    Args:
-        content: A content object ContentBlock
-
-    Returns:
-        True if the content is ImageContent, False otherwise
-    """
-    return isinstance(content, ImageContent)
-
-
-def is_resource_content(content: ContentBlock) -> bool:
-    """
-    Check if the content is an embedded resource.
-
-    Args:
-        content: A content object ContentBlock
-
-    Returns:
-        True if the content is EmbeddedResource, False otherwise
-    """
-    return isinstance(content, EmbeddedResource)
-
-
-def is_resource_link(content: ContentBlock) -> bool:
-    """
-    Check if the content is an embedded resource.
-
-    Args:
-        content: A ContentBlock object
-
-    Returns:
-        True if the content is ResourceLink, False otherwise
-    """
-    return isinstance(content, ResourceLink)
-
-
-def get_resource_text(result: ReadResourceResult, index: int = 0) -> Optional[str]:
-    """
-    Extract text content from a ReadResourceResult at the specified index.
-
-    Args:
-        result: A ReadResourceResult from an MCP resource read operation
-        index: Index of the content item to extract text from (default: 0)
-
-    Returns:
-        The text content as a string or None if not available or not text content
-
-    Raises:
-        IndexError: If the index is out of bounds for the contents list
-    """
-    if index >= len(result.contents):
-        raise IndexError(
-            f"Index {index} out of bounds for contents list of length {len(result.contents)}"
-        )
-
-    content = result.contents[index]
-    if isinstance(content, TextResourceContents):
-        return content.text
-
-    return None
-
-
-def split_thinking_content(message: str) -> tuple[Optional[str], str]:
-    """
-    Split a message into thinking and content parts.
-
-    Extracts content between <thinking> tags and returns it along with the remaining content.
-
-    Args:
-        message: A string that may contain a <thinking>...</thinking> block followed by content
-
-    Returns:
-        A tuple of (thinking_content, main_content) where:
-        - thinking_content: The content inside <thinking> tags, or None if not found/parsing fails
-        - main_content: The content after the thinking block, or the entire message if no thinking block
-    """
-    import re
-
-    # Pattern to match <thinking>...</thinking> at the start of the message
-    pattern = r"^<think>(.*?)</think>\s*(.*)$"
-    match = re.match(pattern, message, re.DOTALL)
-
-    if match:
-        thinking_content = match.group(1).strip()
-        main_content = match.group(2).strip()
-        return (thinking_content, main_content)
-    else:
-        # No thinking block found or parsing failed
-        return (None, message)

mcp_agent/mcp/interfaces.py

@@ -1,266 +0,0 @@
-"""
-Interface definitions to prevent circular imports.
-This module defines protocols (interfaces) that can be used to break circular dependencies.
-"""
-
-from datetime import timedelta
-from typing import (
-    TYPE_CHECKING,
-    Any,
-    AsyncContextManager,
-    Callable,
-    Dict,
-    List,
-    Mapping,
-    Optional,
-    Protocol,
-    Tuple,
-    Type,
-    TypeVar,
-    Union,
-    runtime_checkable,
-)
-
-from a2a.types import AgentCard
-from anyio.streams.memory import MemoryObjectReceiveStream, MemoryObjectSendStream
-from deprecated import deprecated
-from mcp import ClientSession
-from mcp.types import GetPromptResult, Prompt, PromptMessage, ReadResourceResult, Tool
-from pydantic import BaseModel
-
-from mcp_agent.core.agent_types import AgentType
-from mcp_agent.core.request_params import RequestParams
-from mcp_agent.mcp.prompt_message_multipart import PromptMessageMultipart
-
-if TYPE_CHECKING:
-    from mcp_agent.llm.usage_tracking import UsageAccumulator
-
-
-__all__ = [
-    "MCPConnectionManagerProtocol",
-    "ServerRegistryProtocol",
-    "ServerConnection",
-    "AugmentedLLMProtocol",
-    "AgentProtocol",
-    "ModelFactoryClassProtocol",
-    "ModelT",
-]
-
-
-@runtime_checkable
-class MCPConnectionManagerProtocol(Protocol):
-    """Protocol for MCPConnectionManager functionality needed by ServerRegistry."""
-
-    async def get_server(
-        self,
-        server_name: str,
-        client_session_factory: Optional[
-            Callable[
-                [
-                    MemoryObjectReceiveStream,
-                    MemoryObjectSendStream,
-                    Optional[timedelta],
-                ],
-                ClientSession,
-            ]
-        ] = None,
-    ) -> "ServerConnection": ...
-
-    async def disconnect_server(self, server_name: str) -> None: ...
-
-    async def disconnect_all_servers(self) -> None: ...
-
-
-@runtime_checkable
-class ServerRegistryProtocol(Protocol):
-    """Protocol defining the minimal interface of ServerRegistry needed by gen_client."""
-
-    @property
-    def connection_manager(self) -> MCPConnectionManagerProtocol: ...
-
-    def initialize_server(
-        self,
-        server_name: str,
-        client_session_factory: Optional[
-            Callable[
-                [
-                    MemoryObjectReceiveStream,
-                    MemoryObjectSendStream,
-                    Optional[timedelta],
-                ],
-                ClientSession,
-            ]
-        ] = None,
-        init_hook: Optional[Callable] = None,
-    ) -> AsyncContextManager[ClientSession]:
-        """Initialize a server and yield a client session."""
-        ...
-
-
-class ServerConnection(Protocol):
-    """Protocol for server connection objects returned by MCPConnectionManager."""
-
-    @property
-    def session(self) -> ClientSession: ...
-
-
-ModelT = TypeVar("ModelT", bound=BaseModel)
-
-
-class AugmentedLLMProtocol(Protocol):
-    """Protocol defining the interface for augmented LLMs"""
-
-    async def structured(
-        self,
-        multipart_messages: List[Union[PromptMessageMultipart, PromptMessage]],
-        model: Type[ModelT],
-        request_params: RequestParams | None = None,
-    ) -> Tuple[ModelT | None, PromptMessageMultipart]:
-        """Apply the prompt and return the result as a Pydantic model, or None if coercion fails"""
-        ...
-
-    async def generate(
-        self,
-        multipart_messages: List[Union[PromptMessageMultipart, PromptMessage]],
-        request_params: RequestParams | None = None,
-    ) -> PromptMessageMultipart:
-        """
-        Apply a list of PromptMessageMultipart messages directly to the LLM.
-
-
-        Args:
-            multipart_messages: List of PromptMessageMultipart objects
-            request_params: Optional parameters to configure the LLM request
-
-        Returns:
-            A PromptMessageMultipart containing the Assistant response, including Tool Content
-        """
-        ...
-
-    async def apply_prompt_template(
-        self, prompt_result: "GetPromptResult", prompt_name: str
-    ) -> str:
-        """
-        Apply a prompt template as persistent context that will be included in all future conversations.
-
-        Args:
-            prompt_result: The GetPromptResult containing prompt messages
-            prompt_name: The name of the prompt being applied
-
-        Returns:
-            String representation of the assistant's response if generated
-        """
-        ...
-
-    @property
-    def message_history(self) -> List[PromptMessageMultipart]:
-        """
-        Return the LLM's message history as PromptMessageMultipart objects.
-
-        Returns:
-            List of PromptMessageMultipart objects representing the conversation history
-        """
-        ...
-
-    usage_accumulator: "UsageAccumulator"
-
-
-class AgentProtocol(AugmentedLLMProtocol, Protocol):
-    """Protocol defining the standard agent interface"""
-
-    name: str
-
-    @property
-    def agent_type(self) -> AgentType:
-        """Return the type of this agent"""
-        ...
-
-    async def __call__(self, message: Union[str, PromptMessage, PromptMessageMultipart]) -> str:
-        """Make the agent callable for sending messages directly."""
-        ...
-
-    async def send(self, message: Union[str, PromptMessage, PromptMessageMultipart]) -> str:
-        """Send a message to the agent and get a response"""
-        ...
-
-    async def apply_prompt(
-        self,
-        prompt: Union[str, "GetPromptResult"],
-        arguments: Dict[str, str] | None = None,
-        as_template: bool = False,
-    ) -> str:
-        """Apply an MCP prompt template by name or GetPromptResult object"""
-        ...
-
-    async def get_prompt(
-        self,
-        prompt_name: str,
-        arguments: Dict[str, str] | None = None,
-        server_name: str | None = None,
-    ) -> GetPromptResult: ...
-
-    async def list_prompts(self, server_name: str | None = None) -> Mapping[str, List[Prompt]]: ...
-
-    async def list_resources(self, server_name: str | None = None) -> Mapping[str, List[str]]: ...
-
-    async def list_mcp_tools(self, server_name: str | None = None) -> Mapping[str, List[Tool]]: ...
-
-    async def get_resource(
-        self, resource_uri: str, server_name: str | None = None
-    ) -> ReadResourceResult:
-        """Get a resource from a specific server or search all servers"""
-        ...
-
-    @deprecated
-    async def generate_str(self, message: str, request_params: RequestParams | None = None) -> str:
-        """Generate a response. Deprecated: Use send(), generate() or structured()  instead"""
-        ...
-
-    @deprecated
-    async def prompt(self, default_prompt: str = "") -> str:
-        """Start an interactive prompt session with the agent. Deprecated. Use agent_app.interactive() instead."""
-        ...
-
-    async def with_resource(
-        self,
-        prompt_content: Union[str, PromptMessage, PromptMessageMultipart],
-        resource_uri: str,
-        server_name: str | None = None,
-    ) -> str:
-        """Send a message with an attached MCP resource"""
-        ...
-
-    async def agent_card(self) -> AgentCard:
-        """Return an A2A Agent Card for this Agent"""
-        ...
-
-    async def initialize(self) -> None:
-        """Initialize the agent and connect to MCP servers"""
-        ...
-
-    async def shutdown(self) -> None:
-        """Shut down the agent and close connections"""
-        ...
-
-
-class ModelFactoryClassProtocol(Protocol):
-    """
-    Protocol defining the minimal interface of the ModelFactory class needed by sampling.
-    This allows sampling.py to depend on this protocol rather than the concrete ModelFactory class.
-    """
-
-    @classmethod
-    def create_factory(
-        cls, model_string: str, request_params: Optional[RequestParams] = None
-    ) -> Callable[..., Any]:
-        """
-        Creates a factory function that can be used to construct an LLM instance.
-
-        Args:
-            model_string: The model specification string
-            request_params: Optional parameters to configure LLM behavior
-
-        Returns:
-            A factory function that can create an LLM instance
-        """
-        ...

mcp_agent/mcp/prompts/__main__.py

@@ -1,10 +0,0 @@
-from mcp_agent.mcp.prompts.prompt_server import main
-
-# This must be here for the console entry points defined in pyproject.toml
-# DO NOT REMOVE!
-
-# For the entry point in pyproject.toml
-app = main
-
-if __name__ == "__main__":
-    main()