langroid 0.18.3__tar.gz → 0.19.1__tar.gz

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

@@ -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 → langroid-0.19.1}/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.18.3 → langroid-0.19.1}/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.3 → langroid-0.19.1}/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.3 → langroid-0.19.1}/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.3 → langroid-0.19.1}/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-0.18.3 → langroid-0.19.1}/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.3 → langroid-0.19.1}/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 → langroid-0.19.1}/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"