langroid 0.18.1__tar.gz → 0.18.3__tar.gz

{langroid-0.18.1 → langroid-0.18.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: langroid
-Version: 0.18.1
+Version: 0.18.3
 Summary: Harness LLMs with Multi-Agent Programming
 License: MIT
 Author: Prasad Chalasani
@@ -170,7 +170,7 @@ blog post from the LanceDB team
 pharmacovigilance, see [blog post](https://langroid.github.io/langroid/blog/2024/08/12/malade-multi-agent-architecture-for-pharmacovigilance/)
 
 
-We welcome contributions -- See the [contributions](./CONTRIBUTING.md) document
+We welcome contributions: See the [contributions](./CONTRIBUTING.md) document
 for ideas on what to contribute.
 
 Are you building LLM Applications, or want help with Langroid for your company, 

{langroid-0.18.1 → langroid-0.18.3}/README.md

@@ -61,7 +61,7 @@ blog post from the LanceDB team
 pharmacovigilance, see [blog post](https://langroid.github.io/langroid/blog/2024/08/12/malade-multi-agent-architecture-for-pharmacovigilance/)
 
 
-We welcome contributions -- See the [contributions](./CONTRIBUTING.md) document
+We welcome contributions: See the [contributions](./CONTRIBUTING.md) document
 for ideas on what to contribute.
 
 Are you building LLM Applications, or want help with Langroid for your company, 

{langroid-0.18.1 → langroid-0.18.3}/langroid/agent/base.py

@@ -91,6 +91,8 @@ class AgentConfig(BaseSettings):
     show_stats: bool = True  # show token usage/cost stats?
     add_to_registry: bool = True  # register agent in ObjectRegistry?
     respond_tools_only: bool = False  # respond only to tool messages (not plain text)?
+    # allow multiple tool messages in a single response?
+    allow_multiple_tools: bool = True
 
     @validator("name")
     def check_name_alphanum(cls, v: str) -> str:
@@ -1120,6 +1122,8 @@ class Agent(ABC):
             # as a response to the tool message even though the tool was not intended
             # for this agent.
             return None
+        if len(tools) > 1 and not self.config.allow_multiple_tools:
+            return self.to_ChatDocument("ERROR: Use ONE tool at a time!")
         if len(tools) == 0:
             fallback_result = self.handle_message_fallback(msg)
             if fallback_result is None:

{langroid-0.18.1 → langroid-0.18.3}/langroid/agent/xml_tool_message.py

@@ -3,12 +3,12 @@ from typing import Any, Dict, List, Optional
 from lxml import etree
 
 from langroid.agent.tool_message import ToolMessage
+from langroid.pydantic_v1 import BaseModel
 
 
 class XMLToolMessage(ToolMessage):
     """
     Abstract class for tools formatted using XML instead of JSON.
-    Mainly tested for non-nested tool structures.
 
     When a subclass defines a field with the attribute `verbatim=True`,
     instructions are sent to the LLM to ensure the field's content is:
@@ -50,8 +50,11 @@ class XMLToolMessage(ToolMessage):
         parser = etree.XMLParser(strip_cdata=False)
         root = etree.fromstring(formatted_string.encode("utf-8"), parser=parser)
 
-        def parse_element(element: etree._Element) -> Any | Dict[str, Any] | str:
+        def parse_element(element: etree._Element) -> Any:
             # Skip elements starting with underscore
+            if element.tag.startswith("_"):
+                return {}
+
             field_info = cls.__fields__.get(element.tag)
             is_verbatim = field_info and field_info.field_info.extra.get(
                 "verbatim", False
@@ -72,8 +75,18 @@ class XMLToolMessage(ToolMessage):
                 # For non-code leaf elements, strip whitespace
                 return element.text.strip() if element.text else ""
             else:
-                # For branch elements, recurse
-                return {child.tag: parse_element(child) for child in element}
+                # For branch elements, handle potential lists or nested structures
+                children = [parse_element(child) for child in element]
+                if all(child.tag == element[0].tag for child in element):
+                    # If all children have the same tag, treat as a list
+                    return children
+                else:
+                    # Otherwise, treat as a dictionary
+                    result = {child.tag: parse_element(child) for child in element}
+                    # Check if this corresponds to a nested Pydantic model
+                    if field_info and issubclass(field_info.type_, BaseModel):
+                        return field_info.type_(**result)
+                    return result
 
         result = parse_element(root)
         if not isinstance(result, dict):
@@ -100,6 +113,24 @@ class XMLToolMessage(ToolMessage):
         # Use Pydantic's parse_obj to create and validate the instance
         return cls.parse_obj(parsed_data)
 
+    @classmethod
+    def find_verbatim_fields(
+        cls, prefix: str = "", parent_cls: Optional["BaseModel"] = None
+    ) -> List[str]:
+        verbatim_fields = []
+        for field_name, field_info in (parent_cls or cls).__fields__.items():
+            full_name = f"{prefix}.{field_name}" if prefix else field_name
+            if (
+                field_info.field_info.extra.get("verbatim", False)
+                or field_name == "code"
+            ):
+                verbatim_fields.append(full_name)
+            if issubclass(field_info.type_, BaseModel):
+                verbatim_fields.extend(
+                    cls.find_verbatim_fields(full_name, field_info.type_)
+                )
+        return verbatim_fields
+
     @classmethod
     def format_instructions(cls, tool: bool = False) -> str:
         """
@@ -123,14 +154,69 @@ class XMLToolMessage(ToolMessage):
         """
 
         preamble = "Placeholders:\n"
+        xml_format = f"Formatting example:\n\n<{cls.Config.root_element}>\n"
+
+        def format_field(
+            field_name: str,
+            field_type: type,
+            indent: str = "",
+            path: str = "",
+        ) -> None:
+            nonlocal preamble, xml_format
+            current_path = f"{path}.{field_name}" if path else field_name
+
+            if 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
+                    )
+                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"
+                xml_format += f"{indent}<{field_name}>\n"
+                xml_format += f"{indent}  <item>[{item_type.__name__} value]</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])
+                preamble += (
+                    f"{field_name.upper()} = "
+                    f"[dictionary with {key_type.__name__} keys and "
+                    f"{value_type.__name__} 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"
+                )
+                xml_format += f"{indent}  ...\n"
+                xml_format += f"{indent}</{field_name}>\n"
+            else:
+                preamble += f"{field_name.upper()} = [value for {field_name}]\n"
+                if current_path in verbatim_fields:
+                    xml_format += (
+                        f"{indent}<{field_name}>"
+                        f"<![CDATA[{{{field_name.upper()}}}]]></{field_name}>\n"
+                    )
+                else:
+                    xml_format += (
+                        f"{indent}<{field_name}>"
+                        f"{{{field_name.upper()}}}</{field_name}>\n"
+                    )
+
+        verbatim_fields = cls.find_verbatim_fields()
+
         for field in fields:
-            preamble += f"{field.upper()} = [value for {field}]\n"
+            field_type = cls.__fields__[field].type_
+            format_field(field, field_type)
 
-        verbatim_fields = [
-            field
-            for field, field_info in cls.__fields__.items()
-            if field_info.field_info.extra.get("verbatim", False)
-        ]
+        xml_format += f"</{cls.Config.root_element}>"
 
         verbatim_alert = ""
         if len(verbatim_fields) > 0:
@@ -141,13 +227,6 @@ class XMLToolMessage(ToolMessage):
             must be written verbatim WITHOUT any modifications or escaping,
             such as spaces, tabs, indents, newlines, quotes, etc.
             """
-        xml_format = f"Formatting example:\n\n<{cls.Config.root_element}>\n"
-        for field in fields:
-            if field == "code":
-                xml_format += f"  <{field}><![CDATA[{{{field.upper()}}}]]></{field}>\n"
-            else:
-                xml_format += f"  <{field}>{{{field.upper()}}}</{field}>\n"
-        xml_format += f"</{cls.Config.root_element}>"
 
         examples_str = ""
         if cls.examples():
@@ -177,17 +256,35 @@ class XMLToolMessage(ToolMessage):
         Raises:
             ValueError: If the result from etree.tostring is not a string.
         """
+
+        def create_element(
+            parent: etree._Element, name: str, value: Any, path: str = ""
+        ) -> None:
+            elem = etree.SubElement(parent, name)
+            current_path = f"{path}.{name}" if path else name
+
+            if isinstance(value, list):
+                for item in value:
+                    create_element(elem, "item", item, current_path)
+            elif isinstance(value, dict):
+                for k, v in value.items():
+                    create_element(elem, k, v, current_path)
+            elif isinstance(value, BaseModel):
+                # Handle nested Pydantic models
+                for field_name, field_value in value.dict().items():
+                    create_element(elem, field_name, field_value, current_path)
+            else:
+                if current_path in self.__class__.find_verbatim_fields():
+                    elem.text = etree.CDATA(str(value))
+                else:
+                    elem.text = str(value)
+
         root = etree.Element(self.Config.root_element)
         exclude_fields = self.Config.schema_extra.get("exclude", set())
         for name, value in self.dict().items():
             if name not in exclude_fields:
-                elem = etree.SubElement(root, name)
-                field_info = self.__class__.__fields__[name]
-                is_verbatim = field_info.field_info.extra.get("verbatim", False)
-                if is_verbatim:
-                    elem.text = etree.CDATA(str(value))
-                else:
-                    elem.text = str(value)
+                create_element(root, name, value)
+
         result = etree.tostring(root, encoding="unicode", pretty_print=True)
         if not isinstance(result, str):
             raise ValueError("Unexpected non-string result from etree.tostring")

{langroid-0.18.1 → langroid-0.18.3}/langroid/utils/git_utils.py

@@ -127,8 +127,9 @@ def git_commit_file(repo: git.Repo, filepath: str, msg: str) -> None:
     """
     try:
         repo.index.add([filepath])
-        repo.index.commit(f"{msg}; Updated {filepath}")
-        logger.info(f"Successfully committed {filepath}")
+        commit_msg = msg or f"Updated {filepath}"
+        repo.index.commit(commit_msg)
+        logger.info(f"Successfully committed {filepath}: {commit_msg}")
     except git.GitCommandError as e:
         logger.error(f"An error occurred while committing: {e}")
 

{langroid-0.18.1 → langroid-0.18.3}/langroid/utils/system.py

@@ -10,7 +10,7 @@ import socket
 import traceback
 import uuid
 from pathlib import Path
-from typing import Any
+from typing import Any, Literal
 
 logger = logging.getLogger(__name__)
 
@@ -186,24 +186,48 @@ def generate_unique_id() -> str:
     return str(uuid.uuid4())
 
 
-def create_file(filepath: str | Path, content: str = "") -> None:
+def create_file(
+    filepath: str | Path,
+    content: str = "",
+    if_exists: Literal["overwrite", "skip", "error", "append"] = "overwrite",
+) -> None:
     """
-    Create a file with the given content in the specified directory.
+    Create, overwrite or append to a file, with the given content
+    at the specified filepath.
     If content is empty, it will simply touch to create an empty file.
 
     Args:
         filepath (str|Path): The relative path of the file to be created
         content (str): The content to be written to the file
+        if_exists (Literal["overwrite", "skip", "error", "append"]):
+            Action to take if file exists
     """
-    Path(filepath).parent.mkdir(parents=True, exist_ok=True)
-    if content == "":
-        Path(filepath).touch()
+    filepath = Path(filepath)
+    filepath.parent.mkdir(parents=True, exist_ok=True)
+
+    if filepath.exists():
+        if if_exists == "skip":
+            logger.warning(f"File already exists, skipping: {filepath}")
+            return
+        elif if_exists == "error":
+            raise FileExistsError(f"File already exists: {filepath}")
+        elif if_exists == "append":
+            mode = "a"
+        else:  # overwrite
+            mode = "w"
+    else:
+        mode = "w"
+
+    if content == "" and mode in ["a", "w"]:
+        filepath.touch()
+        logger.warning(f"Empty file created: {filepath}")
     else:
         # the newline = '\n` argument is used to ensure that
         # newlines in the content are written as actual line breaks
-        with open(filepath, "w", newline="\n") as f:
+        with open(filepath, mode, newline="\n") as f:
             f.write(content)
-    logger.warning(f"File created/updated: {filepath}")
+        action = "appended to" if mode == "a" else "created/updated in"
+        logger.warning(f"Content {action}: {filepath}")
 
 
 def read_file(path: str, line_numbers: bool = False) -> str:

{langroid-0.18.1 → langroid-0.18.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "langroid"
-version = "0.18.1"
+version = "0.18.3"
 description = "Harness LLMs with Multi-Agent Programming"
 authors = ["Prasad Chalasani <pchalasani@gmail.com>"]
 readme = "README.md"
@@ -163,6 +163,9 @@ pytest-asyncio = "^0.21.1"
 pytest-postgresql = "^5.0.0"
 pytest-mysql = "^2.4.2"
 coverage = "^7.2.5"
+pytest-xdist = "^3.6.1"
+pytest-timeout = "^2.3.1"
+pytest-cov = "^5.0.0"
 
 [tool.poetry.group.docs]
 optional = true