utcp-mcp 1.0.0__tar.gz

utcp_mcp-1.0.0/PKG-INFO

@@ -0,0 +1,25 @@
+Metadata-Version: 2.4
+Name: utcp-mcp
+Version: 1.0.0
+Summary: Universal Tool Calling Protocol (UTCP) client library for Python
+Author: UTCP Contributors
+License-Expression: MPL-2.0
+Project-URL: Homepage, https://utcp.io
+Project-URL: Source, https://github.com/universal-tool-calling-protocol/python-utcp
+Project-URL: Issues, https://github.com/universal-tool-calling-protocol/python-utcp/issues
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: pydantic>=2.0
+Requires-Dist: mcp>=1.12
+Requires-Dist: utcp>=1.0
+Provides-Extra: dev
+Requires-Dist: build; extra == "dev"
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: pytest-asyncio; extra == "dev"
+Requires-Dist: pytest-cov; extra == "dev"
+Requires-Dist: coverage; extra == "dev"
+Requires-Dist: twine; extra == "dev"

utcp_mcp-1.0.0/pyproject.toml

@@ -0,0 +1,43 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "utcp-mcp"
+version = "1.0.0"
+authors = [
+  { name = "UTCP Contributors" },
+]
+description = "Universal Tool Calling Protocol (UTCP) client library for Python"
+readme = "README.md"
+requires-python = ">=3.10"
+dependencies = [
+    "pydantic>=2.0",
+    "mcp>=1.12",
+    "utcp>=1.0"
+]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "Programming Language :: Python :: 3",
+    "Operating System :: OS Independent",
+]
+license = "MPL-2.0"
+
+[project.optional-dependencies]
+dev = [
+    "build",
+    "pytest",
+    "pytest-asyncio",
+    "pytest-cov",
+    "coverage",
+    "twine",
+]
+
+[project.urls]
+Homepage = "https://utcp.io"
+Source = "https://github.com/universal-tool-calling-protocol/python-utcp"
+Issues = "https://github.com/universal-tool-calling-protocol/python-utcp/issues"
+
+[project.entry-points."utcp.plugins"]
+mcp = "utcp_mcp:register"

utcp_mcp-1.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

utcp_mcp-1.0.0/src/utcp_mcp/__init__.py

@@ -0,0 +1,13 @@
+from utcp_mcp.mcp_communication_protocol import McpCommunicationProtocol
+from utcp_mcp.mcp_call_template import McpCallTemplate, McpCallTemplateSerializer
+from utcp.plugins.discovery import register_communication_protocol, register_call_template
+
+def register():
+    register_communication_protocol("mcp", McpCommunicationProtocol())
+    register_call_template("mcp", McpCallTemplateSerializer())
+
+__all__ = [
+    "McpCommunicationProtocol",
+    "McpCallTemplate",
+    "McpCallTemplateSerializer",
+]

utcp_mcp-1.0.0/src/utcp_mcp/mcp_call_template.py

