langroid 0.18.2__tar.gz → 0.19.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: langroid
-Version: 0.18.2
+Version: 0.19.0
 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.2 → langroid-0.19.0}/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.2 → langroid-0.19.0}/langroid/agent/base.py

@@ -108,6 +108,10 @@ def noop_fn(*args: List[Any], **kwargs: Dict[str, Any]) -> None:
     pass
 
 
+async def async_noop_fn(*args: List[Any], **kwargs: Dict[str, Any]) -> None:
+    pass
+
+
 class Agent(ABC):
     """
     An Agent is an abstraction that encapsulates mainly two components:
@@ -154,6 +158,7 @@ class Agent(ABC):
 
         self.callbacks = SimpleNamespace(
             start_llm_stream=lambda: noop_fn,
+            start_llm_stream_async=async_noop_fn,
             cancel_llm_stream=noop_fn,
             finish_llm_stream=noop_fn,
             show_llm_response=noop_fn,

{langroid-0.18.2 → langroid-0.19.0}/langroid/agent/callbacks/chainlit.py

@@ -234,6 +234,7 @@ class ChainlitAgentCallbacks:
         so we can alter the display of the first user message.
         """
         agent.callbacks.start_llm_stream = self.start_llm_stream
+        agent.callbacks.start_llm_stream_async = self.start_llm_stream_async
         agent.callbacks.cancel_llm_stream = self.cancel_llm_stream
         agent.callbacks.finish_llm_stream = self.finish_llm_stream
         agent.callbacks.show_llm_response = self.show_llm_response
@@ -304,6 +305,32 @@ class ChainlitAgentCallbacks:
 
         return stream_token
 
+    async def start_llm_stream_async(self) -> Callable[[str], None]:
+        """Returns a streaming fn that can be passed to the LLM class"""
+        self.stream = cl.Step(
+            id=self.curr_step.id if self.curr_step is not None else None,
+            name=self._entity_name("llm"),
+            type="llm",
+            parent_id=self._get_parent_id(),
+        )
+        self.last_step = self.stream
+        self.curr_step = None
+        logger.info(
+            f"""
+            Starting LLM stream for {self.agent.config.name}
+            id = {self.stream.id} 
+            under parent {self._get_parent_id()}
+        """
+        )
+        await self.stream.send()  # type: ignore
+
+        async def stream_token(t: str) -> None:
+            if self.stream is None:
+                raise ValueError("Stream not initialized")
+            await self.stream.stream_token(t)
+
+        return stream_token
+
     def cancel_llm_stream(self) -> None:
         """Called when cached response found."""
         self.last_step = None

{langroid-0.18.2 → langroid-0.19.0}/langroid/agent/chat_agent.py

@@ -9,7 +9,7 @@ from rich import print
 from rich.console import Console
 from rich.markup import escape
 
-from langroid.agent.base import Agent, AgentConfig, noop_fn
+from langroid.agent.base import Agent, AgentConfig, async_noop_fn, noop_fn
 from langroid.agent.chat_document import ChatDocument
 from langroid.agent.tool_message import ToolMessage
 from langroid.agent.xml_tool_message import XMLToolMessage
@@ -969,10 +969,10 @@ class ChatAgent(Agent):
         functions, fun_call, tools, force_tool = self._function_args()
         assert self.llm is not None
 
-        streamer = noop_fn
+        streamer_async = async_noop_fn
         if self.llm.get_stream():
-            streamer = self.callbacks.start_llm_stream()
-        self.llm.config.streamer = streamer
+            streamer_async = await self.callbacks.start_llm_stream_async()
+        self.llm.config.streamer_async = streamer_async
 
         response = await self.llm.achat(
             messages,
@@ -989,7 +989,7 @@ class ChatAgent(Agent):
                     ChatDocument.from_LLMResponse(response, displayed=True),
                 ),
             )
-        self.llm.config.streamer = noop_fn
+        self.llm.config.streamer_async = async_noop_fn
         if response.cached:
             self.callbacks.cancel_llm_stream()
         self._render_llm_response(response)

