langroid 0.18.3__py3-none-any.whl → 0.19.1__py3-none-any.whl

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/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/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/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
 
@@ -133,15 +134,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 +157,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 +232,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 +282,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/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/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.3.dist-info → langroid-0.19.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: langroid
-Version: 0.18.3
+Version: 0.19.1
 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.18.3.dist-info → langroid-0.19.1.dist-info}/RECORD

@@ -1,10 +1,10 @@
 langroid/__init__.py,sha256=z_fCOLQJPOw3LLRPBlFB5-2HyCjpPgQa4m4iY5Fvb8Y,1800
 langroid/agent/__init__.py,sha256=ll0Cubd2DZ-fsCMl7e10hf9ZjFGKzphfBco396IKITY,786
-langroid/agent/base.py,sha256=tJFil49Us2wRv2oKbikqrmcBv6KAeM-UdZ7Psrr-jjE,64282
+langroid/agent/base.py,sha256=bk_N8J7yKdkuopM8z86MkngAfHt5z0qh1HWdcI4tbPw,64420
 langroid/agent/batch.py,sha256=QZdlt1563hx4l3AXrCaGovE-PNG93M3DsvQAbDzdiS8,13705
 langroid/agent/callbacks/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-langroid/agent/callbacks/chainlit.py,sha256=oiZYfPyfkUfFqhVFBiobN3hAJEaYn0FBSglvNE7t17Q,22302
-langroid/agent/chat_agent.py,sha256=m1fs-XsBzusRicwBETId3dpTQG8qEaS0yym_o4mfAI0,49931
+langroid/agent/callbacks/chainlit.py,sha256=JJXI3UGTyTDg2FFath4rqY1GyUo_0pbVBt8CZpvdtn4,23289
+langroid/agent/chat_agent.py,sha256=GVuKXAwHACeTc1gC0y7Ywj8CmJfqu7InJ0AXtmz8nRw,50000
 langroid/agent/chat_document.py,sha256=FZ_PkeKU5OVp1IUlMvspfqxIXzlyd7J_F32DSYrxQ7E,17651
 langroid/agent/helpers.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 langroid/agent/junk,sha256=LxfuuW7Cijsg0szAzT81OjWWv1PMNI-6w_-DspVIO2s,339
@@ -46,7 +46,7 @@ langroid/agent/tools/retrieval_tool.py,sha256=2q2pfoYbZNfbWQ0McxrtmfF0ekGglIgRl-
 langroid/agent/tools/rewind_tool.py,sha256=XAXL3BpNhCmBGYq_qi_sZfHJuIw7NY2jp4wnojJ7WRs,5606
 langroid/agent/tools/segment_extract_tool.py,sha256=__srZ_VGYLVOdPrITUM8S0HpmX4q7r5FHWMDdHdEv8w,1440
 langroid/agent/typed_task.py,sha256=oxja0Z3uLTv0BcR1xIMqDpo85MIGOruz4XsZ4ghjsW4,689
-langroid/agent/xml_tool_message.py,sha256=WcwCWe9Ad3t4D0cExKOb6dhjL5YM6Cz3gsg3nnVoVh0,13347
+langroid/agent/xml_tool_message.py,sha256=OwmHqHqagJOvC7U000z767WOqWztlJXa7A5gK0csfck,14429
 langroid/agent_config.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 langroid/cachedb/__init__.py,sha256=icAT2s7Vhf-ZGUeqpDQGNU6ob6o0aFEyjwcxxUGRFjg,225
 langroid/cachedb/base.py,sha256=ztVjB1DtN6pLCujCWnR6xruHxwVj3XkYniRTYAKKqk0,1354
@@ -67,10 +67,10 @@ langroid/language_models/.chainlit/config.toml,sha256=1t5lHORGzc2E6dkaO9P15jYHu2
 langroid/language_models/.chainlit/translations/en-US.json,sha256=DAFz2HjOFFfboCStrUfKFg2BpplJPK_OOtixwF_GivY,9931
 langroid/language_models/__init__.py,sha256=1sUGobooTqq77XC7LxKsvME0RgSd5GGmeyrPo9SMh4U,940
 langroid/language_models/azure_openai.py,sha256=G4le3j4YLHV7IwgB2C37hO3MKijZ1KjynbYlEvpIF7Y,6214
-langroid/language_models/base.py,sha256=L02ToM7o1y5OlM23xYX8QbriRMVUodgwbnHodl3US28,22542
+langroid/language_models/base.py,sha256=xMFg8syIHiA7ABRNWPXeFM1vGeY_1EN84ki8C3dycfw,22722
 langroid/language_models/config.py,sha256=9Q8wk5a7RQr8LGMT_0WkpjY8S4ywK06SalVRjXlfCiI,378
 langroid/language_models/mock_lm.py,sha256=HuiAvjHiCfffYF5xjFJUq945HVTW0QPbeUUctOnNCzQ,3868
-langroid/language_models/openai_gpt.py,sha256=AlHg-jbf7PBFcS1iqb5z--upokDcWS7RJ4qpAmovsVw,64822
+langroid/language_models/openai_gpt.py,sha256=MwhdyF5RNfTupGL__jU1rx0LJQe2UvoKnnK4vTBHWDs,68799
 langroid/language_models/prompt_formatter/__init__.py,sha256=2-5cdE24XoFDhifOLl8yiscohil1ogbP1ECkYdBlBsk,372
 langroid/language_models/prompt_formatter/base.py,sha256=eDS1sgRNZVnoajwV_ZIha6cba5Dt8xjgzdRbPITwx3Q,1221
 langroid/language_models/prompt_formatter/hf_formatter.py,sha256=PVJppmjRvD-2DF-XNC6mE05vTZ9wbu37SmXwZBQhad0,5055
@@ -137,8 +137,8 @@ langroid/vector_store/meilisearch.py,sha256=6frB7GFWeWmeKzRfLZIvzRjllniZ1cYj3Hmh
 langroid/vector_store/momento.py,sha256=qR-zBF1RKVHQZPZQYW_7g-XpTwr46p8HJuYPCkfJbM4,10534
 langroid/vector_store/qdrant_cloud.py,sha256=3im4Mip0QXLkR6wiqVsjV1QvhSElfxdFSuDKddBDQ-4,188
 langroid/vector_store/qdrantdb.py,sha256=v88lqFkepADvlN6lByUj9I4NEKa9X9lWH16uTPPbYrE,17457
-pyproject.toml,sha256=Ox9dOuITyUORtt923h4uu74ZWh9d3fkN0lBjQAGdvZc,7251
-langroid-0.18.3.dist-info/LICENSE,sha256=EgVbvA6VSYgUlvC3RvPKehSg7MFaxWDsFuzLOsPPfJg,1065
-langroid-0.18.3.dist-info/METADATA,sha256=YWVqIJ_x-Y6duar3ohcC1SH9ErDDkcjzs6oZ0fXhSF0,56484
-langroid-0.18.3.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
-langroid-0.18.3.dist-info/RECORD,,
+pyproject.toml,sha256=cs7STWXoyn2Mat0iWQcywwjrxRYO7Y4nw5gc8udj9vo,7251
+langroid-0.19.1.dist-info/LICENSE,sha256=EgVbvA6VSYgUlvC3RvPKehSg7MFaxWDsFuzLOsPPfJg,1065
+langroid-0.19.1.dist-info/METADATA,sha256=9tkOu9XsqdS4RAc9-aySyDaarwDt5ybBrehttG9vqys,56513
+langroid-0.19.1.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
+langroid-0.19.1.dist-info/RECORD,,

pyproject.toml

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