@@ -0,0 +1,54 @@
+
+from pydantic import BaseModel
+from typing import Optional, Dict, Literal, Any
+from utcp.data.auth_implementations import OAuth2Auth
+from utcp.data.call_template import CallTemplate
+from utcp.interfaces.serializer import Serializer
+from utcp.exceptions import UtcpSerializerValidationError
+import traceback
+
+"""Type alias for MCP server configurations.
+
+Union type for all supported MCP server transport configurations,
+including both stdio and HTTP-based servers.
+"""
+
+class McpConfig(BaseModel):
+    """Configuration container for multiple MCP servers.
+
+    Holds a collection of named MCP server configurations, allowing
+    a single MCP provider to manage multiple server connections.
+
+    Attributes:
+        mcpServers: Dictionary mapping server names to their configurations.
+    """
+    
+    mcpServers: Dict[str, Dict[str, Any]]
+
+class McpCallTemplate(CallTemplate):
+    """Provider configuration for Model Context Protocol (MCP) tools.
+
+    Enables communication with MCP servers that provide structured tool
+    interfaces. Supports both stdio (local process) and HTTP (remote)
+    transport methods.
+
+    Attributes:
+        call_template_type: Always "mcp" for MCP providers.
+        config: Configuration object containing MCP server definitions.
+            This follows the same format as the official MCP server configuration.
+        auth: Optional OAuth2 authentication for HTTP-based MCP servers.
+    """
+
+    call_template_type: Literal["mcp"] = "mcp"
+    config: McpConfig
+    auth: Optional[OAuth2Auth] = None
+
+class McpCallTemplateSerializer(Serializer[McpCallTemplate]):
+    def to_dict(self, obj: McpCallTemplate) -> dict:
+        return obj.model_dump()
+    
+    def validate_dict(self, obj: dict) -> McpCallTemplate:
+        try:
+            return McpCallTemplate.model_validate(obj)
+        except Exception as e:
+            raise UtcpSerializerValidationError("Invalid McpCallTemplate: " + traceback.format_exc()) from e

utcp_mcp-1.0.0/src/utcp_mcp/mcp_communication_protocol.py