{langroid-0.18.2 → langroid-0.19.0}/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.2 → langroid-0.19.0}/langroid/language_models/base.py

@@ -6,6 +6,7 @@ from datetime import datetime
 from enum import Enum
 from typing import (
     Any,
+    Awaitable,
     Callable,
     Dict,
     List,
@@ -33,6 +34,10 @@ def noop_fn(*args: List[Any], **kwargs: Dict[str, Any]) -> None:
     pass
 
 
+async def async_noop_fn(*args: List[Any], **kwargs: Dict[str, Any]) -> None:
+    pass
+
+
 FunctionCallTypes = Literal["none", "auto"]
 ToolChoiceTypes = Literal["none", "auto", "required"]
 ToolTypes = Literal["function"]
@@ -45,6 +50,7 @@ class LLMConfig(BaseSettings):
 
     type: str = "openai"
     streamer: Optional[Callable[[Any], None]] = noop_fn
+    streamer_async: Optional[Callable[..., Awaitable[None]]] = async_noop_fn
     api_base: str | None = None
     formatter: None | str = None
     timeout: int = 20  # timeout for API requests

{langroid-0.18.2 → langroid-0.19.0}/langroid/language_models/openai_gpt.py

@@ -688,7 +688,6 @@ class OpenAIGPT(LanguageModel):
         completion: str = "",
         function_args: str = "",
         function_name: str = "",
-        is_async: bool = False,
     ) -> Tuple[bool, bool, str, str]:
         """Process state vars while processing a streaming API response.
             Returns a tuple consisting of:
@@ -708,7 +707,98 @@ class OpenAIGPT(LanguageModel):
         event_args = ""
         event_fn_name = ""
         event_tool_deltas: Optional[List[Dict[str, Any]]] = None
-        silent = is_async and self.config.async_stream_quiet
+        # The first two events in the stream of Azure OpenAI is useless.
+        # In the 1st: choices list is empty, in the 2nd: the dict delta has null content
+        if chat:
+            delta = choices[0].get("delta", {})
+            event_text = delta.get("content", "")
+            if "function_call" in delta and delta["function_call"] is not None:
+                if "name" in delta["function_call"]:
+                    event_fn_name = delta["function_call"]["name"]
+                if "arguments" in delta["function_call"]:
+                    event_args = delta["function_call"]["arguments"]
+            if "tool_calls" in delta and delta["tool_calls"] is not None:
+                # it's a list of deltas, usually just one
+                event_tool_deltas = delta["tool_calls"]
+                tool_deltas += event_tool_deltas
+        else:
+            event_text = choices[0]["text"]
+        if event_text:
+            completion += event_text
+            sys.stdout.write(Colors().GREEN + event_text)
+            sys.stdout.flush()
+            self.config.streamer(event_text)
+        if event_fn_name:
+            function_name = event_fn_name
+            has_function = True
+            sys.stdout.write(Colors().GREEN + "FUNC: " + event_fn_name + ": ")
+            sys.stdout.flush()
+            self.config.streamer(event_fn_name)
+
+        if event_args:
+            function_args += event_args
+            sys.stdout.write(Colors().GREEN + event_args)
+            sys.stdout.flush()
+            self.config.streamer(event_args)
+
+        if event_tool_deltas is not None:
+            # print out streaming tool calls, if not async
+            for td in event_tool_deltas:
+                if td["function"]["name"] is not None:
+                    tool_fn_name = td["function"]["name"]
+                    sys.stdout.write(
+                        Colors().GREEN + "OAI-TOOL: " + tool_fn_name + ": "
+                    )
+                    sys.stdout.flush()
+                    self.config.streamer(tool_fn_name)
+                if td["function"]["arguments"] != "":
+                    tool_fn_args = td["function"]["arguments"]
+                    sys.stdout.write(Colors().GREEN + tool_fn_args)
+                    sys.stdout.flush()
+                    self.config.streamer(tool_fn_args)
+
+        # show this delta in the stream
+        if choices[0].get("finish_reason", "") in [
+            "stop",
+            "function_call",
+            "tool_calls",
+        ]:
+            # for function_call, finish_reason does not necessarily
+            # contain "function_call" as mentioned in the docs.
+            # So we check for "stop" or "function_call" here.
+            return True, has_function, function_name, function_args, completion
+        return False, has_function, function_name, function_args, completion
+
+    @no_type_check
+    async def _process_stream_event_async(
+        self,
+        event,
+        chat: bool = False,
+        tool_deltas: List[Dict[str, Any]] = [],
+        has_function: bool = False,
+        completion: str = "",
+        function_args: str = "",
+        function_name: str = "",
+    ) -> Tuple[bool, bool, str, str]:
+        """Process state vars while processing a streaming API response.
+            Returns a tuple consisting of:
+        - is_break: whether to break out of the loop
+        - has_function: whether the response contains a function_call
+        - function_name: name of the function
+        - function_args: args of the function
+        """
+        # convert event obj (of type ChatCompletionChunk) to dict so rest of code,
+        # which expects dicts, works as it did before switching to openai v1.x
+        if not isinstance(event, dict):
+            event = event.model_dump()
+
+        choices = event.get("choices", [{}])
+        if len(choices) == 0:
+            choices = [{}]
+        event_args = ""
+        event_fn_name = ""
+        event_tool_deltas: Optional[List[Dict[str, Any]]] = None
+        silent = self.config.async_stream_quiet
         # The first two events in the stream of Azure OpenAI is useless.
         # In the 1st: choices list is empty, in the 2nd: the dict delta has null content
         if chat:
@@ -730,21 +820,21 @@ class OpenAIGPT(LanguageModel):
             if not silent:
                 sys.stdout.write(Colors().GREEN + event_text)
                 sys.stdout.flush()
-                self.config.streamer(event_text)
+                await self.config.streamer_async(event_text)
         if event_fn_name:
             function_name = event_fn_name
             has_function = True
             if not silent:
                 sys.stdout.write(Colors().GREEN + "FUNC: " + event_fn_name + ": ")
                 sys.stdout.flush()
-                self.config.streamer(event_fn_name)
+                await self.config.streamer_async(event_fn_name)
 
         if event_args:
             function_args += event_args
             if not silent:
                 sys.stdout.write(Colors().GREEN + event_args)
                 sys.stdout.flush()
-                self.config.streamer(event_args)
+                await self.config.streamer_async(event_args)
 
         if event_tool_deltas is not None and not silent:
             # print out streaming tool calls, if not async
@@ -755,12 +845,12 @@ class OpenAIGPT(LanguageModel):
                         Colors().GREEN + "OAI-TOOL: " + tool_fn_name + ": "
                     )
                     sys.stdout.flush()
-                    self.config.streamer(tool_fn_name)
+                    await self.config.streamer_async(tool_fn_name)
                 if td["function"]["arguments"] != "":
                     tool_fn_args = td["function"]["arguments"]
                     sys.stdout.write(Colors().GREEN + tool_fn_args)
                     sys.stdout.flush()
-                    self.config.streamer(tool_fn_args)
+                    await self.config.streamer_async(tool_fn_args)
 
         # show this delta in the stream
         if choices[0].get("finish_reason", "") in [
@@ -862,7 +952,7 @@ class OpenAIGPT(LanguageModel):
                     function_name,
                     function_args,
                     completion,
-                ) = self._process_stream_event(
+                ) = await self._process_stream_event_async(
                     event,
                     chat=chat,
                     tool_deltas=tool_deltas,
@@ -870,7 +960,6 @@ class OpenAIGPT(LanguageModel):
                     completion=completion,
                     function_args=function_args,
                     function_name=function_name,
-                    is_async=True,
                 )
                 if is_break:
                     break

{langroid-0.18.2 → langroid-0.19.0}/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.2 → langroid-0.19.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "langroid"
-version = "0.18.2"
+version = "0.19.0"
 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