fast-agent-mcp 0.2.53__tar.gz → 0.2.55__tar.gz

{fast_agent_mcp-0.2.53 → fast_agent_mcp-0.2.55}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fast-agent-mcp
-Version: 0.2.53
+Version: 0.2.55
 Summary: Define, Prompt and Test MCP enabled Agents and Workflows
 Author-email: Shaun Smith <fastagent@llmindset.co.uk>
 License:                                  Apache License
@@ -218,7 +218,7 @@ Requires-Dist: deprecated>=1.2.18
 Requires-Dist: email-validator>=2.2.0
 Requires-Dist: fastapi>=0.115.6
 Requires-Dist: google-genai>=1.27.0
-Requires-Dist: mcp==1.12.1
+Requires-Dist: mcp==1.12.4
 Requires-Dist: openai>=1.97.1
 Requires-Dist: opentelemetry-distro>=0.55b0
 Requires-Dist: opentelemetry-exporter-otlp-proto-http>=1.7.0

{fast_agent_mcp-0.2.53 → fast_agent_mcp-0.2.55}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "fast-agent-mcp"
-version = "0.2.53"
+version = "0.2.55"
 description = "Define, Prompt and Test MCP enabled Agents and Workflows"
 readme = "README.md"
 license = { file = "LICENSE" }