@@ -0,0 +1,274 @@
+from typing import Any, Dict, Optional, AsyncGenerator, TYPE_CHECKING
+import json
+
+from mcp import ClientSession, StdioServerParameters
+from mcp.client.stdio import stdio_client
+from mcp.client.streamable_http import streamablehttp_client
+from utcp.data.utcp_manual import UtcpManual
+from utcp.data.call_template import CallTemplate
+from utcp.data.tool import Tool
+from utcp.data.auth_implementations import OAuth2Auth
+from utcp.interfaces.communication_protocol import CommunicationProtocol
+from utcp.data.register_manual_response import RegisterManualResult
+import aiohttp
+from aiohttp import BasicAuth as AiohttpBasicAuth
+from utcp_mcp.mcp_call_template import McpCallTemplate
+if TYPE_CHECKING:
+    from utcp.utcp_client import UtcpClient
+import logging
+
+logger = logging.getLogger(__name__)
+
+class McpCommunicationProtocol(CommunicationProtocol):
+    """MCP transport implementation that connects to MCP servers via stdio or HTTP.
+    
+    This implementation uses a session-per-operation approach where each operation
+    (register, call_tool) opens a fresh session, performs the operation, and closes.
+    """
+    
+    def __init__(self):
+        self._oauth_tokens: Dict[str, Dict[str, Any]] = {}
+
+    async def _list_tools_with_session(self, server_config: Dict[str, Any], auth: Optional[OAuth2Auth] = None):
+        # Create client streams based on transport type
+        if "command" in server_config and "args" in server_config:
+            params = StdioServerParameters(**server_config)
+            async with stdio_client(params) as (read, write):
+                async with ClientSession(read, write) as session:
+                    await session.initialize()
+                    tools_response = await session.list_tools()
+                    return tools_response.tools
+        elif "url" in server_config:
+            # Get authentication token if OAuth2 is configured
+            auth_header = None
+            if auth and isinstance(auth, OAuth2Auth):
+                token = await self._handle_oauth2(auth)
+                auth_header = {"Authorization": f"Bearer {token}"}
+            
+            async with streamablehttp_client(server_config["url"], auth=auth_header) as (read, write, _):
+                async with ClientSession(read, write) as session:
+                    await session.initialize()
+                    tools_response = await session.list_tools()
+                    return tools_response.tools
+        else:
+            raise ValueError(f"Unsupported MCP transport: {json.dumps(server_config)}")
+    
+    async def _call_tool_with_session(self, server_config: Dict[str, Any], tool_name: str, inputs: Dict[str, Any], auth: Optional[OAuth2Auth] = None):
+        if "command" in server_config and "args" in server_config:
+            params = StdioServerParameters(**server_config)
+            async with stdio_client(params) as (read, write):
+                async with ClientSession(read, write) as session:
+                    await session.initialize()
+                    result = await session.call_tool(tool_name, arguments=inputs)
+                    return result
+        elif "url" in server_config:
+            # Get authentication token if OAuth2 is configured
+            auth_header = None
+            if auth and isinstance(auth, OAuth2Auth):
+                token = await self._handle_oauth2(auth)
+                auth_header = {"Authorization": f"Bearer {token}"}
+            
+            async with streamablehttp_client(
+                url=server_config["url"],
+                headers=server_config.get("headers", None),
+                timeout=server_config.get("timeout", 30),
+                sse_read_timeout=server_config.get("sse_read_timeout", 60 * 5),
+                terminate_on_close=server_config.get("terminate_on_close", True),
+                auth=auth_header
+            ) as (read, write, _):
+                async with ClientSession(read, write) as session:
+                    await session.initialize()
+                    result = await session.call_tool(tool_name, arguments=inputs)
+                    return result
+        else:
+            raise ValueError(f"Unsupported MCP transport: {json.dumps(server_config)}")
+
+    async def register_manual(self, caller: 'UtcpClient', manual_call_template: CallTemplate) -> RegisterManualResult:
+        if not isinstance(manual_call_template, McpCallTemplate):
+            raise ValueError("manual_call_template must be a McpCallTemplate")
+        all_tools = []
+        errors = []
+        if manual_call_template.config and manual_call_template.config.mcpServers:
+            for server_name, server_config in manual_call_template.config.mcpServers.items():
+                try:
+                    logger.info(f"Discovering tools for server '{server_name}' via {server_config}")
+                    mcp_tools = await self._list_tools_with_session(server_config, auth=manual_call_template.auth)
+                    logger.info(f"Discovered {len(mcp_tools)} tools for server '{server_name}'")
+                    for mcp_tool in mcp_tools:
+                        # Convert mcp.Tool to utcp.data.tool.Tool
+                        utcp_tool = Tool(
+                            name=mcp_tool.name,
+                            description=mcp_tool.description,
+                            input_schema=mcp_tool.inputSchema,
+                            output_schema=mcp_tool.outputSchema,
+                            tool_call_template=manual_call_template
+                        )
+                        all_tools.append(utcp_tool)
+                except Exception as e:
+                    logger.error(f"Failed to discover tools for server '{server_name}': {e}")
+                    errors.append(f"Failed to discover tools for server '{server_name}': {e}")
+        return RegisterManualResult(
+            manual_call_template=manual_call_template,
+            manual=UtcpManual(
+                tools=all_tools
+            ),
+            success=len(errors) == 0,
+            errors=errors
+        )
+
+    async def call_tool(self, caller: 'UtcpClient', tool_name: str, tool_args: Dict[str, Any], tool_call_template: CallTemplate) -> Any:
+        if not isinstance(tool_call_template, McpCallTemplate):
+            raise ValueError("tool_call_template must be a McpCallTemplate")
+        if not tool_call_template.config or not tool_call_template.config.mcpServers:
+            raise ValueError(f"No server configuration found for tool '{tool_name}'")
+        
+        # Try each server until we find one that has the tool
+        for server_name, server_config in tool_call_template.config.mcpServers.items():
+            try:
+                logger.info(f"Attempting to call tool '{tool_name}' on server '{server_name}'")
+                
+                # First check if this server has the tool
+                tools = await self._list_tools_with_session(server_config, auth=tool_call_template.auth)
+                tool_names = [tool.name for tool in tools]
+                
+                if tool_name not in tool_names:
+                    logger.info(f"Tool '{tool_name}' not found in server '{server_name}'")
+                    continue  # Try next server
+                
+                # Call the tool
+                result = await self._call_tool_with_session(server_config, tool_name, tool_args, auth=tool_call_template.auth)
+                
+                # Process the result
+                return self._process_tool_result(result, tool_name)
+            except Exception as e:
+                logger.error(f"Error calling tool '{tool_name}' on server '{server_name}': {e}")
+                continue  # Try next server
+        
+        raise ValueError(f"Tool '{tool_name}' not found in any configured server")
+
+    async def call_tool_streaming(self, caller: 'UtcpClient', tool_name: str, tool_args: Dict[str, Any], tool_call_template: CallTemplate) -> AsyncGenerator[Any, None]:
+        yield self.call_tool(caller, tool_name, tool_args, tool_call_template)
+
+    def _process_tool_result(self, result, tool_name: str) -> Any:
+        logger.info(f"Processing tool result for '{tool_name}', type: {type(result)}")
+        
+        # Check for structured output first
+        if hasattr(result, 'structured_output'):
+            logger.info(f"Found structured_output: {result.structured_output}")
+            return result.structured_output
+        
+        # Process content if available
+        if hasattr(result, 'content'):
+            content = result.content
+            logger.info(f"Content type: {type(content)}")
+            
+            # Handle list content
+            if isinstance(content, list):
+                logger.info(f"Content is a list with {len(content)} items")
+                
+                if not content:
+                    return []
+                
+                # For single item lists, extract the item
+                if len(content) == 1:
+                    item = content[0]
+                    if hasattr(item, 'text'):
+                        return self._parse_text_content(item.text)
+                    return item
+                
+                # For multiple items, process all
+                result_list = []
+                for item in content:
+                    if hasattr(item, 'text'):
+                        result_list.append(self._parse_text_content(item.text))
+                    else:
+                        result_list.append(item)
+                return result_list
+            
+            # Handle single TextContent
+            if hasattr(content, 'text'):
+                return self._parse_text_content(content.text)
+            
+            # Handle other content types
+            if hasattr(content, 'json'):
+                return content.json
+            
+            return content
+        
+        # Fallback to result attribute
+        if hasattr(result, 'result'):
+            return result.result
+        
+        return result
+
+    def _parse_text_content(self, text: str) -> Any:
+        """Parse text content, attempting JSON, numbers, or returning as string."""
+        if not text:
+            return text
+        
+        # Try JSON parsing
+        try:
+            if (text.strip().startswith('{') and text.strip().endswith('}')) or \
+               (text.strip().startswith('[') and text.strip().endswith(']')):
+                return json.loads(text)
+        except json.JSONDecodeError:
+            pass
+        
+        # Try number parsing
+        try:
+            if text.isdigit() or (text.startswith('-') and text[1:].isdigit()):
+                return int(text)
+            return float(text)
+        except ValueError:
+            pass
+        
+        # Return as string
+        return text
+
+    async def deregister_manual(self, caller: 'UtcpClient', manual_call_template: CallTemplate) -> None:
+        """Deregister an MCP manual. This is a no-op in session-per-operation mode."""
+        logger.info(f"Deregistering manual '{manual_call_template.name}' (no-op in session-per-operation mode)")
+        pass
+
+    async def _handle_oauth2(self, auth_details: OAuth2Auth) -> str:
+        """Handles OAuth2 client credentials flow, trying both body and auth header methods."""
+        client_id = auth_details.client_id
+        
+        # Return cached token if available
+        if client_id in self._oauth_tokens:
+            return self._oauth_tokens[client_id]["access_token"]
+
+        async with aiohttp.ClientSession() as session:
+            # Method 1: Send credentials in the request body
+            try:
+                logger.info(f"Attempting OAuth2 token fetch for '{client_id}' with credentials in body.")
+                body_data = {
+                    'grant_type': 'client_credentials',
+                    'client_id': client_id,
+                    'client_secret': auth_details.client_secret,
+                    'scope': auth_details.scope
+                }
+                async with session.post(auth_details.token_url, data=body_data) as response:
+                    response.raise_for_status()
+                    token_response = await response.json()
+                    self._oauth_tokens[client_id] = token_response
+                    return token_response["access_token"]
+            except aiohttp.ClientError as e:
+                logger.error(f"OAuth2 with credentials in body failed: {e}. Trying Basic Auth header.")
+                
+            # Method 2: Send credentials as Basic Auth header
+            try:
+                logger.info(f"Attempting OAuth2 token fetch for '{client_id}' with Basic Auth header.")
+                header_auth = AiohttpBasicAuth(client_id, auth_details.client_secret)
+                header_data = {
+                    'grant_type': 'client_credentials',
+                    'scope': auth_details.scope
+                }
+                async with session.post(auth_details.token_url, data=header_data, auth=header_auth) as response:
+                    response.raise_for_status()
+                    token_response = await response.json()
+                    self._oauth_tokens[client_id] = token_response
+                    return token_response["access_token"]
+            except aiohttp.ClientError as e:
+                logger.error(f"OAuth2 with Basic Auth header also failed: {e}")
+                raise e

