langroid 0.19.0__tar.gz → 0.19.2__tar.gz

{langroid-0.19.0 → langroid-0.19.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: langroid
-Version: 0.19.0
+Version: 0.19.2
 Summary: Harness LLMs with Multi-Agent Programming
 License: MIT
 Author: Prasad Chalasani
@@ -153,7 +153,8 @@ This Multi-Agent paradigm is inspired by the
 (but you do not need to know anything about this!). 
 
 `Langroid` is a fresh take on LLM app-development, where considerable thought has gone 
-into simplifying the developer experience; it does not use `Langchain`.
+into simplifying the developer experience; 
+it does not use `Langchain`, or any other LLM framework.
 
 :fire: Read the (WIP) [overview of the langroid architecture](https://langroid.github.io/langroid/blog/2024/08/15/overview-of-langroids-multi-agent-architecture-prelim/)
 

{langroid-0.19.0 → langroid-0.19.2}/README.md

@@ -44,7 +44,8 @@ This Multi-Agent paradigm is inspired by the
 (but you do not need to know anything about this!). 
 
 `Langroid` is a fresh take on LLM app-development, where considerable thought has gone 
-into simplifying the developer experience; it does not use `Langchain`.
+into simplifying the developer experience; 
+it does not use `Langchain`, or any other LLM framework.
 
 :fire: Read the (WIP) [overview of the langroid architecture](https://langroid.github.io/langroid/blog/2024/08/15/overview-of-langroids-multi-agent-architecture-prelim/)
 

{langroid-0.19.0 → langroid-0.19.2}/langroid/agent/base.py

@@ -33,6 +33,7 @@ from rich.prompt import Prompt
 from langroid.agent.chat_document import ChatDocMetaData, ChatDocument
 from langroid.agent.tool_message import ToolMessage
 from langroid.agent.xml_tool_message import XMLToolMessage
+from langroid.exceptions import XMLException
 from langroid.language_models.base import (
     LanguageModel,
     LLMConfig,
@@ -1120,6 +1121,8 @@ class Agent(ABC):
         except ValidationError as ve:
             # correct tool name but bad fields
             return self.tool_validation_error(ve)
+        except XMLException as xe:  # from XMLToolMessage parsing
+            return str(xe)
         except ValueError:
             # invalid tool name
             # We return None since returning "invalid tool name" would
@@ -1242,7 +1245,14 @@ class Agent(ABC):
         if is_json:
             maybe_tool_dict = json.loads(tool_candidate_str)
         else:
-            maybe_tool_dict = XMLToolMessage.extract_field_values(tool_candidate_str)
+            try:
+                maybe_tool_dict = XMLToolMessage.extract_field_values(
+                    tool_candidate_str
+                )
+            except Exception as e:
+                from langroid.exceptions import XMLException
+
+                raise XMLException(f"Error extracting XML fields:\n {str(e)}")
         # check if the maybe_tool_dict contains a "properties" field
         # which further contains the actual tool-call
         # (some weak LLMs do this). E.g. gpt-4o sometimes generates this:

{langroid-0.19.0 → langroid-0.19.2}/langroid/agent/xml_tool_message.py

@@ -1,4 +1,5 @@
-from typing import Any, Dict, List, Optional
+from collections.abc import Mapping
+from typing import Any, Dict, List, Optional, get_args, get_origin
 
 from lxml import etree
 
@@ -106,12 +107,17 @@ class XMLToolMessage(ToolMessage):
             Optional["XMLToolMessage"]: An instance of the class if parsing succeeds,
                 None otherwise.
         """
-        parsed_data = cls.extract_field_values(formatted_string)
-        if parsed_data is None:
-            return None
+        try:
+            parsed_data = cls.extract_field_values(formatted_string)
+            if parsed_data is None:
+                return None
+
+            # Use Pydantic's parse_obj to create and validate the instance
+            return cls.parse_obj(parsed_data)
+        except Exception as e:
+            from langroid.exceptions import XMLException
 
-        # Use Pydantic's parse_obj to create and validate the instance
-        return cls.parse_obj(parsed_data)
+            raise XMLException(f"Error parsing XML: {str(e)}")
 
     @classmethod
     def find_verbatim_fields(
@@ -133,15 +139,6 @@ class XMLToolMessage(ToolMessage):
 
     @classmethod
     def format_instructions(cls, tool: bool = False) -> str:
-        """
-        Instructions to the LLM showing how to use the XML tool.
-
-        Args:
-            tool: Not used in this implementation, kept for compatibility.
-
-        Returns:
-            str: instructions on how to use the XML message
-        """
         fields = [
             f
             for f in cls.__fields__.keys()
@@ -165,35 +162,62 @@ class XMLToolMessage(ToolMessage):
             nonlocal preamble, xml_format
             current_path = f"{path}.{field_name}" if path else field_name
 
-            if issubclass(field_type, BaseModel):
+            origin = get_origin(field_type)
+            args = get_args(field_type)
+
+            if (
+                origin is None
+                and isinstance(field_type, type)
+                and issubclass(field_type, BaseModel)
+            ):
                 preamble += (
                     f"{field_name.upper()} = [nested structure for {field_name}]\n"
                 )
                 xml_format += f"{indent}<{field_name}>\n"
                 for sub_field, sub_field_info in field_type.__fields__.items():
                     format_field(
-                        sub_field, sub_field_info.type_, indent + "  ", current_path
+                        sub_field,
+                        sub_field_info.outer_type_,
+                        indent + "  ",
+                        current_path,
                     )
                 xml_format += f"{indent}</{field_name}>\n"
-            elif issubclass(field_type, List):
-                item_type = getattr(field_type, "__args__", [Any])[0]
-                preamble += f"{field_name.upper()} = [list of {item_type.__name__}]\n"
+            elif origin in (list, List) or (field_type is list):
+                item_type = args[0] if args else Any
+                if isinstance(item_type, type) and issubclass(item_type, BaseModel):
+                    preamble += (
+                        f"{field_name.upper()} = "
+                        f"[list of nested structures for {field_name}]\n"
+                    )
+                else:
+                    preamble += (
+                        f"{field_name.upper()} = "
+                        f"[list of {getattr(item_type, '__name__', str(item_type))} "
+                        f"for {field_name}]\n"
+                    )
                 xml_format += f"{indent}<{field_name}>\n"
-                xml_format += f"{indent}  <item>[{item_type.__name__} value]</item>\n"
+                xml_format += (
+                    f"{indent}  <item>"
+                    f"[{getattr(item_type, '__name__', str(item_type))} value]"
+                    f"</item>\n"
+                )
                 xml_format += f"{indent}  ...\n"
                 xml_format += f"{indent}</{field_name}>\n"
-            elif issubclass(field_type, Dict):
-                key_type, value_type = getattr(field_type, "__args__", [Any, Any])
+            elif origin in (dict, Dict) or (
+                isinstance(field_type, type) and issubclass(field_type, Mapping)
+            ):
+                key_type, value_type = args if len(args) == 2 else (Any, Any)
                 preamble += (
                     f"{field_name.upper()} = "
-                    f"[dictionary with {key_type.__name__} keys and "
-                    f"{value_type.__name__} values]\n"
+                    f"[dictionary with "
+                    f"{getattr(key_type, '__name__', str(key_type))} keys and "
+                    f"{getattr(value_type, '__name__', str(value_type))} values]\n"
                 )
                 xml_format += f"{indent}<{field_name}>\n"
                 xml_format += (
-                    f"{indent}  <{key_type.__name__}>"
-                    f"[{value_type.__name__} value]"
-                    f"</{key_type.__name__}>\n"
+                    f"{indent}  <{getattr(key_type, '__name__', str(key_type))}>"
+                    f"[{getattr(value_type, '__name__', str(value_type))} value]"
+                    f"</{getattr(key_type, '__name__', str(key_type))}>\n"
                 )
                 xml_format += f"{indent}  ...\n"
                 xml_format += f"{indent}</{field_name}>\n"
@@ -213,7 +237,10 @@ class XMLToolMessage(ToolMessage):
         verbatim_fields = cls.find_verbatim_fields()
 
         for field in fields:
-            field_type = cls.__fields__[field].type_
+            field_info = cls.__fields__[field]
+            field_type = (
+                field_info.outer_type_
+            )  # Use outer_type_ to get the actual type including List, etc.
             format_field(field, field_type)
 
         xml_format += f"</{cls.Config.root_element}>"
@@ -260,6 +287,9 @@ class XMLToolMessage(ToolMessage):
         def create_element(
             parent: etree._Element, name: str, value: Any, path: str = ""
         ) -> None:
+            if value is None:
+                return
+
             elem = etree.SubElement(parent, name)
             current_path = f"{path}.{name}" if path else name
 

{langroid-0.19.0 → langroid-0.19.2}/langroid/exceptions.py

@@ -1,6 +1,11 @@
 from typing import Optional
 
 
+class XMLException(Exception):
+    def __init__(self, message: str) -> None:
+        super().__init__(message)
+
+
 class InfiniteLoopException(Exception):
     def __init__(self, message: str = "Infinite loop detected", *args: object) -> None:
         super().__init__(message, *args)

{langroid-0.19.0 → langroid-0.19.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "langroid"
-version = "0.19.0"
+version = "0.19.2"
 description = "Harness LLMs with Multi-Agent Programming"
 authors = ["Prasad Chalasani <pchalasani@gmail.com>"]
 readme = "README.md"