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

{mcp_agent → fast_agent}/llm/usage_tracking.py

@@ -9,13 +9,24 @@ import time
 from typing import List, Optional, Union
 
 # Proper type imports for each provider
-from anthropic.types import Usage as AnthropicUsage
-from google.genai.types import GenerateContentResponseUsageMetadata as GoogleUsage
-from openai.types.completion_usage import CompletionUsage as OpenAIUsage
+try:
+    from anthropic.types import Usage as AnthropicUsage
+except Exception:  # pragma: no cover - optional dependency
+    AnthropicUsage = object  # type: ignore
+
+try:
+    from google.genai.types import GenerateContentResponseUsageMetadata as GoogleUsage
+except Exception:  # pragma: no cover - optional dependency
+    GoogleUsage = object  # type: ignore
+
+try:
+    from openai.types.completion_usage import CompletionUsage as OpenAIUsage
+except Exception:  # pragma: no cover - optional dependency
+    OpenAIUsage = object  # type: ignore
 from pydantic import BaseModel, Field, computed_field
 
-from mcp_agent.llm.model_database import ModelDatabase
-from mcp_agent.llm.provider_types import Provider
+from fast_agent.llm.model_database import ModelDatabase
+from fast_agent.llm.provider_types import Provider
 
 
 # Fast-agent specific usage type for synthetic providers
@@ -230,6 +241,13 @@ class UsageAccumulator(BaseModel):
         if self.model is None:
             self.model = turn.model
 
+    # add tool call count to the last turn (if present)
+    # not ideal way to do it, but works well enough. full history would be available through the
+    # message_history; maybe we consolidate there and put turn_usage on the turn.
+    def count_tools(self, tool_calls: int) -> None:
+        if self.turns and self.turns[-1]:
+            self.turns[-1].tool_calls = tool_calls
+
     @computed_field
     @property
     def cumulative_input_tokens(self) -> int:

fast_agent/mcp/__init__.py

@@ -0,0 +1,54 @@
+"""
+MCP utilities and types for fast-agent.
+
+Public API:
+- `Prompt`: helper for constructing MCP prompts/messages.
+- `PromptMessageExtended`: canonical message container used internally by providers.
+- Helpers from `fast_agent.mcp.helpers` (re-exported for convenience).
+
+Note: Backward compatibility for legacy `PromptMessageMultipart` imports is handled
+via `fast_agent.mcp.prompt_message_multipart`, which subclasses `PromptMessageExtended`.
+"""
+
+from .helpers import (
+    ensure_multipart_messages,
+    get_image_data,
+    get_resource_text,
+    get_resource_uri,
+    get_text,
+    is_image_content,
+    is_resource_content,
+    is_resource_link,
+    is_text_content,
+    normalize_to_extended_list,
+    split_thinking_content,
+    text_content,
+)
+from .prompt_message_extended import PromptMessageExtended
+
+__all__ = [
+    "Prompt",
+    "PromptMessageExtended",
+    # Helpers
+    "get_text",
+    "get_image_data",
+    "get_resource_uri",
+    "is_text_content",
+    "is_image_content",
+    "is_resource_content",
+    "is_resource_link",
+    "get_resource_text",
+    "ensure_multipart_messages",
+    "normalize_to_extended_list",
+    "split_thinking_content",
+    "text_content",
+]
+
+
+def __getattr__(name: str):
+    # Lazily import to avoid circular imports with fast_agent.types
+    if name == "Prompt":
+        from .prompt import Prompt  # local import
+
+        return Prompt
+    raise AttributeError(f"module '{__name__}' has no attribute '{name}'")

{mcp_agent → fast_agent}/mcp/elicitation_factory.py

@@ -6,9 +6,9 @@ from typing import Any, Optional
 
 from mcp.client.session import ElicitationFnT
 