utcp_mcp-1.0.0/src/utcp_mcp.egg-info/PKG-INFO

@@ -0,0 +1,25 @@
+Metadata-Version: 2.4
+Name: utcp-mcp
+Version: 1.0.0
+Summary: Universal Tool Calling Protocol (UTCP) client library for Python
+Author: UTCP Contributors
+License-Expression: MPL-2.0
+Project-URL: Homepage, https://utcp.io
+Project-URL: Source, https://github.com/universal-tool-calling-protocol/python-utcp
+Project-URL: Issues, https://github.com/universal-tool-calling-protocol/python-utcp/issues
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: pydantic>=2.0
+Requires-Dist: mcp>=1.12
+Requires-Dist: utcp>=1.0
+Provides-Extra: dev
+Requires-Dist: build; extra == "dev"
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: pytest-asyncio; extra == "dev"
+Requires-Dist: pytest-cov; extra == "dev"
+Requires-Dist: coverage; extra == "dev"
+Requires-Dist: twine; extra == "dev"

utcp_mcp-1.0.0/src/utcp_mcp.egg-info/SOURCES.txt

@@ -0,0 +1,12 @@
+pyproject.toml
+src/utcp_mcp/__init__.py
+src/utcp_mcp/mcp_call_template.py
+src/utcp_mcp/mcp_communication_protocol.py
+src/utcp_mcp.egg-info/PKG-INFO
+src/utcp_mcp.egg-info/SOURCES.txt
+src/utcp_mcp.egg-info/dependency_links.txt
+src/utcp_mcp.egg-info/entry_points.txt
+src/utcp_mcp.egg-info/requires.txt
+src/utcp_mcp.egg-info/top_level.txt
+tests/test_mcp_http_transport.py
+tests/test_mcp_transport.py

