langroid 0.54.1__tar.gz → 0.55.0__tar.gz

{langroid-0.54.1 → langroid-0.55.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: langroid
-Version: 0.54.1
+Version: 0.55.0
 Summary: Harness LLMs with Multi-Agent Programming
 Author-email: Prasad Chalasani <pchalasani@gmail.com>
 License: MIT
@@ -209,7 +209,7 @@ Description-Content-Type: text/markdown
 [![PyPI - Version](https://img.shields.io/pypi/v/langroid)](https://pypi.org/project/langroid/)
 [![Downloads](https://img.shields.io/pypi/dm/langroid)](https://pypi.org/project/langroid/)
 [![Pytest](https://github.com/langroid/langroid/actions/workflows/pytest.yml/badge.svg)](https://github.com/langroid/langroid/actions/workflows/pytest.yml)
-[![codecov](https://codecov.io/gh/langroid/langroid/branch/main/graph/badge.svg?token=H94BX5F0TE)](https://codecov.io/gh/langroid/langroid)
+[![codecov](https://codecov.io/gh/langroid/langroid/graph/badge.svg)](https://codecov.io/gh/langroid/langroid)
 [![Multi-Architecture DockerHub](https://github.com/langroid/langroid/actions/workflows/docker-publish.yml/badge.svg)](https://github.com/langroid/langroid/actions/workflows/docker-publish.yml)
 
 [![Static Badge](https://img.shields.io/badge/Documentation-blue?link=https%3A%2F%2Flangroid.github.io%2Flangroid%2F&link=https%3A%2F%2Flangroid.github.io%2Flangroid%2F)](https://langroid.github.io/langroid)

{langroid-0.54.1 → langroid-0.55.0}/README.md

@@ -8,7 +8,7 @@
 [![PyPI - Version](https://img.shields.io/pypi/v/langroid)](https://pypi.org/project/langroid/)
 [![Downloads](https://img.shields.io/pypi/dm/langroid)](https://pypi.org/project/langroid/)
 [![Pytest](https://github.com/langroid/langroid/actions/workflows/pytest.yml/badge.svg)](https://github.com/langroid/langroid/actions/workflows/pytest.yml)
-[![codecov](https://codecov.io/gh/langroid/langroid/branch/main/graph/badge.svg?token=H94BX5F0TE)](https://codecov.io/gh/langroid/langroid)
+[![codecov](https://codecov.io/gh/langroid/langroid/graph/badge.svg)](https://codecov.io/gh/langroid/langroid)
 [![Multi-Architecture DockerHub](https://github.com/langroid/langroid/actions/workflows/docker-publish.yml/badge.svg)](https://github.com/langroid/langroid/actions/workflows/docker-publish.yml)
 
 [![Static Badge](https://img.shields.io/badge/Documentation-blue?link=https%3A%2F%2Flangroid.github.io%2Flangroid%2F&link=https%3A%2F%2Flangroid.github.io%2Flangroid%2F)](https://langroid.github.io/langroid)

{langroid-0.54.1 → langroid-0.55.0}/langroid/agent/base.py

@@ -251,6 +251,172 @@ class Agent(ABC):
     def clear_dialog(self) -> None:
         self.dialog = []
 
+    def _analyze_handler_params(
+        self, handler_method: Any
+    ) -> Tuple[bool, Optional[str], Optional[str]]:
+        """
+        Analyze parameters of a handler method to determine their types.
+
+        Returns:
+            Tuple of (has_annotations, agent_param_name, chat_doc_param_name)
+            - has_annotations: True if useful type annotations were found
+            - agent_param_name: Name of the agent parameter if found
+            - chat_doc_param_name: Name of the chat_doc parameter if found
+        """
+        sig = inspect.signature(handler_method)
+        params = list(sig.parameters.values())
+        # Remove 'self' parameter
+        params = [p for p in params if p.name != "self"]
+
+        agent_param = None
+        chat_doc_param = None
+        has_annotations = False
+
+        for param in params:
+            # First try type annotations
+            if param.annotation != inspect.Parameter.empty:
+                ann_str = str(param.annotation)
+                # Check for Agent-like types
+                if (
+                    param.annotation == self.__class__
+                    or "Agent" in ann_str
+                    or (
+                        hasattr(param.annotation, "__name__")
+                        and "Agent" in param.annotation.__name__
+                    )
+                ):
+                    agent_param = param.name
+                    has_annotations = True
+                # Check for ChatDocument-like types
+                elif "ChatDocument" in ann_str or "ChatDoc" in ann_str:
+                    chat_doc_param = param.name
+                    has_annotations = True
+
+            # Fallback to parameter names
+            elif param.name == "agent":
+                agent_param = param.name
+            elif param.name == "chat_doc":
+                chat_doc_param = param.name
+
+        return has_annotations, agent_param, chat_doc_param
+
+    @no_type_check
+    def _create_handler_wrapper(
+        self,
+        message_class: Type[ToolMessage],
+        handler_method: Any,
+        is_async: bool = False,
+    ) -> Any:
+        """
+        Create a wrapper function for a handler method based on its signature.
+
+        Args:
+            message_class: The ToolMessage class
+            handler_method: The handle/handle_async method
+            is_async: Whether this is for an async handler
+
+        Returns:
+            Appropriate wrapper function
+        """
+        sig = inspect.signature(handler_method)
+        params = list(sig.parameters.values())
+        params = [p for p in params if p.name != "self"]
+
+        has_annotations, agent_param, chat_doc_param = self._analyze_handler_params(
+            handler_method,
+        )
+
+        # Build wrapper based on found parameters
+        if len(params) == 0:
+            if is_async:
+
+                async def wrapper(obj: Any) -> Any:
+                    return await obj.handle_async()
+
+            else:
+
+                def wrapper(obj: Any) -> Any:
+                    return obj.handle()
+
+        elif agent_param and chat_doc_param:
+            # Both parameters present - build wrapper respecting their order
+            param_names = [p.name for p in params]
+            if param_names.index(agent_param) < param_names.index(chat_doc_param):
+                # agent is first parameter
+                if is_async:
+
+                    async def wrapper(obj: Any, chat_doc: Any) -> Any:
+                        return await obj.handle_async(self, chat_doc)
+
+                else:
+
+                    def wrapper(obj: Any, chat_doc: Any) -> Any:
+                        return obj.handle(self, chat_doc)
+
+            else:
+                # chat_doc is first parameter
+                if is_async:
+
+                    async def wrapper(obj: Any, chat_doc: Any) -> Any:
+                        return await obj.handle_async(chat_doc, self)
+
+                else:
+
+                    def wrapper(obj: Any, chat_doc: Any) -> Any:
+                        return obj.handle(chat_doc, self)
+
+        elif agent_param and not chat_doc_param:
+            # Only agent parameter
+            if is_async:
+
+                async def wrapper(obj: Any) -> Any:
+                    return await obj.handle_async(self)
+
+            else:
+
+                def wrapper(obj: Any) -> Any:
+                    return obj.handle(self)
+
+        elif chat_doc_param and not agent_param:
+            # Only chat_doc parameter
+            if is_async:
+
+                async def wrapper(obj: Any, chat_doc: Any) -> Any:
+                    return await obj.handle_async(chat_doc)
+
+            else:
+
+                def wrapper(obj: Any, chat_doc: Any) -> Any:
+                    return obj.handle(chat_doc)
+
+        else:
+            # No recognized parameters - backward compatibility
+            # Assume single parameter is chat_doc (legacy behavior)
+            if len(params) == 1:
+                if is_async:
+
+                    async def wrapper(obj: Any, chat_doc: Any) -> Any:
+                        return await obj.handle_async(chat_doc)
+
+                else:
+
+                    def wrapper(obj: Any, chat_doc: Any) -> Any:
+                        return obj.handle(chat_doc)
+
+            else:
+                # Multiple unrecognized parameters - best guess
+                if is_async:
+
+                    async def wrapper(obj: Any, chat_doc: Any) -> Any:
+                        return await obj.handle_async(chat_doc)
+
+                else:
+
+                    def wrapper(obj: Any, chat_doc: Any) -> Any:
+                        return obj.handle(chat_doc)
+
+        return wrapper
+
     def _get_tool_list(
         self, message_class: Optional[Type[ToolMessage]] = None
     ) -> List[str]:
@@ -304,13 +470,12 @@ class Agent(ABC):
             in one place, i.e. in the message class.
             See `tests/main/test_stateless_tool_messages.py` for an example.
             """
-            has_chat_doc_arg = (
-                len(inspect.signature(message_class.handle).parameters) > 1
+            wrapper = self._create_handler_wrapper(
+                message_class,
+                message_class.handle,
+                is_async=False,
             )
-            if has_chat_doc_arg:
-                setattr(self, handler, lambda obj, chat_doc: obj.handle(chat_doc))
-            else:
-                setattr(self, handler, lambda obj: obj.handle())
+            setattr(self, handler, wrapper)
         elif (
             hasattr(message_class, "response")
             and inspect.isfunction(message_class.response)
@@ -320,11 +485,17 @@ class Agent(ABC):
                 len(inspect.signature(message_class.response).parameters) > 2
             )
             if has_chat_doc_arg:
-                setattr(
-                    self, handler, lambda obj, chat_doc: obj.response(self, chat_doc)
-                )
+
+                def response_wrapper_with_chat_doc(obj: Any, chat_doc: Any) -> Any:
+                    return obj.response(self, chat_doc)
+
+                setattr(self, handler, response_wrapper_with_chat_doc)
             else:
-                setattr(self, handler, lambda obj: obj.response(self))
+
+                def response_wrapper_no_chat_doc(obj: Any) -> Any:
+                    return obj.response(self)
+
+                setattr(self, handler, response_wrapper_no_chat_doc)
 
         if hasattr(message_class, "handle_message_fallback") and (
             inspect.isfunction(message_class.handle_message_fallback)
@@ -334,10 +505,13 @@ class Agent(ABC):
             # `handle_message_fallback` method (which does nothing).
             # It's possible multiple tool messages have a `handle_message_fallback`,
             # in which case, the last one inserted will be used.
+            def fallback_wrapper(msg: Any) -> Any:
+                return message_class.handle_message_fallback(self, msg)
+
             setattr(
                 self,
                 "handle_message_fallback",
-                lambda msg: message_class.handle_message_fallback(self, msg),
+                fallback_wrapper,
             )
 
         async_handler_name = f"{handler}_async"
@@ -346,23 +520,12 @@ class Agent(ABC):
             and inspect.isfunction(message_class.handle_async)
             and not hasattr(self, async_handler_name)
         ):
-            has_chat_doc_arg = (
-                len(inspect.signature(message_class.handle_async).parameters) > 1
+            wrapper = self._create_handler_wrapper(
+                message_class,
+                message_class.handle_async,
+                is_async=True,
             )
-
-            if has_chat_doc_arg:
-
-                @no_type_check
-                async def handler(obj, chat_doc):
-                    return await obj.handle_async(chat_doc)
-
-            else:
-
-                @no_type_check
-                async def handler(obj):
-                    return await obj.handle_async()
-
-            setattr(self, async_handler_name, handler)
+            setattr(self, async_handler_name, wrapper)
         elif (
             hasattr(message_class, "response_async")
             and inspect.isfunction(message_class.response_async)

langroid-0.55.0/langroid/agent/done_sequence_parser.py

@@ -0,0 +1,151 @@
+"""Parser for done sequence DSL (Domain Specific Language).
+
+Converts string patterns into DoneSequence objects for convenient task completion
+configuration.
+
+Examples:
+    "T, A" -> Tool followed by Agent response
+    "T[calculator], A" -> Specific tool 'calculator' followed by Agent response
+    "L, T, A, L" -> LLM, Tool, Agent, LLM sequence
+    "C[quit|exit]" -> Content matching regex pattern
+"""
+
+import re
+from typing import List, Union
+
+from langroid.pydantic_v1 import BaseModel
+
+from .task import AgentEvent, DoneSequence, EventType
+
+
+def parse_done_sequence(sequence: Union[str, DoneSequence]) -> DoneSequence:
+    """Parse a string pattern or return existing DoneSequence unchanged.
+
+    Args:
+        sequence: Either a DoneSequence object or a string pattern to parse
+
+    Returns:
+        DoneSequence object
+
+    Raises:
+        ValueError: If the string pattern is invalid
+    """
+    if isinstance(sequence, DoneSequence):
+        return sequence
+
+    if not isinstance(sequence, str):
+        raise ValueError(f"Expected string or DoneSequence, got {type(sequence)}")
+
+    events = _parse_string_pattern(sequence)
+    return DoneSequence(events=events)
+
+
+def _parse_string_pattern(pattern: str) -> List[AgentEvent]:
+    """Parse a string pattern into a list of AgentEvent objects.
+
+    Pattern format:
+        - Single letter codes: T, A, L, U, N, C
+        - Specific tools: T[tool_name]
+        - Content match: C[regex_pattern]
+        - Separated by commas, spaces allowed
+
+    Args:
+        pattern: String pattern to parse
+
+    Returns:
+        List of AgentEvent objects
+
+    Raises:
+        ValueError: If pattern is invalid
+    """
+    events = []
+
+    # Split by comma and strip whitespace
+    parts = [p.strip() for p in pattern.split(",")]
+
+    for part in parts:
+        if not part:
+            continue
+
+        event = _parse_event_token(part)
+        events.append(event)
+
+    if not events:
+        raise ValueError(f"No valid events found in pattern: {pattern}")
+
+    return events
+
+
+def _parse_event_token(token: str) -> AgentEvent:
+    """Parse a single event token into an AgentEvent.
+
+    Args:
+        token: Single event token (e.g., "T", "T[calc]", "C[quit|exit]")
+
+    Returns:
+        AgentEvent object
+
+    Raises:
+        ValueError: If token is invalid
+    """
+    # Check for bracket notation
+    bracket_match = re.match(r"^([A-Z])\[([^\]]+)\]$", token)
+
+    if bracket_match:
+        event_code = bracket_match.group(1)
+        param = bracket_match.group(2)
+
+        if event_code == "T":
+            # Specific tool: T[tool_name]
+            return AgentEvent(event_type=EventType.SPECIFIC_TOOL, tool_name=param)
+        elif event_code == "C":
+            # Content match: C[regex_pattern]
+            return AgentEvent(event_type=EventType.CONTENT_MATCH, content_pattern=param)
+        else:
+            raise ValueError(
+                f"Invalid event code with brackets: {event_code}. "
+                "Only T[tool] and C[pattern] are supported."
+            )
+
+    # Simple single-letter codes
+    event_map = {
+        "T": EventType.TOOL,
+        "A": EventType.AGENT_RESPONSE,
+        "L": EventType.LLM_RESPONSE,
+        "U": EventType.USER_RESPONSE,
+        "N": EventType.NO_RESPONSE,
+        "C": EventType.CONTENT_MATCH,  # C without brackets matches any content
+    }
+
+    if token in event_map:
+        return AgentEvent(event_type=event_map[token])
+
+    # If not a single letter, could be a full event type name
+    token_upper = token.upper()
+    if token_upper == "TOOL":
+        return AgentEvent(event_type=EventType.TOOL)
+    elif token_upper == "AGENT":
+        return AgentEvent(event_type=EventType.AGENT_RESPONSE)
+    elif token_upper == "LLM":
+        return AgentEvent(event_type=EventType.LLM_RESPONSE)
+    elif token_upper == "USER":
+        return AgentEvent(event_type=EventType.USER_RESPONSE)
+    else:
+        raise ValueError(
+            f"Invalid event token: '{token}'. "
+            "Valid tokens are: T, A, L, U, N, C, or T[tool_name], C[pattern]"
+        )
+
+
+def parse_done_sequences(
+    sequences: List[Union[str, DoneSequence]]
+) -> List[DoneSequence]:
+    """Parse a list of mixed string patterns and DoneSequence objects.
+
+    Args:
+        sequences: List containing strings and/or DoneSequence objects
+
+    Returns:
+        List of DoneSequence objects
+    """
+    return [parse_done_sequence(seq) for seq in sequences]