-from mcp_agent.core.agent_types import AgentConfig
-from mcp_agent.logging.logger import get_logger
-from mcp_agent.mcp.elicitation_handlers import (
+from fast_agent.agents.agent_types import AgentConfig
+from fast_agent.core.logging.logger import get_logger
+from fast_agent.mcp.elicitation_handlers import (
     auto_cancel_elicitation_handler,
     forms_elicitation_handler,
 )

{mcp_agent → fast_agent}/mcp/elicitation_handlers.py

@@ -8,10 +8,10 @@ from typing import TYPE_CHECKING, Any
 from mcp.shared.context import RequestContext
 from mcp.types import ElicitRequestParams, ElicitResult, ErrorData
 
-from mcp_agent.human_input.elicitation_handler import elicitation_input_callback
-from mcp_agent.human_input.types import HumanInputRequest
-from mcp_agent.logging.logger import get_logger
-from mcp_agent.mcp.helpers.server_config_helpers import get_server_config
+from fast_agent.core.logging.logger import get_logger
+from fast_agent.human_input.elicitation_handler import elicitation_input_callback
+from fast_agent.human_input.types import HumanInputRequest
+from fast_agent.mcp.helpers.server_config_helpers import get_server_config
 
 if TYPE_CHECKING:
     from mcp import ClientSession
@@ -24,7 +24,7 @@ async def auto_cancel_elicitation_handler(
     params: ElicitRequestParams,
 ) -> ElicitResult | ErrorData:
     """Handler that automatically cancels all elicitation requests.
-    
+
     Useful for production deployments where you want to advertise elicitation
     capability but automatically decline all requests.
     """
@@ -51,7 +51,8 @@ async def forms_elicitation_handler(
     agent_name: str | None = None
 
     # 1. Check if we have an MCPAgentClientSession in the context
-    from mcp_agent.mcp.mcp_agent_client_session import MCPAgentClientSession
+    from fast_agent.mcp.mcp_agent_client_session import MCPAgentClientSession
+
     if hasattr(context, "session") and isinstance(context.session, MCPAgentClientSession):
         agent_name = context.session.agent_name
 
@@ -90,9 +91,17 @@ async def forms_elicitation_handler(
         elif response_data == "__CANCELLED__":
             return ElicitResult(action="cancel")
         elif response_data == "__DISABLE_SERVER__":
-            # Log that user wants to disable elicitation for this server
-            logger.warning(f"User requested to disable elicitation for server: {server_name}")
-            # For now, just cancel - in a full implementation, this would update server config
+            # Respect user's request: disable elicitation for this server for this session
+            logger.warning(
+                f"User requested to disable elicitation for server: {server_name} — disabling for session"
+            )
+            try:
+                from fast_agent.human_input.elicitation_state import elicitation_state
+
+                elicitation_state.disable_server(server_name)
+            except Exception:
+                # Do not fail the flow if state update fails
+                pass
             return ElicitResult(action="cancel")
 
         # Parse response based on schema if provided
@@ -152,4 +161,4 @@ async def forms_elicitation_handler(
         return ElicitResult(action="accept", content=content)
     except (KeyboardInterrupt, EOFError, TimeoutError):
         # User cancelled or timeout
-        return ElicitResult(action="cancel")
+        return ElicitResult(action="cancel")

{mcp_agent → fast_agent}/mcp/gen_client.py

@@ -5,9 +5,9 @@ from typing import AsyncGenerator, Callable
 from anyio.streams.memory import MemoryObjectReceiveStream, MemoryObjectSendStream
 from mcp import ClientSession
 
-from mcp_agent.logging.logger import get_logger
-from mcp_agent.mcp.interfaces import ServerRegistryProtocol
-from mcp_agent.mcp.mcp_agent_client_session import MCPAgentClientSession
+from fast_agent.core.logging.logger import get_logger
+from fast_agent.mcp.interfaces import ServerRegistryProtocol
+from fast_agent.mcp.mcp_agent_client_session import MCPAgentClientSession
 
 logger = get_logger(__name__)
 

fast_agent/mcp/helpers/__init__.py

@@ -0,0 +1,36 @@
+"""
+Helper modules for working with MCP content (Fast Agent namespace).
+
+This mirrors the legacy fast_agent.mcp.helpers API to provide a stable,
+cycle-free import path now that PromptMessageExtended lives in fast_agent.mcp.
+"""
+
+from .content_helpers import (
+    ensure_multipart_messages,
+    get_image_data,
+    get_resource_text,
+    get_resource_uri,
+    get_text,
+    is_image_content,
+    is_resource_content,
+    is_resource_link,
+    is_text_content,
+    normalize_to_extended_list,
+    split_thinking_content,
+    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",
+    "ensure_multipart_messages",
+    "normalize_to_extended_list",
+    "split_thinking_content",
+    "text_content",
+]

fast_agent/mcp/helpers/content_helpers.py

@@ -0,0 +1,183 @@
+"""
+Helper functions for working with content objects (Fast Agent namespace).
+
+"""
+
+from typing import TYPE_CHECKING, List, Optional, Sequence, Union
+
+if TYPE_CHECKING:
+    from fast_agent.mcp.prompt_message_extended import PromptMessageExtended
+
+from mcp.types import (
+    BlobResourceContents,
+    ContentBlock,
+    EmbeddedResource,
+    ImageContent,
+    PromptMessage,
+    ReadResourceResult,
+    ResourceLink,
+    TextContent,
+    TextResourceContents,
+)
+
+
+def get_text(content: ContentBlock) -> Optional[str]:
+    """Extract text content from a content object if available."""
+    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
+
+    if isinstance(content, ResourceLink):
+        name = content.name or "unknown"
+        uri_str = str(content.uri)
+        mime_type = content.mimeType or "unknown"
+        description = content.description or "No description"
+
+        return (
+            f"Linked Resource ${name} MIME type {mime_type}>\n"
+            f"Resource Link: {uri_str}\n"
+            f"${description}\n"
+        )
+
+    return None
+
+
+def get_image_data(content: ContentBlock) -> Optional[str]:
+    """Extract image data from a content object if available."""
+    if isinstance(content, ImageContent):
+        return content.data
+
+    if isinstance(content, EmbeddedResource):
+        if isinstance(content.resource, BlobResourceContents):
+            return content.resource.blob
+
+    return None
+
+
+def get_resource_uri(content: ContentBlock) -> Optional[str]:
+    """Extract resource URI from an EmbeddedResource if available."""
+    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."""
+    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."""
+    return isinstance(content, ImageContent)
+
+
+def is_resource_content(content: ContentBlock) -> bool:
+    """Check if the content is an embedded resource."""
+    return isinstance(content, EmbeddedResource)
+
+
+def is_resource_link(content: ContentBlock) -> bool:
+    """Check if the content is a resource link."""
+    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."""
+    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."""
+    import re
+
+    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:
+        return (None, message)
+
+
+def text_content(text: str) -> TextContent:
+    """Convenience to create a TextContent block from a string."""
+    return TextContent(type="text", text=text)
+
+
+def ensure_multipart_messages(
+    messages: List[Union["PromptMessageExtended", PromptMessage]],
+) -> List["PromptMessageExtended"]:
+    """Ensure all messages in a list are PromptMessageExtended objects."""
+    # Import here to avoid circular dependency
+    from fast_agent.mcp.prompt_message_extended import PromptMessageExtended
+
+    if not messages:
+        return []
+
+    result = []
+    for message in messages:
+        if isinstance(message, PromptMessage):
+            result.append(PromptMessageExtended(role=message.role, content=[message.content]))
+        else:
+            result.append(message)
+
+    return result
+
+
+def normalize_to_extended_list(
+    messages: Union[
+        str,
+        PromptMessage,
+        "PromptMessageExtended",
+        Sequence[Union[str, PromptMessage, "PromptMessageExtended"]],
+    ],
+) -> List["PromptMessageExtended"]:
+    """Normalize various input types to a list of PromptMessageExtended objects."""
+    # Import here to avoid circular dependency
+    from fast_agent.mcp.prompt_message_extended import PromptMessageExtended
+
+    if messages is None:
+        return []
+
+    # Single string → convert to user PromptMessageExtended
+    if isinstance(messages, str):
+        return [
+            PromptMessageExtended(role="user", content=[TextContent(type="text", text=messages)])
+        ]
+
+    # Single PromptMessage → convert to PromptMessageExtended
+    if isinstance(messages, PromptMessage):
+        return [PromptMessageExtended(role=messages.role, content=[messages.content])]
+
+    # Single PromptMessageExtended → wrap in a list
+    if isinstance(messages, PromptMessageExtended):
+        return [messages]
+
+    # List of mixed types → convert each element
+    result: List[PromptMessageExtended] = []
+    for item in messages:
+        if isinstance(item, str):
+            result.append(
+                PromptMessageExtended(role="user", content=[TextContent(type="text", text=item)])
+            )
+        elif isinstance(item, PromptMessage):
+            result.append(PromptMessageExtended(role=item.role, content=[item.content]))
+        else:
+            result.append(item)
+
+    return result

{mcp_agent → fast_agent}/mcp/helpers/server_config_helpers.py

@@ -3,23 +3,23 @@
 from typing import TYPE_CHECKING, Any, Optional
 
 if TYPE_CHECKING:
-    from mcp_agent.config import MCPServerSettings
+    from fast_agent.config import MCPServerSettings
 
 
 def get_server_config(ctx: Any) -> Optional["MCPServerSettings"]:
     """Extract server config from context if available.
-    
+
     Type guard helper that safely accesses server_config with proper type checking.
     """
     # Import here to avoid circular import
-    from mcp_agent.mcp.mcp_agent_client_session import MCPAgentClientSession
-    
+    from fast_agent.mcp.mcp_agent_client_session import MCPAgentClientSession
+
     # Check if ctx has a session attribute (RequestContext case)
     if hasattr(ctx, "session"):
-        if isinstance(ctx.session, MCPAgentClientSession) and hasattr(ctx.session, 'server_config'):
+        if isinstance(ctx.session, MCPAgentClientSession) and hasattr(ctx.session, "server_config"):
             return ctx.session.server_config
     # Also check if ctx itself is MCPAgentClientSession (direct call case)
-    elif isinstance(ctx, MCPAgentClientSession) and hasattr(ctx, 'server_config'):
+    elif isinstance(ctx, MCPAgentClientSession) and hasattr(ctx, "server_config"):
         return ctx.server_config
-    
-    return None
+
+    return None

{mcp_agent → fast_agent}/mcp/hf_auth.py

@@ -8,10 +8,10 @@ from urllib.parse import urlparse
 def is_huggingface_url(url: str) -> bool:
     """
     Check if a URL is a HuggingFace URL that should receive HF_TOKEN authentication.
-    
+
     Args:
         url: The URL to check
-        
+
     Returns:
         True if the URL is a HuggingFace URL, False otherwise
     """
@@ -20,11 +20,11 @@ def is_huggingface_url(url: str) -> bool:
         hostname = parsed.hostname
         if hostname is None:
             return False
-        
+
         # Check for HuggingFace domains
         if hostname in {"hf.co", "huggingface.co"}:
             return True
-            
+
         # Check for HuggingFace Spaces (*.hf.space)
         # Use endswith to match subdomains like space-name.hf.space
         # but ensure exact match to prevent spoofing like evil.hf.space.com
@@ -35,12 +35,14 @@ def is_huggingface_url(url: str) -> bool:
             if len(parts) == 3 and parts[-2:] == ["hf", "space"]:
                 space_name = parts[0]
                 # Validate space name: not empty, not just hyphens/dots, no spaces
-                return (len(space_name) > 0 and 
-                        space_name != "-" and 
-                        not space_name.startswith(".") and
-                        not space_name.endswith(".") and
-                        " " not in space_name)
-            
+                return (
+                    len(space_name) > 0
+                    and space_name != "-"
+                    and not space_name.startswith(".")
+                    and not space_name.endswith(".")
+                    and " " not in space_name
+                )
+
         return False
     except Exception:
         return False
@@ -49,7 +51,7 @@ def is_huggingface_url(url: str) -> bool:
 def get_hf_token_from_env() -> Optional[str]:
     """
     Get the HuggingFace token from the HF_TOKEN environment variable.
-    
+
     Returns:
         The HF_TOKEN value if set, None otherwise
     """
@@ -59,11 +61,11 @@ def get_hf_token_from_env() -> Optional[str]:
 def should_add_hf_auth(url: str, existing_headers: Optional[Dict[str, str]]) -> bool:
     """
     Determine if HuggingFace authentication should be added to the headers.
-    
+
     Args:
         url: The URL to check
         existing_headers: Existing headers dictionary (may be None)
-        
+
     Returns:
         True if HF auth should be added, False otherwise
     """
@@ -71,10 +73,10 @@ def should_add_hf_auth(url: str, existing_headers: Optional[Dict[str, str]]) ->
     # 1. URL is a HuggingFace URL
     # 2. No existing Authorization/X-HF-Authorization header is set
     # 3. HF_TOKEN environment variable is available
-    
+
     if not is_huggingface_url(url):
         return False
-        
+
     if existing_headers:
         # Check if this is a .hf.space domain
         try:
@@ -92,31 +94,31 @@ def should_add_hf_auth(url: str, existing_headers: Optional[Dict[str, str]]) ->
             # Fallback to checking Authorization header
             if "Authorization" in existing_headers:
                 return False
-        
+
     return get_hf_token_from_env() is not None
 
 
 def add_hf_auth_header(url: str, headers: Optional[Dict[str, str]]) -> Optional[Dict[str, str]]:
     """
     Add HuggingFace authentication header if appropriate.
-    
+
     Args:
         url: The URL to check
         headers: Existing headers dictionary (may be None)
-        
+
     Returns:
         Updated headers dictionary with HF auth if appropriate, or original headers
     """
     if not should_add_hf_auth(url, headers):
         return headers
-        
+
     hf_token = get_hf_token_from_env()
     if hf_token is None:
         return headers
-        
+
     # Create new headers dict or copy existing one
     result_headers = dict(headers) if headers else {}
-    
+
     # Check if this is a .hf.space domain
     try:
         parsed = urlparse(url)
@@ -130,5 +132,5 @@ def add_hf_auth_header(url: str, headers: Optional[Dict[str, str]]) -> Optional[
     except Exception:
         # Fallback to standard Authorization header
         result_headers["Authorization"] = f"Bearer {hf_token}"
-    
-    return result_headers
+
+    return result_headers

fast_agent/mcp/interfaces.py

@@ -0,0 +1,93 @@
+"""
+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 (
+    AsyncContextManager,
+    Callable,
+    Optional,
+    Protocol,
+    runtime_checkable,
+)
+
+from anyio.streams.memory import MemoryObjectReceiveStream, MemoryObjectSendStream
+from mcp import ClientSession
+
+from fast_agent.interfaces import (
+    AgentProtocol,
+    FastAgentLLMProtocol,
+    LlmAgentProtocol,
+    LLMFactoryProtocol,
+    ModelFactoryFunctionProtocol,
+    ModelT,
+)
+
+__all__ = [
+    "MCPConnectionManagerProtocol",
+    "ServerRegistryProtocol",
+    "ServerConnection",
+    "FastAgentLLMProtocol",
+    "AgentProtocol",
+    "LlmAgentProtocol",
+    "LLMFactoryProtocol",
+    "ModelFactoryFunctionProtocol",
+    "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,
+    ) -> 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: ...

{mcp_agent → fast_agent}/mcp/logger_textio.py

@@ -6,7 +6,7 @@ import io
 import os
 from typing import TextIO
 
-from mcp_agent.logging.logger import get_logger
+from fast_agent.core.logging.logger import get_logger
 
 logger = get_logger(__name__)
 
@@ -82,13 +82,13 @@ class LoggerTextIO(TextIO):
         This prevents output from showing on the terminal
         while still allowing our write() method to capture it for logging.
         """
-        if not hasattr(self, '_devnull_fd'):
+        if not hasattr(self, "_devnull_fd"):
             self._devnull_fd = os.open(os.devnull, os.O_WRONLY)
         return self._devnull_fd
-        
+
     def __del__(self):
         """Clean up the devnull file descriptor."""
-        if hasattr(self, '_devnull_fd'):
+        if hasattr(self, "_devnull_fd"):
             try:
                 os.close(self._devnull_fd)
             except (OSError, AttributeError):