utcp_mcp-1.0.0/src/utcp_mcp.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

utcp_mcp-1.0.0/src/utcp_mcp.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[utcp.plugins]
+mcp = utcp_mcp:register

utcp_mcp-1.0.0/src/utcp_mcp.egg-info/requires.txt

@@ -0,0 +1,11 @@
+pydantic>=2.0
+mcp>=1.12
+utcp>=1.0
+
+[dev]
+build
+pytest
+pytest-asyncio
+pytest-cov
+coverage
+twine

utcp_mcp-1.0.0/src/utcp_mcp.egg-info/top_level.txt

@@ -0,0 +1 @@
+utcp_mcp

utcp_mcp-1.0.0/tests/test_mcp_http_transport.py

@@ -0,0 +1,195 @@
+"""
+Tests for the MCP transport interface with HTTP transport.
+"""
+import sys
+import pytest
+import pytest_asyncio
+import asyncio
+import subprocess
+import time
+import os
+import socket
+from typing import List, Optional, Tuple
+
+from utcp_mcp.mcp_call_template import McpCallTemplate, McpConfig
+from utcp_mcp.mcp_communication_protocol import McpCommunicationProtocol
+
+HTTP_SERVER_NAME = "mock_http_server"
+HTTP_SERVER_PORT = 8000
+
+
+@pytest_asyncio.fixture
+async def http_server_process() -> subprocess.Popen:
+    """Start the HTTP MCP server as a separate process."""
+    server_path = os.path.join(
+        os.path.dirname(__file__), "mock_http_mcp_server.py"
+    )
+    process = subprocess.Popen(
+        [sys.executable, server_path],
+        stdout=subprocess.PIPE,
+        stderr=subprocess.PIPE,
+    )
+    
+    # Wait for the server to be ready by checking if the port is accessible and server logs
+    server_ready = False
+    for _ in range(30):  # Wait up to 30 seconds
+        try:
+            with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+                s.settimeout(1)
+                result = s.connect_ex(("127.0.0.1", HTTP_SERVER_PORT))
+                if result == 0:
+                    # Also check if we can see the server startup message
+                    server_ready = True
+                    break
+        except Exception:
+            pass
+        await asyncio.sleep(1)
+    
+    if not server_ready:
+        # Server didn't start in time
+        process.terminate()
+        stdout, stderr = process.communicate()
+        raise RuntimeError(f"HTTP server failed to start. stdout: {stdout.decode()}, stderr: {stderr.decode()}")
+    
+    # Give the server a bit more time to fully initialize
+    await asyncio.sleep(2)
+    
+    yield process
+    
+    # Clean up the process
+    process.terminate()
+    try:
+        process.wait(timeout=5)
+    except subprocess.TimeoutExpired:
+        process.kill()
+        process.wait()
+
+
+@pytest_asyncio.fixture
+def http_mcp_provider() -> McpCallTemplate:
+    """Provides an McpCallTemplate configured to connect to the mock HTTP server."""
+    server_config = {
+        "url": f"http://127.0.0.1:{HTTP_SERVER_PORT}/mcp",
+        "transport": "http"
+    }
+    return McpCallTemplate(
+        name="mock_http_provider",
+        call_template_type="mcp",
+        config=McpConfig(mcpServers={HTTP_SERVER_NAME: server_config})
+    )
+
+
+@pytest_asyncio.fixture
+async def transport() -> McpCommunicationProtocol:
+    """Provides a clean McpCommunicationProtocol instance."""
+    t = McpCommunicationProtocol()
+    yield t
+
+
+@pytest.mark.asyncio
+async def test_http_register_manual_discovers_tools(
+    transport: McpCommunicationProtocol,
+    http_mcp_provider: McpCallTemplate,
+    http_server_process: subprocess.Popen
+):
+    """Test that registering an HTTP MCP manual discovers the correct tools."""
+    register_result = await transport.register_manual(None, http_mcp_provider)
+    assert register_result.success
+    assert len(register_result.manual.tools) == 4
+
+    # Find the echo tool
+    echo_tool = next((tool for tool in register_result.manual.tools if tool.name == "echo"), None)
+    assert echo_tool is not None
+    assert "echoes back its input" in echo_tool.description
+
+    # Check for other tools
+    tool_names = [tool.name for tool in register_result.manual.tools]
+    assert "greet" in tool_names
+    assert "list_items" in tool_names
+    assert "add_numbers" in tool_names
+
+
+@pytest.mark.asyncio
+async def test_http_structured_output(
+    transport: McpCommunicationProtocol,
+    http_mcp_provider: McpCallTemplate,
+    http_server_process: subprocess.Popen
+):
+    """Test that HTTP MCP tools with structured output work correctly."""
+    # Register the provider
+    await transport.register_manual(None, http_mcp_provider)
+    
+    # Call the echo tool and verify the result
+    result = await transport.call_tool(None, "echo", {"message": "http_test"}, http_mcp_provider)
+    assert result == {"reply": "you said: http_test"}
+
+
+@pytest.mark.asyncio
+async def test_http_unstructured_output(
+    transport: McpCommunicationProtocol,
+    http_mcp_provider: McpCallTemplate,
+    http_server_process: subprocess.Popen
+):
+    """Test that HTTP MCP tools with unstructured output types work correctly."""
+    # Register the provider
+    await transport.register_manual(None, http_mcp_provider)
+    
+    # Call the greet tool and verify the result
+    result = await transport.call_tool(None, "greet", {"name": "Alice"}, http_mcp_provider)
+    assert result == "Hello, Alice!"
+
+
+@pytest.mark.asyncio
+async def test_http_list_output(
+    transport: McpCommunicationProtocol,
+    http_mcp_provider: McpCallTemplate,
+    http_server_process: subprocess.Popen
+):
+    """Test that HTTP MCP tools returning lists work correctly."""
+    # Register the provider
+    await transport.register_manual(None, http_mcp_provider)
+    
+    # Call the list_items tool and verify the result
+    result = await transport.call_tool(None, "list_items", {"count": 3}, http_mcp_provider)
+    
+    assert isinstance(result, list)
+    assert len(result) == 3
+    assert result[0] == "item_0"
+    assert result[1] == "item_1"
+    assert result[2] == "item_2"
+
+
+@pytest.mark.asyncio
+async def test_http_numeric_output(
+    transport: McpCommunicationProtocol,
+    http_mcp_provider: McpCallTemplate,
+    http_server_process: subprocess.Popen
+):
+    """Test that HTTP MCP tools returning numeric values work correctly."""
+    # Register the provider
+    await transport.register_manual(None, http_mcp_provider)
+    
+    # Call the add_numbers tool and verify the result
+    result = await transport.call_tool(None, "add_numbers", {"a": 5, "b": 7}, http_mcp_provider)
+    
+    assert result == 12
+
+
+@pytest.mark.asyncio
+async def test_http_deregister_manual(
+    transport: McpCommunicationProtocol,
+    http_mcp_provider: McpCallTemplate,
+    http_server_process: subprocess.Popen
+):
+    """Test that deregistering an HTTP MCP manual works (no-op in session-per-operation mode)."""
+    # Register a manual
+    register_result = await transport.register_manual(None, http_mcp_provider)
+    assert register_result.success
+    assert len(register_result.manual.tools) == 4
+
+    # Deregister it (this is a no-op in session-per-operation mode)
+    await transport.deregister_manual(None, http_mcp_provider)
+
+    # Should still be able to call tools since we create fresh sessions
+    result = await transport.call_tool(None, "echo", {"message": "test"}, http_mcp_provider)
+    assert result == {"reply": "you said: test"}

