Building AI agents, atomically
refactoring from bool to enum type in mcp tool factory, updating tests, and docs, using http_stream for consistency, defaulting to http_stream for mcp
jon foxdc2437e1de6c
diff --git a/atomic-agents/atomic_agents/lib/factories/mcp_tool_factory.py b/atomic-agents/atomic_agents/lib/factories/mcp_tool_factory.pyindex 2d4194c..8e3a6ed 100644--- a/atomic-agents/atomic_agents/lib/factories/mcp_tool_factory.py+++ b/atomic-agents/atomic_agents/lib/factories/mcp_tool_factory.py@@ -14,7 +14,7 @@ from mcp.client.stdio import stdio_clientfrom atomic_agents.lib.base.base_io_schema import BaseIOSchemafrom atomic_agents.lib.base.base_tool import BaseToolfrom atomic_agents.lib.factories.schema_transformer import SchemaTransformer-from atomic_agents.lib.factories.tool_definition_service import ToolDefinitionService, MCPToolDefinition+from atomic_agents.lib.factories.tool_definition_service import ToolDefinitionService, MCPToolDefinition, MCPTransportTypelogger = logging.getLogger(__name__)@@ -31,8 +31,7 @@ class MCPToolFactory:def __init__(self,mcp_endpoint: Optional[str] = None,- use_stdio: bool = False,- use_http_stream: bool = False,+ transport_type: MCPTransportType = MCPTransportType.HTTP_STREAM,client_session: Optional[ClientSession] = None,event_loop: Optional[asyncio.AbstractEventLoop] = None,working_directory: Optional[str] = None,@@ -41,24 +40,20 @@ class MCPToolFactory:Initialize the factory.Args:- mcp_endpoint: URL of the MCP server (for SSE) or the full command to run the server (for STDIO)- use_stdio: If True, use STDIO transport instead of SSE- use_http_stream: If True, use HTTP streaming transport (preferred) instead of SSE (deprecated)+ mcp_endpoint: URL of the MCP server (for SSE/HTTP stream) or the full command to run the server (for STDIO)+ transport_type: Type of transport to use (SSE, HTTP_STREAM, or STDIO)client_session: Optional pre-initialized ClientSession for reuseevent_loop: Optional event loop for running asynchronous operationsworking_directory: Optional working directory to use when running STDIO commands"""self.mcp_endpoint = mcp_endpoint- self.use_stdio = use_stdio- self.use_http_stream = use_http_stream+ self.transport_type = transport_typeself.client_session = client_sessionself.event_loop = event_loopself.schema_transformer = SchemaTransformer()self.working_directory = working_directory# Validate configuration- if self.use_stdio and self.use_http_stream:- raise ValueError("Cannot use both STDIO and HTTP stream transports at once.")if client_session is not None and event_loop is None:raise ValueError("When `client_session` is provided an `event_loop` must also be supplied.")if not mcp_endpoint and client_session is None:@@ -94,8 +89,7 @@ class MCPToolFactory:# Create new connectionservice = ToolDefinitionService(self.mcp_endpoint,- self.use_stdio,- self.use_http_stream,+ self.transport_type,self.working_directory,)return asyncio.run(service.fetch_definitions())@@ -135,8 +129,7 @@ class MCPToolFactory:def run_tool_sync(self, params: InputSchema) -> OutputSchema: # type: ignorebound_tool_name = self.mcp_tool_namebound_mcp_endpoint = self.mcp_endpoint # May be None when using external session- bound_use_stdio = self.use_stdio- bound_use_http_stream = self.use_http_stream+ bound_transport_type = self.transport_typepersistent_session: Optional[ClientSession] = getattr(self, "_client_session", None)loop: Optional[asyncio.AbstractEventLoop] = getattr(self, "_event_loop", None)bound_working_directory = getattr(self, "working_directory", None)@@ -147,7 +140,7 @@ class MCPToolFactory:async def _connect_and_call():stack = AsyncExitStack()try:- if bound_use_stdio:+ if bound_transport_type == MCPTransportType.STDIO:# Split the command string into the command and its argumentscommand_parts = shlex.split(bound_mcp_endpoint)if not command_parts:@@ -160,17 +153,23 @@ class MCPToolFactory:)stdio_transport = await stack.enter_async_context(stdio_client(server_params))read_stream, write_stream = stdio_transport- elif bound_use_http_stream:+ elif bound_transport_type == MCPTransportType.HTTP_STREAM:# HTTP streaming transport (preferred)http_endpoint = f"{bound_mcp_endpoint}/mcp"logger.debug(f"Executing tool '{bound_tool_name}' via HTTP stream: endpoint={http_endpoint}")stream_transport = await stack.enter_async_context(sse_client(http_endpoint))read_stream, write_stream = stream_transport- else:+ elif bound_transport_type == MCPTransportType.SSE:+ # SSE transport (deprecated)sse_endpoint = f"{bound_mcp_endpoint}/sse"logger.debug(f"Executing tool '{bound_tool_name}' via SSE: endpoint={sse_endpoint}")sse_transport = await stack.enter_async_context(sse_client(sse_endpoint))read_stream, write_stream = sse_transport+ else:+ available_types = [t.value for t in MCPTransportType]+ raise ValueError(+ f"Unknown transport type: {bound_transport_type}. Available transport types: {available_types}"+ )session = await stack.enter_async_context(ClientSession(read_stream, write_stream))await session.initialize()@@ -217,8 +216,7 @@ class MCPToolFactory:"__doc__": tool_description,"mcp_tool_name": tool_name,"mcp_endpoint": self.mcp_endpoint,- "use_stdio": self.use_stdio,- "use_http_stream": self.use_http_stream,+ "transport_type": self.transport_type,"_client_session": self.client_session,"_event_loop": self.event_loop,"working_directory": self.working_directory,@@ -281,27 +279,25 @@ class MCPToolFactory:# Public API functionsdef fetch_mcp_tools(mcp_endpoint: Optional[str] = None,- use_stdio: bool = False,- use_http_stream: bool = False,+ transport_type: MCPTransportType = MCPTransportType.HTTP_STREAM,*,client_session: Optional[ClientSession] = None,event_loop: Optional[asyncio.AbstractEventLoop] = None,working_directory: Optional[str] = None,) -> List[Type[BaseTool]]:"""- Connects to an MCP server via SSE, Http Stream or STDIO, discovers tool definitions, and dynamically generates+ Connects to an MCP server via SSE, HTTP Stream or STDIO, discovers tool definitions, and dynamically generatessynchronous Atomic Agents compatible BaseTool subclasses for each tool.Each generated tool will establish its own connection when its `run` method is called.Args:mcp_endpoint: URL of the MCP server or command for STDIO.- use_stdio: If True, use STDIO transport.- use_http_stream: If True, use HTTP streaming transport.+ transport_type: Type of transport to use (SSE, HTTP_STREAM, or STDIO).client_session: Optional pre-initialized ClientSession for reuse.event_loop: Optional event loop for running asynchronous operations.working_directory: Optional working directory for STDIO."""- factory = MCPToolFactory(mcp_endpoint, use_stdio, use_http_stream, client_session, event_loop, working_directory)+ factory = MCPToolFactory(mcp_endpoint, transport_type, client_session, event_loop, working_directory)return factory.create_tools()@@ -322,8 +318,7 @@ def create_mcp_orchestrator_schema(tools: List[Type[BaseTool]]) -> Optional[Typedef fetch_mcp_tools_with_schema(mcp_endpoint: Optional[str] = None,- use_stdio: bool = False,- use_http_stream: bool = False,+ transport_type: MCPTransportType = MCPTransportType.HTTP_STREAM,*,client_session: Optional[ClientSession] = None,event_loop: Optional[asyncio.AbstractEventLoop] = None,@@ -334,8 +329,7 @@ def fetch_mcp_tools_with_schema(Args:mcp_endpoint: URL of the MCP server or command for STDIO.- use_stdio: If True, use STDIO transport.- use_http_stream: If True, use HTTP streaming transport.+ transport_type: Type of transport to use (SSE, HTTP_STREAM, or STDIO).client_session: Optional pre-initialized ClientSession for reuse.event_loop: Optional event loop for running asynchronous operations.working_directory: Optional working directory for STDIO.@@ -345,7 +339,7 @@ def fetch_mcp_tools_with_schema(- List of dynamically generated tool classes- Orchestrator output schema with Union of tool input schemas, or None if no tools found."""- factory = MCPToolFactory(mcp_endpoint, use_stdio, use_http_stream, client_session, event_loop, working_directory)+ factory = MCPToolFactory(mcp_endpoint, transport_type, client_session, event_loop, working_directory)tools = factory.create_tools()if not tools:return [], Nonediff --git a/atomic-agents/atomic_agents/lib/factories/tool_definition_service.py b/atomic-agents/atomic_agents/lib/factories/tool_definition_service.pyindex f722b8a..8784580 100644--- a/atomic-agents/atomic_agents/lib/factories/tool_definition_service.py+++ b/atomic-agents/atomic_agents/lib/factories/tool_definition_service.py@@ -4,6 +4,7 @@ import loggingimport shlexfrom contextlib import AsyncExitStackfrom typing import List, NamedTuple, Optional, Dict, Any+from enum import Enumfrom mcp import ClientSession, StdioServerParametersfrom mcp.client.sse import sse_client@@ -12,6 +13,14 @@ from mcp.client.stdio import stdio_clientlogger = logging.getLogger(__name__)+class MCPTransportType(Enum):+ """Enum for MCP transport types."""++ SSE = "sse"+ HTTP_STREAM = "http_stream"+ STDIO = "stdio"++class MCPToolDefinition(NamedTuple):"""Definition of an MCP tool."""@@ -26,8 +35,7 @@ class ToolDefinitionService:def __init__(self,endpoint: Optional[str] = None,- use_stdio: bool = False,- use_http_stream: bool = False,+ transport_type: MCPTransportType = MCPTransportType.HTTP_STREAM,working_directory: Optional[str] = None,):"""@@ -35,13 +43,11 @@ class ToolDefinitionService:Args:endpoint: URL of the MCP server (for SSE/HTTP stream) or command string (for STDIO)- use_stdio: Whether to use STDIO transport- use_http_stream: Whether to use HTTP stream transport (no '/sse')+ transport_type: Type of transport to use (SSE, HTTP_STREAM, or STDIO)working_directory: Optional working directory to use when running STDIO commands"""self.endpoint = endpoint- self.use_stdio = use_stdio- self.use_http_stream = use_http_stream+ self.transport_type = transport_typeself.working_directory = working_directoryasync def fetch_definitions(self) -> List[MCPToolDefinition]:@@ -62,7 +68,7 @@ class ToolDefinitionService:definitions = []stack = AsyncExitStack()try:- if self.use_stdio:+ if self.transport_type == MCPTransportType.STDIO:# STDIO transportcommand_parts = shlex.split(self.endpoint)if not command_parts:@@ -73,18 +79,21 @@ class ToolDefinitionService:server_params = StdioServerParameters(command=command, args=args, env=None, cwd=self.working_directory)stdio_transport = await stack.enter_async_context(stdio_client(server_params))read_stream, write_stream = stdio_transport- elif self.use_http_stream:+ elif self.transport_type == MCPTransportType.HTTP_STREAM:# HTTP Stream transporttransport_endpoint = f"{self.endpoint}/mcp"logger.info(f"Attempting HTTP Stream connection to {transport_endpoint}")transport = await stack.enter_async_context(sse_client(transport_endpoint))read_stream, write_stream = transport- else:- # Default to SSE transport (deprecated)+ elif self.transport_type == MCPTransportType.SSE:+ # SSE transport (deprecated)transport_endpoint = f"{self.endpoint}/sse"logger.info(f"Attempting SSE connection to {transport_endpoint}")transport = await stack.enter_async_context(sse_client(transport_endpoint))read_stream, write_stream = transport+ else:+ available_types = [t.value for t in MCPTransportType]+ raise ValueError(f"Unknown transport type: {self.transport_type}. Available types: {available_types}")session = await stack.enter_async_context(ClientSession(read_stream, write_stream))definitions = await self.fetch_definitions_from_session(session)diff --git a/atomic-agents/tests/lib/factories/test_mcp_tool_factory.py b/atomic-agents/tests/lib/factories/test_mcp_tool_factory.pyindex bf074d7..33d8991 100644--- a/atomic-agents/tests/lib/factories/test_mcp_tool_factory.py+++ b/atomic-agents/tests/lib/factories/test_mcp_tool_factory.py@@ -7,7 +7,7 @@ from atomic_agents.lib.factories.mcp_tool_factory import (fetch_mcp_tools_with_schema,MCPToolFactory,)-from atomic_agents.lib.factories.tool_definition_service import MCPToolDefinition, ToolDefinitionService+from atomic_agents.lib.factories.tool_definition_service import MCPToolDefinition, ToolDefinitionService, MCPTransportTypeclass DummySession:@@ -21,12 +21,12 @@ def test_fetch_mcp_tools_no_endpoint_raises():def test_fetch_mcp_tools_event_loop_without_client_session_raises():with pytest.raises(ValueError):- fetch_mcp_tools(None, False, client_session=DummySession(), event_loop=None)+ fetch_mcp_tools(None, MCPTransportType.HTTP_STREAM, client_session=DummySession(), event_loop=None)def test_fetch_mcp_tools_empty_definitions(monkeypatch):monkeypatch.setattr(MCPToolFactory, "_fetch_tool_definitions", lambda self: [])- tools = fetch_mcp_tools("http://example.com", use_stdio=False)+ tools = fetch_mcp_tools("http://example.com", MCPTransportType.HTTP_STREAM)assert tools == []@@ -34,12 +34,12 @@ def test_fetch_mcp_tools_with_definitions_http(monkeypatch):input_schema = {"type": "object", "properties": {}, "required": []}definitions = [MCPToolDefinition(name="ToolX", description="Dummy tool", input_schema=input_schema)]monkeypatch.setattr(MCPToolFactory, "_fetch_tool_definitions", lambda self: definitions)- tools = fetch_mcp_tools("http://example.com", use_stdio=False)+ tools = fetch_mcp_tools("http://example.com", MCPTransportType.HTTP_STREAM)assert len(tools) == 1tool_cls = tools[0]# verify class attributesassert tool_cls.mcp_endpoint == "http://example.com"- assert tool_cls.use_stdio is False+ assert tool_cls.transport_type == MCPTransportType.HTTP_STREAM# input_schema has only tool_name fieldModel = tool_cls.input_schemaassert "tool_name" in Model.model_fields@@ -76,7 +76,7 @@ def test_fetch_mcp_tools_with_schema_no_endpoint_raises():def test_fetch_mcp_tools_with_schema_empty(monkeypatch):monkeypatch.setattr(MCPToolFactory, "create_tools", lambda self: [])- tools, schema = fetch_mcp_tools_with_schema("endpoint", False)+ tools, schema = fetch_mcp_tools_with_schema("endpoint", MCPTransportType.HTTP_STREAM)assert tools == []assert schema is None@@ -86,7 +86,7 @@ def test_fetch_mcp_tools_with_schema_nonempty(monkeypatch):dummy_schema = object()monkeypatch.setattr(MCPToolFactory, "create_tools", lambda self: dummy_tools)monkeypatch.setattr(MCPToolFactory, "create_orchestrator_schema", lambda self, t: dummy_schema)- tools, schema = fetch_mcp_tools_with_schema("endpoint", True)+ tools, schema = fetch_mcp_tools_with_schema("endpoint", MCPTransportType.STDIO)assert tools == dummy_toolsassert schema is dummy_schema@@ -95,16 +95,16 @@ def test_fetch_mcp_tools_with_stdio_and_working_directory(monkeypatch):input_schema = {"type": "object", "properties": {}, "required": []}definitions = [MCPToolDefinition(name="ToolZ", description=None, input_schema=input_schema)]monkeypatch.setattr(MCPToolFactory, "_fetch_tool_definitions", lambda self: definitions)- tools = fetch_mcp_tools("run me", True, working_directory="/tmp")+ tools = fetch_mcp_tools("run me", MCPTransportType.STDIO, working_directory="/tmp")assert len(tools) == 1tool_cls = tools[0]- assert tool_cls.use_stdio is True+ assert tool_cls.transport_type == MCPTransportType.STDIOassert tool_cls.mcp_endpoint == "run me"assert tool_cls.working_directory == "/tmp"[email protected]("use_stdio", [False, True])-def test_run_tool(monkeypatch, use_stdio):[email protected]("transport_type", [MCPTransportType.HTTP_STREAM, MCPTransportType.STDIO])+def test_run_tool(monkeypatch, transport_type):# Setup dummy transports and sessionimport atomic_agents.lib.factories.mcp_tool_factory as mtf@@ -148,8 +148,10 @@ def test_run_tool(monkeypatch, use_stdio):definitions = [MCPToolDefinition(name="ToolA", description="desc", input_schema=input_schema)]monkeypatch.setattr(MCPToolFactory, "_fetch_tool_definitions", lambda self: definitions)# Run fetch and execute tool- endpoint = "cmd run" if use_stdio else "http://e"- tools = fetch_mcp_tools(endpoint, use_stdio, working_directory="wd" if use_stdio else None)+ endpoint = "cmd run" if transport_type == MCPTransportType.STDIO else "http://e"+ tools = fetch_mcp_tools(+ endpoint, transport_type, working_directory="wd" if transport_type == MCPTransportType.STDIO else None+ )tool_cls = tools[0]inst = tool_cls()result = inst.run(tool_cls.input_schema(tool_name="ToolA"))@@ -177,7 +179,7 @@ def test_run_tool_with_persistent_session(monkeypatch):# Create and pass an event looploop = asyncio.new_event_loop()try:- tools = fetch_mcp_tools(None, False, client_session=client, event_loop=loop)+ tools = fetch_mcp_tools(None, MCPTransportType.HTTP_STREAM, client_session=client, event_loop=loop)tool_cls = tools[0]inst = tool_cls()result = inst.run(tool_cls.input_schema(tool_name="ToolB"))@@ -196,9 +198,9 @@ def test_fetch_tool_definitions_via_service(monkeypatch):return defsmonkeypatch.setattr(MCPToolFactory, "_fetch_tool_definitions", fake_fetch)- factory_http = MCPToolFactory("http://e", False)+ factory_http = MCPToolFactory("http://e", MCPTransportType.HTTP_STREAM)assert factory_http._fetch_tool_definitions() == defs- factory_stdio = MCPToolFactory("http://e", True, working_directory="/tmp")+ factory_stdio = MCPToolFactory("http://e", MCPTransportType.STDIO, working_directory="/tmp")assert factory_stdio._fetch_tool_definitions() == defs@@ -209,7 +211,7 @@ def test_fetch_tool_definitions_propagates_error(monkeypatch):raise RuntimeError("nope")monkeypatch.setattr(MCPToolFactory, "_fetch_tool_definitions", fake_fetch)- factory = MCPToolFactory("http://e", False)+ factory = MCPToolFactory("http://e", MCPTransportType.HTTP_STREAM)with pytest.raises(RuntimeError):factory._fetch_tool_definitions()@@ -259,7 +261,7 @@ def test_run_tool_handles_special_result_types(monkeypatch):MCPToolDefinition(name="T", description=None, input_schema={"type": "object", "properties": {}, "required": []})]monkeypatch.setattr(MCPToolFactory, "_fetch_tool_definitions", lambda self: definitions)- tool_cls = fetch_mcp_tools("e", False)[0]+ tool_cls = fetch_mcp_tools("e", MCPTransportType.HTTP_STREAM)[0]result = tool_cls().run(tool_cls.input_schema(tool_name="T"))assert result.result == "hello"@@ -269,7 +271,7 @@ def test_run_tool_handles_special_result_types(monkeypatch):return 123monkeypatch.setattr(mtf, "ClientSession", PlainSession)- result2 = fetch_mcp_tools("e", False)[0]().run(tool_cls.input_schema(tool_name="T"))+ result2 = fetch_mcp_tools("e", MCPTransportType.HTTP_STREAM)[0]().run(tool_cls.input_schema(tool_name="T"))assert result2.result == 123@@ -302,14 +304,14 @@ def test_run_invalid_stdio_command_raises(monkeypatch):],)# Use a blank-space endpoint to bypass init validation but trigger empty command in STDIO- tool_cls = fetch_mcp_tools(" ", True, working_directory="/wd")[0]+ tool_cls = fetch_mcp_tools(" ", MCPTransportType.STDIO, working_directory="/wd")[0]with pytest.raises(RuntimeError) as exc:tool_cls().run(tool_cls.input_schema(tool_name="Bad"))assert "STDIO command string cannot be empty" in str(exc.value)def test_create_tool_classes_skips_invalid(monkeypatch):- factory = MCPToolFactory("endpoint", False)+ factory = MCPToolFactory("endpoint", MCPTransportType.HTTP_STREAM)defs = [MCPToolDefinition(name="Bad", description=None, input_schema={"type": "object", "properties": {}, "required": []}),MCPToolDefinition(name="Good", description=None, input_schema={"type": "object", "properties": {}, "required": []}),@@ -345,7 +347,7 @@ def test_force_mark_unreachable_lines_for_coverage():def test__fetch_tool_definitions_service_branch(monkeypatch):"""Covers lines 112-113: ToolDefinitionService branch in _fetch_tool_definitions."""- factory = MCPToolFactory("dummy_endpoint", False)+ factory = MCPToolFactory("dummy_endpoint", MCPTransportType.HTTP_STREAM)# Patch fetch_definitions to avoid real async workasync def dummy_fetch_definitions(self):@@ -396,7 +398,7 @@ def test_run_tool_with_persistent_session_no_event_loop(monkeypatch):# Create tool with persistent session and a valid event looploop = asyncio.new_event_loop()try:- tools = fetch_mcp_tools(None, False, client_session=client, event_loop=loop)+ tools = fetch_mcp_tools(None, MCPTransportType.HTTP_STREAM, client_session=client, event_loop=loop)tool_cls = tools[0]inst = tool_cls()# Remove the event loop to simulate the error pathdiff --git a/atomic-agents/tests/lib/factories/test_tool_definition_service.py b/atomic-agents/tests/lib/factories/test_tool_definition_service.pyindex 8cc81aa..8541201 100644--- a/atomic-agents/tests/lib/factories/test_tool_definition_service.py+++ b/atomic-agents/tests/lib/factories/test_tool_definition_service.py@@ -4,6 +4,7 @@ from unittest.mock import AsyncMock, MagicMock, patchfrom atomic_agents.lib.factories.tool_definition_service import (ToolDefinitionService,MCPToolDefinition,+ MCPTransportType,)@@ -91,7 +92,7 @@ class TestToolDefinitionService:@pytest.mark.asyncioasync def test_fetch_via_stdio(self):# Create service- service = ToolDefinitionService("command arg1 arg2", use_stdio=True)+ service = ToolDefinitionService("command arg1 arg2", MCPTransportType.STDIO)# Mock the fetch_definitions_from_session methodservice.fetch_definitions_from_session = AsyncMock(@@ -123,7 +124,7 @@ class TestToolDefinitionService:@pytest.mark.asyncioasync def test_stdio_empty_command(self):# Create service with empty command- service = ToolDefinitionService("", use_stdio=True)+ service = ToolDefinitionService("", MCPTransportType.STDIO)# Test that ValueError is raised for empty commandwith pytest.raises(ValueError, match="Endpoint is required"):@@ -173,7 +174,7 @@ class TestToolDefinitionService:@pytest.mark.asyncioasync def test_stdio_command_parts_empty(self):- svc = ToolDefinitionService(" ", use_stdio=True)+ svc = ToolDefinitionService(" ", MCPTransportType.STDIO)with pytest.raises(RuntimeError, match="Unexpected error during tool definition fetching: STDIO command string cannot be empty"):diff --git a/atomic-examples/mcp-agent/README.md b/atomic-examples/mcp-agent/README.mdindex bbd862f..8d2a427 100644--- a/atomic-examples/mcp-agent/README.md+++ b/atomic-examples/mcp-agent/README.md@@ -107,7 +107,7 @@ This example shows the flexibility of the MCP architecture with two distinct tra# Second terminal: Run the client with HTTP Stream transportcd example-client- poetry run python -m example_client.main --transport http+ poetry run python -m example_client.main --transport http_stream```## Example Queriesdiff --git a/atomic-examples/mcp-agent/example-client/example_client/main.py b/atomic-examples/mcp-agent/example-client/example_client/main.pyindex 1a88af2..42b41a5 100644--- a/atomic-examples/mcp-agent/example-client/example_client/main.py+++ b/atomic-examples/mcp-agent/example-client/example_client/main.py@@ -6,48 +6,43 @@ This file serves as a launcher that can run either the STDIO or SSE transport veimport argparseimport sys+from atomic_agents.lib.factories.tool_definition_service import MCPTransportTypedef main():"""Parse command line arguments and launch the appropriate implementation."""parser = argparse.ArgumentParser(description="MCP Agent example client")++ # Get available transport choices from the enum+ transport_choices = [transport.value for transport in MCPTransportType]+parser.add_argument("--transport",- choices=["stdio", "sse", "http"],- default="stdio",- help="Transport method to use for MCP communication (stdio, sse, or http)",+ choices=transport_choices,+ default=MCPTransportType.STDIO.value,+ help=f"Transport method to use for MCP communication. Available: {', '.join(transport_choices)}",)args = parser.parse_args()- if args.transport == "stdio":- # Import and run STDIO implementation- try:- from example_client.main_stdio import main as stdio_main-- stdio_main()- except ImportError as e:- print(f"Failed to import STDIO implementation: {e}")- sys.exit(1)- elif args.transport == "sse":- # Import and run SSE implementation- try:- from example_client.main_sse import main as sse_main+ # Map transport values to their corresponding main functions+ transport_mapping = {+ MCPTransportType.STDIO.value: ("example_client.main_stdio", "stdio_main"),+ MCPTransportType.SSE.value: ("example_client.main_sse", "sse_main"),+ MCPTransportType.HTTP_STREAM.value: ("example_client.main_http", "http_main"),+ }- sse_main()- except ImportError as e:- print(f"Failed to import SSE implementation: {e}")- sys.exit(1)- elif args.transport == "http":- # Import and run HTTP implementation+ if args.transport in transport_mapping:+ module_name, function_name = transport_mapping[args.transport]try:- from example_client.main_http import main as http_main-- http_main()+ module = __import__(module_name, fromlist=[function_name])+ main_func = getattr(module, function_name)+ main_func()except ImportError as e:- print(f"Failed to import HTTP implementation: {e}")+ print(f"Failed to import {args.transport} implementation: {e}")sys.exit(1)else:print(f"Unknown transport: {args.transport}")+ print(f"Available transports: {', '.join(transport_choices)}")sys.exit(1)diff --git a/atomic-examples/mcp-agent/example-client/example_client/main_http.py b/atomic-examples/mcp-agent/example-client/example_client/main_http.pyindex a58a61e..bab428e 100644--- a/atomic-examples/mcp-agent/example-client/example_client/main_http.py+++ b/atomic-examples/mcp-agent/example-client/example_client/main_http.py@@ -5,6 +5,7 @@ Communicates with the server_http.py `/mcp` endpoint using HTTP GET/POST/DELETEimport sysfrom atomic_agents.lib.factories.mcp_tool_factory import fetch_mcp_tools+from atomic_agents.lib.factories.tool_definition_service import MCPTransportTypefrom rich.console import Consolefrom rich.table import Tablefrom pydantic import Field@@ -38,7 +39,7 @@ def main():client = instructor.from_openai(openai.OpenAI(api_key=config.openai_api_key))console.print("[bold green]Initializing MCP Agent System (HTTP Stream mode)...[/bold green]")- tools = fetch_mcp_tools(mcp_endpoint=config.mcp_server_url, use_stdio=False, use_http_stream=True)+ tools = fetch_mcp_tools(mcp_endpoint=config.mcp_server_url, transport_type=MCPTransportType.HTTP_STREAM)if not tools:console.print(f"[bold red]No MCP tools found at {config.mcp_server_url}[/bold red]")sys.exit(1)diff --git a/atomic-examples/mcp-agent/example-client/example_client/main_sse.py b/atomic-examples/mcp-agent/example-client/example_client/main_sse.pyindex 8b343dc..47fd444 100644--- a/atomic-examples/mcp-agent/example-client/example_client/main_sse.py+++ b/atomic-examples/mcp-agent/example-client/example_client/main_sse.py@@ -1,5 +1,6 @@# pyright: reportInvalidTypeForm=falsefrom atomic_agents.lib.factories.mcp_tool_factory import fetch_mcp_tools+from atomic_agents.lib.factories.tool_definition_service import MCPTransportTypefrom rich.console import Consolefrom rich.table import Tablefrom rich.markdown import Markdown@@ -48,7 +49,7 @@ class FinalResponseSchema(BaseIOSchema):# Fetch tools and build ActionUnion staticallytools = fetch_mcp_tools(mcp_endpoint=config.mcp_server_url,- use_stdio=False,+ transport_type=MCPTransportType.SSE,)if not tools:raise RuntimeError("No MCP tools found. Please ensure the MCP server is running and accessible.")diff --git a/atomic-examples/mcp-agent/example-client/example_client/main_stdio.py b/atomic-examples/mcp-agent/example-client/example_client/main_stdio.pyindex d063549..9b18761 100644--- a/atomic-examples/mcp-agent/example-client/example_client/main_stdio.py+++ b/atomic-examples/mcp-agent/example-client/example_client/main_stdio.py@@ -1,5 +1,6 @@# pyright: reportInvalidTypeForm=falsefrom atomic_agents.lib.factories.mcp_tool_factory import fetch_mcp_tools+from atomic_agents.lib.factories.tool_definition_service import MCPTransportTypefrom rich.console import Consolefrom rich.table import Tableimport openai@@ -77,7 +78,7 @@ stdio_session = stdio_loop.run_until_complete(_bootstrap_stdio())# Fetch tools and build ActionUnion staticallytools = fetch_mcp_tools(mcp_endpoint=None,- use_stdio=True,+ transport_type=MCPTransportType.STDIO,client_session=stdio_session, # Pass persistent sessionevent_loop=stdio_loop, # Pass corresponding loop)