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

langroid/agent/chat_agent.py

@@ -502,6 +502,17 @@ class ChatAgent(Agent):
         idx = self.nth_message_idx_with_role(role, n_role_msgs)
         return self.message_history[idx]
 
+    def last_message_idx_with_role(self, role: Role) -> int:
+        """Index of last message in message_history, with specified role.
+        Return -1 if not found. Index = 0 is the first message in the history.
+        """
+        indices_with_role = [
+            i for i, m in enumerate(self.message_history) if m.role == role
+        ]
+        if len(indices_with_role) == 0:
+            return -1
+        return indices_with_role[-1]
+
     def nth_message_idx_with_role(self, role: Role, n: int) -> int:
         """Index of `n`th message in message_history, with specified role.
         (n is assumed to be 1-based, i.e. 1 is the first message with that role).
@@ -1229,9 +1240,18 @@ class ChatAgent(Agent):
         idx: int,
         tokens: int = 5,
         warning: str = "...[Contents truncated!]",
+        inplace: bool = True,
     ) -> LLMMessage:
-        """Truncate message at idx in msg history to `tokens` tokens"""
-        llm_msg = self.message_history[idx]
+        """
+        Truncate message at idx in msg history to `tokens` tokens.
+
+        If inplace is True, the message is truncated in place, else
+        it LEAVES the original message INTACT and returns a new message
+        """
+        if inplace:
+            llm_msg = self.message_history[idx]
+        else:
+            llm_msg = copy.deepcopy(self.message_history[idx])
         orig_content = llm_msg.content
         new_content = (
             self.parser.truncate_tokens(orig_content, tokens)
@@ -1463,6 +1483,10 @@ class ChatAgent(Agent):
         """
         Prepare messages to be sent to self.llm_response_messages,
             which is the main method that calls the LLM API to get a response.
+            If desired output tokens + message history exceeds the model context length,
+            then first the max output tokens is reduced to fit, and if that is not
+            possible, older messages may be truncated to accommodate at least
+            self.config.llm.min_output_tokens of output.
 
         Returns:
             Tuple[List[LLMMessage], int]: (messages, output_len)
@@ -1530,17 +1554,42 @@ class ChatAgent(Agent):
             truncate
             and output_len > self.llm.chat_context_length() - self.chat_num_tokens(hist)
         ):
+            CHAT_HISTORY_BUFFER = 300
             # chat + output > max context length,
             # so first try to shorten requested output len to fit;
-            # use an extra margin of 300 tokens in case our calcs are off
+            # use an extra margin of CHAT_HISTORY_BUFFER tokens
+            # in case our calcs are off (and to allow for some extra tokens)
             output_len = (
-                self.llm.chat_context_length() - self.chat_num_tokens(hist) - 300
+                self.llm.chat_context_length()
+                - self.chat_num_tokens(hist)
+                - CHAT_HISTORY_BUFFER
             )
-            if output_len < self.config.llm.min_output_tokens:
-                # unacceptably small output len, so drop early parts of conv history
-                # if output_len is still too long, then drop early parts of conv history
+            if output_len > self.config.llm.min_output_tokens:
+                logger.warning(
+                    f"""
+                    Chat Model context length is {self.llm.chat_context_length()},
+                    but the current message history is {self.chat_num_tokens(hist)} 
+                    tokens long, which does not allow 
+                    {self.config.llm.model_max_output_tokens} output tokens. 
+                    Therefore we reduced `max_output_tokens` to {output_len} tokens,
+                    so they can fit within the model's context length
+                    """
+                )
+            else:
+                # unacceptably small output len, so compress early parts of conv
+                # history if output_len is still too long.
                 # TODO we should really be doing summarization or other types of
                 #   prompt-size reduction