utcp_mcp-1.0.0/tests/test_mcp_transport.py

@@ -0,0 +1,120 @@
+import sys
+import os
+import pytest
+import pytest_asyncio
+
+from utcp_mcp.mcp_communication_protocol import McpCommunicationProtocol
+from utcp_mcp.mcp_call_template import McpCallTemplate, McpConfig
+
+SERVER_NAME = "mock_stdio_server"
+
+
+@pytest_asyncio.fixture
+def mcp_manual() -> McpCallTemplate:
+    """Provides an McpCallTemplate configured to run the mock stdio server."""
+    server_path = os.path.join(os.path.dirname(__file__), "mock_mcp_server.py")
+    server_config = {
+        "command": sys.executable,
+        "args": [server_path],
+    }
+    return McpCallTemplate(
+        name="mock_mcp_manual",
+        call_template_type="mcp",
+        config=McpConfig(mcpServers={SERVER_NAME: server_config})
+    )
+
+
+@pytest_asyncio.fixture
+async def transport() -> McpCommunicationProtocol:
+    """Provides a clean McpCommunicationProtocol instance."""
+    t = McpCommunicationProtocol()
+    yield t
+
+
+@pytest.mark.asyncio
+async def test_register_manual_discovers_tools(transport: McpCommunicationProtocol, mcp_manual: McpCallTemplate):
+    """Verify that registering a manual discovers the correct tools."""
+    register_result = await transport.register_manual(None, mcp_manual)
+    assert register_result.success
+    assert len(register_result.manual.tools) == 4
+
+    # Find the echo tool
+    echo_tool = next((tool for tool in register_result.manual.tools if tool.name == "echo"), None)
+    assert echo_tool is not None
+    assert "echoes back its input" in echo_tool.description
+
+    # Check for other tools
+    tool_names = [tool.name for tool in register_result.manual.tools]
+    assert "greet" in tool_names
+    assert "list_items" in tool_names
+    assert "add_numbers" in tool_names
+
+
+@pytest.mark.asyncio
+async def test_call_tool_succeeds(transport: McpCommunicationProtocol, mcp_manual: McpCallTemplate):
+    """Verify a successful tool call after registration."""
+    await transport.register_manual(None, mcp_manual)
+
+    result = await transport.call_tool(None, "echo", {"message": "test"}, mcp_manual)
+
+    assert result == {"reply": "you said: test"}
+
+
+@pytest.mark.asyncio
+async def test_call_tool_works_without_register(transport: McpCommunicationProtocol, mcp_manual: McpCallTemplate):
+    """Verify that calling a tool works without prior registration in session-per-operation mode."""
+    result = await transport.call_tool(None, "echo", {"message": "test"}, mcp_manual)
+    assert result == {"reply": "you said: test"}
+
+
+@pytest.mark.asyncio
+async def test_structured_output_tool(transport: McpCommunicationProtocol, mcp_manual: McpCallTemplate):
+    """Test that tools with structured output (TypedDict) work correctly."""
+    await transport.register_manual(None, mcp_manual)
+
+    result = await transport.call_tool(None, "echo", {"message": "test"}, mcp_manual)
+    assert result == {"reply": "you said: test"}
+
+
+@pytest.mark.asyncio
+async def test_unstructured_string_output(transport: McpCommunicationProtocol, mcp_manual: McpCallTemplate):
+    """Test that tools returning plain strings work correctly."""
+    await transport.register_manual(None, mcp_manual)
+
+    result = await transport.call_tool(None, "greet", {"name": "Alice"}, mcp_manual)
+    assert result == "Hello, Alice!"
+
+
+@pytest.mark.asyncio
+async def test_list_output(transport: McpCommunicationProtocol, mcp_manual: McpCallTemplate):
+    """Test that tools returning lists work correctly."""
+    await transport.register_manual(None, mcp_manual)
+
+    result = await transport.call_tool(None, "list_items", {"count": 3}, mcp_manual)
+
+    assert isinstance(result, list)
+    assert len(result) == 3
+    assert result == ["item_0", "item_1", "item_2"]
+
+
+@pytest.mark.asyncio
+async def test_numeric_output(transport: McpCommunicationProtocol, mcp_manual: McpCallTemplate):
+    """Test that tools returning numeric values work correctly."""
+    await transport.register_manual(None, mcp_manual)
+
+    result = await transport.call_tool(None, "add_numbers", {"a": 5, "b": 7}, mcp_manual)
+
+    assert result == 12
+
+
+@pytest.mark.asyncio
+async def test_deregister_manual(transport: McpCommunicationProtocol, mcp_manual: McpCallTemplate):
+    """Verify that deregistering a manual works (no-op in session-per-operation mode)."""
+    register_result = await transport.register_manual(None, mcp_manual)
+    assert register_result.success
+    assert len(register_result.manual.tools) == 4
+
+    await transport.deregister_manual(None, mcp_manual)
+
+    result = await transport.call_tool(None, "echo", {"message": "test"}, mcp_manual)
+    assert result == {"reply": "you said: test"}