langroid 0.53.4__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/agent/xml_tool_message.py

@@ -49,11 +49,11 @@ class XMLToolMessage(ToolMessage):
         Raises:
             etree.XMLSyntaxError: If the input string is not valid XML.
         """
-        # SECURITY: Initialize XMLParser with flags to prevent 
-        # XML External Entity (XXE), billion laughs, and external DTD attacks by 
+        # SECURITY: Initialize XMLParser with flags to prevent
+        # XML External Entity (XXE), billion laughs, and external DTD attacks by
         # disabling entity resolution, DTD loading, and network access;
         # `strip_cdata=False` is needed to preserve
-        # content within CDATA sections (e.g., for code).        
+        # content within CDATA sections (e.g., for code).
         parser = etree.XMLParser(
             strip_cdata=False,
             resolve_entities=False,

langroid/vector_store/base.py

@@ -159,12 +159,11 @@ class VectorStore(ABC):
         df = pd.DataFrame(dicts)
 
         try:
-            result = pd.eval(  # safer than eval but limited to single expression
-                calc,
-                engine="python",
-                parser="pandas",
-                local_dict={"df": df},
-            )
+            # SECURITY: Use Python's eval() with NO globals and only {"df": df}
+            # in locals. This allows pandas operations on `df` while preventing
+            # access to builtins or other potentially harmful global functions,
+            # mitigating risks associated with executing untrusted `calc` strings.
+            result = eval(calc, {}, {"df": df})  # type: ignore
         except Exception as e:
             # return error message so LLM can fix the calc string if needed
             err = f"""

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

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

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

@@ -10,7 +10,7 @@ langroid/agent/chat_document.py,sha256=6O20Fp4QrquykaF2jFtwNHkvcoDte1LLwVZNk9mVH
 langroid/agent/openai_assistant.py,sha256=JkAcs02bIrgPNVvUWVR06VCthc5-ulla2QMBzux_q6o,34340
 langroid/agent/task.py,sha256=HB6N-Jn80HFqCf0ZYOC1v3Bn3oO7NLjShHQJJFwW0q4,90557
 langroid/agent/tool_message.py,sha256=BhjP-_TfQ2tgxuY4Yo_JHLOwwt0mJ4BwjPnREvEY4vk,14744
-langroid/agent/xml_tool_message.py,sha256=Yf-OsqO6z17qgQbfcTX4dxmPMtwYZVfgcWjcWI8nJzE,15506
+langroid/agent/xml_tool_message.py,sha256=oeBKnJNoGaKdtz39XoWGMTNlVyXew2MWH5lgtYeh8wQ,15496
 langroid/agent/callbacks/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 langroid/agent/callbacks/chainlit.py,sha256=UHB6P_J40vsVnssosqkpkOVWRf9NK4TOY0_G2g_Arsg,20900
 langroid/agent/special/__init__.py,sha256=gik_Xtm_zV7U9s30Mn8UX3Gyuy4jTjQe9zjiE3HWmEo,1273
@@ -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
@@ -124,7 +124,7 @@ langroid/utils/output/citations.py,sha256=9W0slQQgzRGLS7hU51mm5UWao5cS_xr8AVosVe
 langroid/utils/output/printing.py,sha256=yzPJZN-8_jyOJmI9N_oLwEDfjMwVgk3IDiwnZ4eK_AE,2962
 langroid/utils/output/status.py,sha256=rzbE7mDJcgNNvdtylCseQcPGCGghtJvVq3lB-OPJ49E,1049
 langroid/vector_store/__init__.py,sha256=8ktJUVsVUoc7FMmkUFpFBZu7VMWUqQY9zpm4kEJ8yTs,1537
-langroid/vector_store/base.py,sha256=sT6_8-LfLu_z82p4yMmyH_Kh8kt7o51Lt1n00PKBXWw,14588
+langroid/vector_store/base.py,sha256=HDgY2uMwOnoyuySDCXdRK_USPWaFRLhti94B2OP1B_w,14752
 langroid/vector_store/chromadb.py,sha256=p9mEqJwO2BrL2jSSXfa23kCPlPOwWpF3xJYd5zoWw_c,8661
 langroid/vector_store/lancedb.py,sha256=Qd20gKjWozPWfW5-D66J6U8dSrJo1yl-maj6s1lbf1c,14688
 langroid/vector_store/meilisearch.py,sha256=6frB7GFWeWmeKzRfLZIvzRjllniZ1cYj3HmhHQICXLs,11663
@@ -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.4.dist-info/METADATA,sha256=mJijMq7-4U64bl-XA2rQiGdgW6A3TxdMMx60sa-E1Fc,64945
-langroid-0.53.4.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-langroid-0.53.4.dist-info/licenses/LICENSE,sha256=EgVbvA6VSYgUlvC3RvPKehSg7MFaxWDsFuzLOsPPfJg,1065
-langroid-0.53.4.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,,