+                msg_idx_to_compress = 1  # don't touch system msg
+                # we will try compressing msg indices up to but not including
+                # last user msg
+                last_msg_idx_to_compress = (
+                    self.last_message_idx_with_role(
+                        role=Role.USER,
+                    )
+                    - 1
+                )
+                n_truncated = 0
                 while (
                     self.chat_num_tokens(hist)
                     > self.llm.chat_context_length() - self.config.llm.min_output_tokens
@@ -1548,14 +1597,14 @@ class ChatAgent(Agent):
                     # try dropping early parts of conv history
                     # TODO we should really be doing summarization or other types of
                     #   prompt-size reduction
-                    if len(hist) <= 2:
+                    if msg_idx_to_compress > last_msg_idx_to_compress:
                         # We want to preserve the first message (typically system msg)
                         # and last message (user msg).
                         raise ValueError(
                             """
                         The (message history + max_output_tokens) is longer than the 
                         max chat context length of this model, and we have tried 
-                        reducing the requested max output tokens, as well as dropping 
+                        reducing the requested max output tokens, as well as truncating
                         early parts of the message history, to accommodate the model 
                         context length, but we have run out of msgs to drop.
                          
@@ -1566,51 +1615,59 @@ class ChatAgent(Agent):
                         - decreasing `max_output_tokens`
                         """
                         )
-                    # drop the second message, i.e. first msg after the sys msg
-                    # (typically user msg).
-                    ChatDocument.delete_id(hist[1].chat_document_id)
-                    hist = hist[:1] + hist[2:]
+                    n_truncated += 1
+                    # compress the msg at idx `msg_idx_to_compress`
+                    hist[msg_idx_to_compress] = self.truncate_message(
+                        msg_idx_to_compress,
+                        tokens=30,
+                        warning="... [Contents truncated!]",
+                    )
 
-                if len(hist) < len(self.message_history):
+                    msg_idx_to_compress += 1
+
+                output_len = min(
+                    self.config.llm.model_max_output_tokens,
+                    self.llm.chat_context_length()
+                    - self.chat_num_tokens(hist)
+                    - CHAT_HISTORY_BUFFER,
+                )
+                if output_len < self.config.llm.min_output_tokens:
+                    raise ValueError(
+                        f"""
+                        Tried to shorten prompt history for chat mode 
+                        but even after truncating all messages except system msg and 
+                        last (user) msg, 
+                        the history token len {self.chat_num_tokens(hist)} is
+                        too long to accommodate the desired minimum output tokens
+                        {self.config.llm.min_output_tokens} within the 
+                        model's context length {self.llm.chat_context_length()}.
+                        Please try shortening the system msg or user prompts,
+                        or adjust `config.llm.min_output_tokens` to be smaller. 
+                        """
+                    )
+                else:
+                    # we MUST have truncated at least one msg
                     msg_tokens = self.chat_num_tokens()
                     logger.warning(
                         f"""
                     Chat Model context length is {self.llm.chat_context_length()} 
-                    tokens, but the current message history is {msg_tokens} tokens long.
-                    Dropped the {len(self.message_history) - len(hist)} messages
-                    from early in the conversation history so that history token 
-                    length is {self.chat_num_tokens(hist)}.
-                    This may still not be low enough to allow minimum output length of 
-                    {self.config.llm.min_output_tokens} tokens.
+                    tokens, but the current message history is {msg_tokens} tokens long,
+                    which does not allow {self.config.llm.model_max_output_tokens} 
+                    output tokens. 
+                    Therefore we truncated the first {n_truncated} messages
+                    in the conversation history so that history token 
+                    length is reduced to {self.chat_num_tokens(hist)}, and 
+                    we use `max_output_tokens = {output_len}`,
+                    so they can fit within the model's context length
+                    of {self.llm.chat_context_length()} tokens.
                     """
                     )
 
-        if output_len < 0:
-            raise ValueError(
-                f"""
-                Tried to shorten prompt history for chat mode 
-                but even after dropping all messages except system msg and last (
-                user) msg, the history token len {self.chat_num_tokens(hist)} is longer 
-                than the model's max context length {self.llm.chat_context_length()}.
-                Please try shortening the system msg or user prompts.
-                """
-            )
-        if output_len < self.config.llm.min_output_tokens:
-            logger.warning(
-                f"""
-                Tried to shorten prompt history for chat mode 
-                but the feasible output length {output_len} is still
-                less than the minimum output length {self.config.llm.min_output_tokens}.
-                Your chat history is too long for this model, 
-                and the response may be truncated.
-                """
-            )
         if isinstance(message, ChatDocument):
             # record the position of the corresponding LLMMessage in
             # the message_history
             message.metadata.msg_idx = len(hist) - 1
             message.metadata.agent_id = self.id
-
         return hist, output_len
 
     def _function_args(

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/language_models/base.py

@@ -620,33 +620,31 @@ class LanguageModel(ABC):
     def __call__(self, prompt: str, max_tokens: int) -> LLMResponse:
         return self.generate(prompt, max_tokens)
 
+    @staticmethod
+    def _fallback_model_names(model: str) -> List[str]:
+        parts = model.split("/")
+        fallbacks = []
+        for i in range(1, len(parts)):
+            fallbacks.append("/".join(parts[i:]))
+        return fallbacks
+
     def info(self) -> ModelInfo:
         """Info of relevant chat model"""
-        model = (
-            self.config.completion_model
-            if self.config.use_completion_for_chat
-            else self.config.chat_model
-        )
         orig_model = (
             self.config.completion_model
             if self.config.use_completion_for_chat
             else self.chat_model_orig
         )
-        return get_model_info(orig_model, model)
+        return get_model_info(orig_model, self._fallback_model_names(orig_model))
 
     def completion_info(self) -> ModelInfo:
         """Info of relevant completion model"""
-        model = (
-            self.config.chat_model
-            if self.config.use_chat_for_completion
-            else self.config.completion_model
-        )
         orig_model = (
             self.chat_model_orig
             if self.config.use_chat_for_completion
             else self.config.completion_model
         )
-        return get_model_info(orig_model, model)
+        return get_model_info(orig_model, self._fallback_model_names(orig_model))
 
     def supports_functions_or_tools(self) -> bool:
         """

langroid/language_models/mcp_client_lm.py

@@ -0,0 +1,128 @@
+"""
+An API for an Agent in an MCP Server to use for chat-completions
+"""
+
+from typing import Awaitable, Callable, Dict, List, Optional, Union
+
+from fastmcp.server import Context
+
+import langroid.language_models as lm
+from langroid.language_models import LLMResponse
+from langroid.language_models.base import (
+    LanguageModel,
+    LLMConfig,
+    OpenAIJsonSchemaSpec,
+    OpenAIToolSpec,
+    ToolChoiceTypes,
+)
+from langroid.utils.types import to_string
+
+
+def none_fn(x: str) -> None | str:
+    return None
+
+
+class MCPClientLMConfig(LLMConfig):
+    """
+    Mock Language Model Configuration.
+
+    Attributes:
+        response_dict (Dict[str, str]): A "response rule-book", in the form of a
+            dictionary; if last msg in dialog is x,then respond with response_dict[x]
+    """
+
+    response_dict: Dict[str, str] = {}
+    response_fn: Callable[[str], None | str] = none_fn
+    response_fn_async: Optional[Callable[[str], Awaitable[Optional[str]]]] = None
+    default_response: str = "Mock response"
+
+    type: str = "mock"
+
+
+class MockLM(LanguageModel):
+
+    def __init__(self, config: MockLMConfig = MockLMConfig()):
+        super().__init__(config)
+        self.config: MockLMConfig = config
+
+    def _response(self, msg: str) -> LLMResponse:
+        # response is based on this fallback order:
+        # - response_dict
+        # - response_fn
+        # - default_response
+        mapped_response = self.config.response_dict.get(
+            msg, self.config.response_fn(msg) or self.config.default_response
+        )
+        return lm.LLMResponse(
+            message=to_string(mapped_response),
+            cached=False,
+        )
+
+    async def _response_async(self, msg: str) -> LLMResponse:
+        # response is based on this fallback order:
+        # - response_dict
+        # - response_fn_async
+        # - response_fn
+        # - default_response
+        if self.config.response_fn_async is not None:
+            response = await self.config.response_fn_async(msg)
+        else:
+            response = self.config.response_fn(msg)
+
+        mapped_response = self.config.response_dict.get(
+            msg, response or self.config.default_response
+        )
+        return lm.LLMResponse(
+            message=to_string(mapped_response),
+            cached=False,
+        )
+
+    def chat(
+        self,
+        messages: Union[str, List[lm.LLMMessage]],
+        max_tokens: int = 200,
+        tools: Optional[List[OpenAIToolSpec]] = None,
+        tool_choice: ToolChoiceTypes | Dict[str, str | Dict[str, str]] = "auto",
+        functions: Optional[List[lm.LLMFunctionSpec]] = None,
+        function_call: str | Dict[str, str] = "auto",
+        response_format: Optional[OpenAIJsonSchemaSpec] = None,
+    ) -> lm.LLMResponse:
+        """
+        Mock chat function for testing
+        """
+        last_msg = messages[-1].content if isinstance(messages, list) else messages
+        return self._response(last_msg)
+
+    async def achat(
+        self,
+        messages: Union[str, List[lm.LLMMessage]],
+        max_tokens: int = 200,
+        tools: Optional[List[OpenAIToolSpec]] = None,
+        tool_choice: ToolChoiceTypes | Dict[str, str | Dict[str, str]] = "auto",
+        functions: Optional[List[lm.LLMFunctionSpec]] = None,
+        function_call: str | Dict[str, str] = "auto",
+        response_format: Optional[OpenAIJsonSchemaSpec] = None,
+    ) -> lm.LLMResponse:
+        """
+        Mock chat function for testing
+        """
+        last_msg = messages[-1].content if isinstance(messages, list) else messages
+        return await self._response_async(last_msg)
+
+    def generate(self, prompt: str, max_tokens: int = 200) -> lm.LLMResponse:
+        """
+        Mock generate function for testing
+        """
+        return self._response(prompt)
+
+    async def agenerate(self, prompt: str, max_tokens: int = 200) -> LLMResponse:
+        """
+        Mock generate function for testing
+        """
+        return await self._response_async(prompt)
+
+    def get_stream(self) -> bool:
+        return False
+
+    def set_stream(self, stream: bool) -> bool:
+        return False

langroid/language_models/model_info.py

@@ -406,10 +406,21 @@ MODEL_INFO: Dict[str, ModelInfo] = {
 
 def get_model_info(
     model: str | ModelName,
-    fallback_model: str | ModelName = "",
+    fallback_models: List[str] = [],
 ) -> ModelInfo:
     """Get model information by name or enum value"""
-    return _get_model_info(model) or _get_model_info(fallback_model) or ModelInfo()
+    # Sequence of models to try, starting with the primary model
+    models_to_try = [model] + fallback_models
+
+    # Find the first model in the sequence that has info defined using next()
+    # on a generator expression that filters out None results from _get_model_info
+    found_info = next(
+        (info for m in models_to_try if (info := _get_model_info(m)) is not None),
+        None,  # Default value if the iterator is exhausted (no valid info found)
+    )
+
+    # Return the found info, or a default ModelInfo if none was found
+    return found_info or ModelInfo()
 
 
 def _get_model_info(model: str | ModelName) -> ModelInfo | None:

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: langroid
-Version: 0.53.5
+Version: 0.53.7
 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.7.dist-info}/RECORD

@@ -5,7 +5,7 @@ langroid/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 langroid/agent/__init__.py,sha256=ll0Cubd2DZ-fsCMl7e10hf9ZjFGKzphfBco396IKITY,786
 langroid/agent/base.py,sha256=zHwhNU403H-ZvogH4QhKTzaZn5_jt0ZdPHzSEmycDoc,80035
 langroid/agent/batch.py,sha256=vi1r5i1-vN80WfqHDSwjEym_KfGsqPGUtwktmiK1nuk,20635
-langroid/agent/chat_agent.py,sha256=igo7wl3tOig7yae8NokEEqXS5AYuAeWJGq1YZhpzOho,85739
+langroid/agent/chat_agent.py,sha256=2HIYzYxkrGkRIS97ioKfIqjaW3RbX89M39LjzBobBEY,88381
 langroid/agent/chat_document.py,sha256=6O20Fp4QrquykaF2jFtwNHkvcoDte1LLwVZNk9mVH9c,18057
 langroid/agent/openai_assistant.py,sha256=JkAcs02bIrgPNVvUWVR06VCthc5-ulla2QMBzux_q6o,34340
 langroid/agent/task.py,sha256=HB6N-Jn80HFqCf0ZYOC1v3Bn3oO7NLjShHQJJFwW0q4,90557
@@ -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
@@ -71,10 +71,11 @@ langroid/embedding_models/protoc/embeddings_pb2.pyi,sha256=UkNy7BrNsmQm0vLb3NtGX
 langroid/embedding_models/protoc/embeddings_pb2_grpc.py,sha256=9dYQqkW3JPyBpSEjeGXTNpSqAkC-6FPtBHyteVob2Y8,2452
 langroid/language_models/__init__.py,sha256=3aD2qC1lz8v12HX4B-dilv27gNxYdGdeu1QvDlkqqHs,1095
 langroid/language_models/azure_openai.py,sha256=SW0Fp_y6HpERr9l6TtF6CYsKgKwjUf_hSL_2mhTV4wI,5034
-langroid/language_models/base.py,sha256=Axj8U9o9r7ovpCYqhNJ4SaVYLvufLRQXnr51IyIYJKY,28493
+langroid/language_models/base.py,sha256=253xcwXZ0yxSQ1W4SR50tAPZKCDc35yyU1o35EqB9b8,28484
 langroid/language_models/config.py,sha256=9Q8wk5a7RQr8LGMT_0WkpjY8S4ywK06SalVRjXlfCiI,378
+langroid/language_models/mcp_client_lm.py,sha256=wyDvlc26E_En5u_ZNZxajCHm8KBNi4jzG-dL76QCdt4,4098
 langroid/language_models/mock_lm.py,sha256=5BgHKDVRWFbUwDT_PFgTZXz9-k8wJSA2e3PZmyDgQ1k,4022
-langroid/language_models/model_info.py,sha256=7Fv5YByZjsRXKhkaa6okOM8jhDVpWZu6xlYAN3WTSCk,14453
+langroid/language_models/model_info.py,sha256=0e011vJZMi7XU9OkKT6doxlybrNJfMlP54klLDDNgFg,14939
 langroid/language_models/openai_gpt.py,sha256=F28jqTEerN32m14q3K0oc3vnvBT8J7Q9xqXGZNKUjKU,85938
 langroid/language_models/utils.py,sha256=n55Oe2_V_4VNGhytvPWLYC-0tFS07RTjN83KWl-p_MI,6032
 langroid/language_models/prompt_formatter/__init__.py,sha256=2-5cdE24XoFDhifOLl8yiscohil1ogbP1ECkYdBlBsk,372
@@ -132,7 +133,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.7.dist-info/METADATA,sha256=crGfq16xZSGBqOyccaPQDgpy_hKGc1cgm4JmE2imWJQ,64945
+langroid-0.53.7.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+langroid-0.53.7.dist-info/licenses/LICENSE,sha256=EgVbvA6VSYgUlvC3RvPKehSg7MFaxWDsFuzLOsPPfJg,1065
+langroid-0.53.7.dist-info/RECORD,,