@@ -15,7 +15,7 @@ classifiers = [
 requires-python = ">=3.13"
 dependencies = [
     "fastapi>=0.115.6",
-    "mcp==1.12.1",
+    "mcp==1.12.4",
     "opentelemetry-distro>=0.55b0",
     "opentelemetry-exporter-otlp-proto-http>=1.7.0",
     "pydantic-settings>=2.7.0",

{fast_agent_mcp-0.2.53 → fast_agent_mcp-0.2.55}/src/mcp_agent/agents/base_agent.py

@@ -783,6 +783,60 @@ class BaseAgent(MCPAggregator, AgentProtocol):
 
         return result
 
+    async def list_mcp_tools(self, server_name: str | None = None) -> Mapping[str, List[Tool]]:
+        """
+        List all tools available to this agent, grouped by server and filtered by configuration.
+
+        Args:
+            server_name: Optional server name to list tools from
+
+        Returns:
+            Dictionary mapping server names to lists of Tool objects (with original names, not namespaced)
+        """
+        if not self.initialized:
+            await self.initialize()
+
+        # Get all tools from the parent class
+        result = await super().list_mcp_tools(server_name)
+
+        # Apply filtering if tools are specified in config
+        if self.config.tools is not None:
+            filtered_result = {}
+            for server, tools in result.items():
+                # Check if this server has tool filters
+                if server in self.config.tools:
+                    filtered_tools = []
+                    for tool in tools:
+                        # Check if tool matches any pattern for this server
+                        for pattern in self.config.tools[server]:
+                            if self._matches_pattern(tool.name, pattern, server):
+                                filtered_tools.append(tool)
+                                break
+                    if filtered_tools:
+                        filtered_result[server] = filtered_tools
+            result = filtered_result
+
+        # Add human input tool to a special server if human input is configured
+        if self.human_input_callback:
+            from mcp.server.fastmcp.tools import Tool as FastTool
+
+            human_input_tool: FastTool = FastTool.from_function(self.request_human_input)
+            special_server_name = "__human_input__"
+            
+            # If the special server doesn't exist in result, create it
+            if special_server_name not in result:
+                result[special_server_name] = []
+            
+            result[special_server_name].append(
+                Tool(
+                    name=HUMAN_INPUT_TOOL_NAME,
+                    description=human_input_tool.description,
+                    inputSchema=human_input_tool.parameters,
+                )
+            )
+
+        return result
+
     @property
     def agent_type(self) -> AgentType:
         """

{fast_agent_mcp-0.2.53 → fast_agent_mcp-0.2.55}/src/mcp_agent/llm/model_database.py

@@ -91,7 +91,10 @@ class ModelDatabase:
     )
 
     QWEN_STANDARD = ModelParameters(
-        context_window=32000, max_output_tokens=8192, tokenizes=QWEN_MULTIMODAL
+        context_window=32000,
+        max_output_tokens=8192,
+        tokenizes=QWEN_MULTIMODAL,
+        json_mode="object",
     )
     QWEN3_REASONER = ModelParameters(
         context_window=131072,

{fast_agent_mcp-0.2.53 → fast_agent_mcp-0.2.55}/src/mcp_agent/llm/providers/augmented_llm_aliyun.py

@@ -1,24 +1,26 @@
 from mcp_agent.core.request_params import RequestParams
 from mcp_agent.llm.provider_types import Provider
+from mcp_agent.llm.providers.augmented_llm_groq import GroqAugmentedLLM
 from mcp_agent.llm.providers.augmented_llm_openai import OpenAIAugmentedLLM
 
 ALIYUN_BASE_URL = "https://dashscope.aliyuncs.com/compatible-mode/v1"
 DEFAULT_QWEN_MODEL = "qwen-turbo"
 
 
-class AliyunAugmentedLLM(OpenAIAugmentedLLM):
+class AliyunAugmentedLLM(GroqAugmentedLLM):
     def __init__(self, *args, **kwargs) -> None:
-        super().__init__(*args, provider=Provider.ALIYUN, **kwargs)
+        OpenAIAugmentedLLM.__init__(self, *args, provider=Provider.ALIYUN, **kwargs)
 
     def _initialize_default_params(self, kwargs: dict) -> RequestParams:
         """Initialize Aliyun-specific default parameters"""
         # Get base defaults from parent (includes ModelDatabase lookup)
         base_params = super()._initialize_default_params(kwargs)
-        
+
         # Override with Aliyun-specific settings
         chosen_model = kwargs.get("model", DEFAULT_QWEN_MODEL)
         base_params.model = chosen_model
-        
+        base_params.parallel_tool_calls = True
+
         return base_params
 
     def _base_url(self) -> str:
@@ -27,3 +29,4 @@ class AliyunAugmentedLLM(OpenAIAugmentedLLM):
             base_url = self.context.config.aliyun.base_url
 
         return base_url if base_url else ALIYUN_BASE_URL
+

{fast_agent_mcp-0.2.53 → fast_agent_mcp-0.2.55}/src/mcp_agent/llm/providers/augmented_llm_groq.py

@@ -46,7 +46,7 @@ class GroqAugmentedLLM(OpenAIAugmentedLLM):
         assert self.default_request_params
         llm_model = self.default_request_params.model or DEFAULT_GROQ_MODEL
         json_mode: str | None = ModelDatabase.get_json_mode(llm_model)
-        if "json_object" == json_mode:
+        if "object" == json_mode:
             request_params.response_format = {"type": "json_object"}
 
         # Get the full schema and extract just the properties

{fast_agent_mcp-0.2.53 → fast_agent_mcp-0.2.55}/src/mcp_agent/llm/providers/augmented_llm_openai.py

@@ -321,20 +321,20 @@ class OpenAIAugmentedLLM(AugmentedLLM[ChatCompletionMessageParam, ChatCompletion
 
         response = await self.aggregator.list_tools()
         available_tools: List[ChatCompletionToolParam] | None = [
-            ChatCompletionToolParam(
-                type="function",
-                function={
+            {
+                "type": "function",
+                "function": {
                     "name": tool.name,
                     "description": tool.description if tool.description else "",
                     "parameters": self.adjust_schema(tool.inputSchema),
                 },
-            )
+            }
             for tool in response.tools
         ]
 
         if not available_tools:
-            if self.provider == Provider.DEEPSEEK:
-                available_tools = None  # deepseek does not allow empty array
+            if self.provider in [Provider.DEEPSEEK, Provider.ALIYUN]:
+                available_tools = None  # deepseek/aliyun does not allow empty array
             else:
                 available_tools = []
 

{fast_agent_mcp-0.2.53 → fast_agent_mcp-0.2.55}/src/mcp_agent/mcp/interfaces.py

@@ -25,7 +25,7 @@ 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
+from mcp.types import GetPromptResult, Prompt, PromptMessage, ReadResourceResult, Tool
 from pydantic import BaseModel
 
 from mcp_agent.core.agent_types import AgentType
@@ -203,6 +203,8 @@ class AgentProtocol(AugmentedLLMProtocol, Protocol):
 
     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:

{fast_agent_mcp-0.2.53 → fast_agent_mcp-0.2.55}/src/mcp_agent/mcp/mcp_aggregator.py

@@ -1232,3 +1232,55 @@ class MCPAggregator(ContextDependent):
                 logger.error(f"Error fetching resources from {s_name}: {e}")
 
         return results
+
+    async def list_mcp_tools(self, server_name: str | None = None) -> Dict[str, List[Tool]]:
+        """
+        List available tools from one or all servers, grouped by server name.
+        
+        Args:
+            server_name: Optional server name to list tools from. If not provided,
+                        lists tools from all servers.
+        
+        Returns:
+            Dictionary mapping server names to lists of Tool objects (with original names, not namespaced)
+        """
+        if not self.initialized:
+            await self.load_servers()
+
+        results: Dict[str, List[Tool]] = {}
+
+        # Get the list of servers to check  
+        servers_to_check = [server_name] if server_name else self.server_names
+
+        # For each server, try to list its tools
+        for s_name in servers_to_check:
+            if s_name not in self.server_names:
+                logger.error(f"Server '{s_name}' not found")
+                continue
+
+            # Initialize empty list for this server
+            results[s_name] = []
+
+            # Check if server supports tools capability
+            if not await self.server_supports_feature(s_name, "tools"):
+                logger.debug(f"Server '{s_name}' does not support tools")
+                continue
+
+            try:
+                # Use the _execute_on_server method to call list_tools on the server
+                result = await self._execute_on_server(
+                    server_name=s_name,
+                    operation_type="tools-list",
+                    operation_name="",
+                    method_name="list_tools",
+                    method_args={},
+                )
+
+                # Get tools from result (these have original names, not namespaced)
+                tools = getattr(result, "tools", [])
+                results[s_name] = tools
+
+            except Exception as e:
+                logger.error(f"Error fetching tools from {s_name}: {e}")
+
+        return results