langroid 0.53.5__py3-none-any.whl → 0.53.6__py3-none-any.whl

langroid/agent/tools/mcp/__init__.py

@@ -1,10 +1,10 @@
 from .decorators import mcp_tool
 from .fastmcp_client import (
     FastMCPClient,
-    get_langroid_tool,
-    get_langroid_tool_async,
-    get_langroid_tools,
-    get_langroid_tools_async,
+    get_tool,
+    get_tool_async,
+    get_tools,
+    get_tools_async,
     get_mcp_tool_async,
     get_mcp_tools_async,
 )
@@ -13,10 +13,10 @@ from .fastmcp_client import (
 __all__ = [
     "mcp_tool",
     "FastMCPClient",
-    "get_langroid_tool",
-    "get_langroid_tool_async",
-    "get_langroid_tools",
-    "get_langroid_tools_async",
+    "get_tool",
+    "get_tool_async",
+    "get_tools",
+    "get_tools_async",
     "get_mcp_tool_async",
     "get_mcp_tools_async",
 ]

langroid/agent/tools/mcp/decorators.py

@@ -1,7 +1,7 @@
 from typing import Callable, Type
 
 from langroid.agent.tool_message import ToolMessage
-from langroid.agent.tools.mcp.fastmcp_client import get_langroid_tool
+from langroid.agent.tools.mcp.fastmcp_client import get_tool
 
 
 def mcp_tool(
@@ -18,7 +18,7 @@ def mcp_tool(
 
     def decorator(user_cls: Type[ToolMessage]) -> Type[ToolMessage]:
         # build the “real” ToolMessage subclass for this server/tool
-        RealTool: Type[ToolMessage] = get_langroid_tool(server, tool_name)
+        RealTool: Type[ToolMessage] = get_tool(server, tool_name)
 
         # copy user‐defined methods / attributes onto RealTool
         for name, attr in user_cls.__dict__.items():

langroid/agent/tools/mcp/fastmcp_client.py

@@ -1,18 +1,30 @@
 import asyncio
+import datetime
 import logging
-from typing import Any, Dict, List, Optional, Tuple, Type, cast
+from typing import Any, Dict, List, Optional, Tuple, Type, TypeAlias, cast
 
 from dotenv import load_dotenv
 from fastmcp.client import Client
+from fastmcp.client.roots import (
+    RootsHandler,
+    RootsList,
+)
+from fastmcp.client.sampling import SamplingHandler
 from fastmcp.client.transports import ClientTransport
 from fastmcp.server import FastMCP
+from mcp.client.session import (
+    LoggingFnT,
+    MessageHandlerFnT,
+)
 from mcp.types import CallToolResult, TextContent, Tool
 
 from langroid.agent.tool_message import ToolMessage
-from langroid.pydantic_v1 import BaseModel, Field, create_model
+from langroid.pydantic_v1 import AnyUrl, BaseModel, Field, create_model
 
 load_dotenv()  # load environment variables from .env
 
+FastMCPServerSpec: TypeAlias = str | FastMCP[Any] | ClientTransport | AnyUrl
+
 
 class FastMCPClient:
     """A client for interacting with a FastMCP server.
@@ -24,7 +36,15 @@ class FastMCPClient:
     _cm: Optional[Client] = None
     client: Optional[Client] = None
 
-    def __init__(self, server: str | FastMCP[Any] | ClientTransport) -> None:
+    def __init__(
+        self,
+        server: FastMCPServerSpec,
+        sampling_handler: SamplingHandler | None = None,  # type: ignore
+        roots: RootsList | RootsHandler | None = None,  # type: ignore
+        log_handler: LoggingFnT | None = None,
+        message_handler: MessageHandlerFnT | None = None,
+        read_timeout_seconds: datetime.timedelta | None = None,
+    ) -> None:
         """Initialize the FastMCPClient.
 
         Args:
@@ -33,11 +53,23 @@ class FastMCPClient:
         self.server = server
         self.client = None
         self._cm = None
+        self.sampling_handler = sampling_handler
+        self.roots = roots
+        self.log_handler = log_handler
+        self.message_handler = message_handler
+        self.read_timeout_seconds = read_timeout_seconds
 
     async def __aenter__(self) -> "FastMCPClient":
         """Enter the async context manager and connect inner client."""
         # create inner client context manager
-        self._cm = Client(self.server)
+        self._cm = Client(
+            self.server,
+            sampling_handler=self.sampling_handler,
+            roots=self.roots,
+            log_handler=self.log_handler,
+            message_handler=self.message_handler,
+            read_timeout_seconds=self.read_timeout_seconds,
+        )
         # actually enter it (opens the session)
         self.client = await self._cm.__aenter__()  # type: ignore
         return self
@@ -113,7 +145,7 @@ class FastMCPClient:
         # Default fallback
         return Any, Field(default=default, description=desc)
 
-    async def get_langroid_tool(self, tool_name: str) -> Type[ToolMessage]:
+    async def get_tool_async(self, tool_name: str) -> Type[ToolMessage]:
         """
         Create a Langroid ToolMessage subclass from the MCP Tool
         with the given `tool_name`.
@@ -163,7 +195,17 @@ class FastMCPClient:
                 **fields,
             ),
         )
-        tool_model._server = self.server  # type: ignore[attr-defined]
+        # Store ALL client configuration needed to recreate a client
+        client_config = {
+            "server": self.server,
+            "sampling_handler": self.sampling_handler,
+            "roots": self.roots,
+            "log_handler": self.log_handler,
+            "message_handler": self.message_handler,
+            "read_timeout_seconds": self.read_timeout_seconds,
+        }
+
+        tool_model._client_config = client_config  # type: ignore [attr-defined]
         tool_model._renamed_fields = renamed  # type: ignore[attr-defined]
 
         # 2) define an arg-free call_tool_async()
@@ -171,15 +213,23 @@ class FastMCPClient:
             from langroid.agent.tools.mcp.fastmcp_client import FastMCPClient
 
             # pack up the payload
-            payload = self.dict(exclude=self.Config.schema_extra["exclude"])
+            payload = self.dict(
+                exclude=self.Config.schema_extra["exclude"].union(
+                    ["request", "purpose"]
+                ),
+            )
 
             # restore any renamed fields
             for orig, new in self.__class__._renamed_fields.items():  # type: ignore
                 if new in payload:
                     payload[orig] = payload.pop(new)
 
+            client_cfg = getattr(self.__class__, "_client_config", None)  # type: ignore
+            if not client_cfg:
+                # Fallback or error - ideally _client_config should always exist
+                raise RuntimeError(f"Client config missing on {self.__class__}")
             # open a fresh client, call the tool, then close
-            async with FastMCPClient(self.__class__._server) as client:  # type: ignore
+            async with FastMCPClient(**client_cfg) as client:  # type: ignore
                 return await client.call_mcp_tool(self.request, payload)
 
         tool_model.call_tool_async = call_tool_async  # type: ignore
@@ -195,7 +245,7 @@ class FastMCPClient:
 
         return tool_model
 
-    async def get_langroid_tools(self) -> List[Type[ToolMessage]]:
+    async def get_tools_async(self) -> List[Type[ToolMessage]]:
         """
         Get all available tools as Langroid ToolMessage classes,
         handling nested schemas, with `handle_async` methods
@@ -203,10 +253,7 @@ class FastMCPClient:
         if not self.client:
             raise RuntimeError("Client not initialized. Use async with FastMCPClient.")
         resp = await self.client.list_tools()
-        tools: List[Type[ToolMessage]] = []
-        for t in resp:
-            tools.append(await self.get_langroid_tool(t.name))
-        return tools
+        return [await self.get_tool_async(t.name) for t in resp]
 
     async def get_mcp_tool_async(self, name: str) -> Optional[Tool]:
         """Find the "original" MCP Tool (i.e. of type mcp.types.Tool) on the server
@@ -270,46 +317,144 @@ class FastMCPClient:
         return self._convert_tool_result(tool_name, result)
 
 
-async def get_langroid_tool_async(
-    server: str | ClientTransport,
+# ==============================================================================
+# Convenience functions (wrappers around FastMCPClient methods)
+# These are useful for one-off calls without needing to manage the
+# FastMCPClient context explicitly.
+# ==============================================================================
+
+
+async def get_tool_async(
+    server: FastMCPServerSpec,
     tool_name: str,
+    **client_kwargs: Any,
 ) -> Type[ToolMessage]:
-    async with FastMCPClient(server) as client:
-        return await client.get_langroid_tool(tool_name)
+    """Get a single Langroid ToolMessage subclass for a specific MCP tool name (async).
+
+    This is a convenience wrapper that creates a temporary FastMCPClient.
 
+    Args:
+        server: Specification of the FastMCP server to connect to.
+        tool_name: The name of the tool to retrieve.
+        **client_kwargs: Additional keyword arguments to pass to the
+            FastMCPClient constructor (e.g., sampling_handler, roots).
 
-def get_langroid_tool(
-    server: str | ClientTransport,
+    Returns:
+        A dynamically created Langroid ToolMessage subclass representing the
+        requested tool.
+    """
+    async with FastMCPClient(server, **client_kwargs) as client:
+        return await client.get_tool_async(tool_name)
+
+
+def get_tool(
+    server: FastMCPServerSpec,
     tool_name: str,
+    **client_kwargs: Any,
 ) -> Type[ToolMessage]:
-    return asyncio.run(get_langroid_tool_async(server, tool_name))
+    """Get a single Langroid ToolMessage subclass
+    for a specific MCP tool name (synchronous).
+
+    This is a convenience wrapper that creates a temporary FastMCPClient and runs the
+    async `get_tool_async` function using `asyncio.run()`.
 
+    Args:
+        server: Specification of the FastMCP server to connect to.
+        tool_name: The name of the tool to retrieve.
+        **client_kwargs: Additional keyword arguments to pass to the
+            FastMCPClient constructor (e.g., sampling_handler, roots).
 
-async def get_langroid_tools_async(
-    server: str | ClientTransport,
+    Returns:
+        A dynamically created Langroid ToolMessage subclass representing the
+        requested tool.
+    """
+    return asyncio.run(get_tool_async(server, tool_name, **client_kwargs))
+
+
+async def get_tools_async(
+    server: FastMCPServerSpec,
+    **client_kwargs: Any,
 ) -> List[Type[ToolMessage]]:
-    async with FastMCPClient(server) as client:
-        return await client.get_langroid_tools()
+    """Get all available tools as Langroid ToolMessage subclasses (async).
+
+    This is a convenience wrapper that creates a temporary FastMCPClient.
 
+    Args:
+        server: Specification of the FastMCP server to connect to.
+        **client_kwargs: Additional keyword arguments to pass to the
+            FastMCPClient constructor (e.g., sampling_handler, roots).
 
-def get_langroid_tools(
-    server: str | ClientTransport,
+    Returns:
+        A list of dynamically created Langroid ToolMessage subclasses
+        representing all available tools on the server.
+    """
+    async with FastMCPClient(server, **client_kwargs) as client:
+        return await client.get_tools_async()
+
+
+def get_tools(
+    server: FastMCPServerSpec,
+    **client_kwargs: Any,
 ) -> List[Type[ToolMessage]]:
-    return asyncio.run(get_langroid_tools_async(server))
+    """Get all available tools as Langroid ToolMessage subclasses (synchronous).
+
+    This is a convenience wrapper that creates a temporary FastMCPClient and runs the
+    async `get_tools_async` function using `asyncio.run()`.
+
+    Args:
+        server: Specification of the FastMCP server to connect to.
+        **client_kwargs: Additional keyword arguments to pass to the
+            FastMCPClient constructor (e.g., sampling_handler, roots).
+
+    Returns:
+        A list of dynamically created Langroid ToolMessage subclasses
+        representing all available tools on the server.
+    """
+    return asyncio.run(get_tools_async(server, **client_kwargs))
 
 
 async def get_mcp_tool_async(
-    server: str | ClientTransport,
+    server: FastMCPServerSpec,
     name: str,
+    **client_kwargs: Any,
 ) -> Optional[Tool]:
-    async with FastMCPClient(server) as client:
+    """Get the raw MCP Tool object for a specific tool name (async).
+
+    This is a convenience wrapper that creates a temporary FastMCPClient to
+    retrieve the tool definition from the server.
+
+    Args:
+        server: Specification of the FastMCP server to connect to.
+        name: The name of the tool to look up.
+        **client_kwargs: Additional keyword arguments to pass to the
+            FastMCPClient constructor.
+
+    Returns:
+        The raw `mcp.types.Tool` object from the server, or `None` if the tool
+        is not found.
+    """
+    async with FastMCPClient(server, **client_kwargs) as client:
         return await client.get_mcp_tool_async(name)
 
 
 async def get_mcp_tools_async(
-    server: str | ClientTransport,
+    server: FastMCPServerSpec,
+    **client_kwargs: Any,
 ) -> List[Tool]:
-    async with FastMCPClient(server) as client:
+    """Get all available raw MCP Tool objects from the server (async).
+
+    This is a convenience wrapper that creates a temporary FastMCPClient to
+    retrieve the list of tool definitions from the server.
+
+    Args:
+        server: Specification of the FastMCP server to connect to.
+        **client_kwargs: Additional keyword arguments to pass to the
+            FastMCPClient constructor.
+
+    Returns:
+        A list of raw `mcp.types.Tool` objects available on the server.
+    """
+    async with FastMCPClient(server, **client_kwargs) as client:
         if not client.client:
             raise RuntimeError("Client not initialized. Use async with FastMCPClient.")
         return await client.client.list_tools()

{langroid-0.53.5.dist-info → langroid-0.53.6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: langroid
-Version: 0.53.5
+Version: 0.53.6
 Summary: Harness LLMs with Multi-Agent Programming
 Author-email: Prasad Chalasani <pchalasani@gmail.com>
 License: MIT

{langroid-0.53.5.dist-info → langroid-0.53.6.dist-info}/RECORD

@@ -54,9 +54,9 @@ langroid/agent/tools/retrieval_tool.py,sha256=zcAV20PP_6VzSd-UE-IJcabaBseFL_QNz5
 langroid/agent/tools/rewind_tool.py,sha256=XAXL3BpNhCmBGYq_qi_sZfHJuIw7NY2jp4wnojJ7WRs,5606
 langroid/agent/tools/segment_extract_tool.py,sha256=__srZ_VGYLVOdPrITUM8S0HpmX4q7r5FHWMDdHdEv8w,1440
 langroid/agent/tools/tavily_search_tool.py,sha256=soI-j0HdgVQLf09wRQScaEK4b5RpAX9C4cwOivRFWWI,1903
-langroid/agent/tools/mcp/__init__.py,sha256=cQb3gYxXk0YZ23QCqbVNMbMeCeWCJj6w3gqGnvyqv7w,459
-langroid/agent/tools/mcp/decorators.py,sha256=mWnlTjyI9PMNi750PWzC_2B6V5K_XdxH0Co9kE2yAj0,1145
-langroid/agent/tools/mcp/fastmcp_client.py,sha256=ffOV0lJOtE3DLfA6y3Fib28jyACySJPgbqjNJpSAEQA,11815
+langroid/agent/tools/mcp/__init__.py,sha256=DJNM0VeFnFS3pJKCyFGggT8JVjVu0rBzrGzasT1HaSM,387
+langroid/agent/tools/mcp/decorators.py,sha256=h7dterhsmvWJ8q4mp_OopmuG2DF71ty8cZwOyzdDZuk,1127
+langroid/agent/tools/mcp/fastmcp_client.py,sha256=g2mJe6cCpzF0XBmW6zAqCz5AvIEt0ZWwe8uAMM4jNS0,17445
 langroid/cachedb/__init__.py,sha256=G2KyNnk3Qkhv7OKyxTOnpsxfDycx3NY0O_wXkJlalNY,96
 langroid/cachedb/base.py,sha256=ztVjB1DtN6pLCujCWnR6xruHxwVj3XkYniRTYAKKqk0,1354
 langroid/cachedb/redis_cachedb.py,sha256=7kgnbf4b5CKsCrlL97mHWKvdvlLt8zgn7lc528jEpiE,5141
@@ -132,7 +132,7 @@ langroid/vector_store/pineconedb.py,sha256=otxXZNaBKb9f_H75HTaU3lMHiaR2NUp5MqwLZ
 langroid/vector_store/postgres.py,sha256=wHPtIi2qM4fhO4pMQr95pz1ZCe7dTb2hxl4VYspGZoA,16104
 langroid/vector_store/qdrantdb.py,sha256=O6dSBoDZ0jzfeVBd7LLvsXu083xs2fxXtPa9gGX3JX4,18443
 langroid/vector_store/weaviatedb.py,sha256=Yn8pg139gOy3zkaPfoTbMXEEBCiLiYa1MU5d_3UA1K4,11847
-langroid-0.53.5.dist-info/METADATA,sha256=ExVMihbLql8jTdQQ-6DuM8Ocjyqc0JV057Sp17U3y8Y,64945
-langroid-0.53.5.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-langroid-0.53.5.dist-info/licenses/LICENSE,sha256=EgVbvA6VSYgUlvC3RvPKehSg7MFaxWDsFuzLOsPPfJg,1065
-langroid-0.53.5.dist-info/RECORD,,
+langroid-0.53.6.dist-info/METADATA,sha256=kOJSlrle7MZXPeosRhCuqg25rdUJFF21wif68zBUkcQ,64945
+langroid-0.53.6.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+langroid-0.53.6.dist-info/licenses/LICENSE,sha256=EgVbvA6VSYgUlvC3RvPKehSg7MFaxWDsFuzLOsPPfJg,1065
+langroid-0.53.6.dist-info/RECORD,,