langroid 0.24.1__py3-none-any.whl → 0.26.0__py3-none-any.whl

langroid/agent/base.py

@@ -175,6 +175,7 @@ class Agent(ABC):
             show_llm_response=noop_fn,
             show_agent_response=noop_fn,
             get_user_response=None,
+            get_user_response_async=None,
             get_last_step=noop_fn,
             set_parent_agent=noop_fn,
             show_error_message=noop_fn,
@@ -322,6 +323,52 @@ class Agent(ABC):
                 lambda msg: message_class.handle_message_fallback(self, msg),
             )
 
+        async_tool_name = f"{tool}_async"
+        if (
+            hasattr(message_class, "handle_async")
+            and inspect.isfunction(message_class.handle_async)
+            and not hasattr(self, async_tool_name)
+        ):
+            has_chat_doc_arg = (
+                len(inspect.signature(message_class.handle_async).parameters) > 1
+            )
+
+            if has_chat_doc_arg:
+
+                @no_type_check
+                async def handler(obj, chat_doc):
+                    return await obj.handle_async(chat_doc)
+
+            else:
+
+                @no_type_check
+                async def handler(obj):
+                    return await obj.handle_async()
+
+            setattr(self, async_tool_name, handler)
+        elif (
+            hasattr(message_class, "response_async")
+            and inspect.isfunction(message_class.response_async)
+            and not hasattr(self, async_tool_name)
+        ):
+            has_chat_doc_arg = (
+                len(inspect.signature(message_class.response_async).parameters) > 2
+            )
+
+            if has_chat_doc_arg:
+
+                @no_type_check
+                async def handler(obj, chat_doc):
+                    return await obj.response_async(self, chat_doc)
+
+            else:
+
+                @no_type_check
+                async def handler(obj):
+                    return await obj.response_async(self)
+
+            setattr(self, async_tool_name, handler)
+
         return [tool]
 
     def enable_message_handling(
@@ -393,32 +440,14 @@ class Agent(ABC):
             recipient=recipient,
         )
 
-    async def agent_response_async(
+    def _agent_response_final(
         self,
-        msg: Optional[str | ChatDocument] = None,
-    ) -> Optional[ChatDocument]:
-        return self.agent_response(msg)
-
-    def agent_response(
-        self,
-        msg: Optional[str | ChatDocument] = None,
+        msg: Optional[str | ChatDocument],
+        results: Optional[str | OrderedDict[str, str] | ChatDocument],
     ) -> Optional[ChatDocument]:
         """
-        Response from the "agent itself", typically (but not only)
-        used to handle LLM's "tool message" or `function_call`
-        (e.g. OpenAI `function_call`).
-        Args:
-            msg (str|ChatDocument): the input to respond to: if msg is a string,
-                and it contains a valid JSON-structured "tool message", or
-                if msg is a ChatDocument, and it contains a `function_call`.
-        Returns:
-            Optional[ChatDocument]: the response, packaged as a ChatDocument
-
+        Convert results to final response.
         """
-        if msg is None:
-            return None
-
-        results = self.handle_message(msg)
         if results is None:
             return None
         if not settings.quiet:
@@ -438,7 +467,7 @@ class Agent(ABC):
         if isinstance(results, ChatDocument):
             # Preserve trail of tool_ids for OpenAI Assistant fn-calls
             results.metadata.tool_ids = (
-                [] if isinstance(msg, str) else msg.metadata.tool_ids
+                [] if msg is None or isinstance(msg, str) else msg.metadata.tool_ids
             )
             return results
         sender_name = self.config.name
@@ -461,10 +490,49 @@ class Agent(ABC):
                 sender_name=sender_name,
                 oai_tool_id=oai_tool_id,
                 # preserve trail of tool_ids for OpenAI Assistant fn-calls
-                tool_ids=[] if isinstance(msg, str) else msg.metadata.tool_ids,
+                tool_ids=(
+                    [] if msg is None or isinstance(msg, str) else msg.metadata.tool_ids
+                ),
             ),
         )
 
+    async def agent_response_async(
+        self,
+        msg: Optional[str | ChatDocument] = None,
+    ) -> Optional[ChatDocument]:
+        """
+        Asynch version of `agent_response`. See there for details.
+        """
+        if msg is None:
+            return None
+
+        results = await self.handle_message_async(msg)
+
+        return self._agent_response_final(msg, results)
+
+    def agent_response(
+        self,
+        msg: Optional[str | ChatDocument] = None,
+    ) -> Optional[ChatDocument]:
+        """
+        Response from the "agent itself", typically (but not only)
+        used to handle LLM's "tool message" or `function_call`
+        (e.g. OpenAI `function_call`).
+        Args:
+            msg (str|ChatDocument): the input to respond to: if msg is a string,
+                and it contains a valid JSON-structured "tool message", or
+                if msg is a ChatDocument, and it contains a `function_call`.
+        Returns:
+            Optional[ChatDocument]: the response, packaged as a ChatDocument
+
+        """
+        if msg is None:
+            return None
+
+        results = self.handle_message(msg)
+
+        return self._agent_response_final(msg, results)
+
     def process_tool_results(
         self,
         results: str,
@@ -625,60 +693,46 @@ class Agent(ABC):
             recipient=recipient,
         )
 
-    async def user_response_async(
-        self,
-        msg: Optional[str | ChatDocument] = None,
-    ) -> Optional[ChatDocument]:
-        return self.user_response(msg)
-
-    def user_response(
-        self,
-        msg: Optional[str | ChatDocument] = None,
-    ) -> Optional[ChatDocument]:
+    def user_can_respond(self, msg: Optional[str | ChatDocument] = None) -> bool:
         """
-        Get user response to current message. Could allow (human) user to intervene
-        with an actual answer, or quit using "q" or "x"
+        Whether the user can respond to a message.
 
         Args:
             msg (str|ChatDocument): the string to respond to.
 
         Returns:
-            (str) User response, packaged as a ChatDocument
 
         """
-
         # When msg explicitly addressed to user, this means an actual human response
         # is being sought.
         need_human_response = (
             isinstance(msg, ChatDocument) and msg.metadata.recipient == Entity.USER
         )
-        default_user_msg = (
-            (self.default_human_response or "null") if need_human_response else ""
-        )
 
         if not self.interactive and not need_human_response:
-            return None
-        elif self.default_human_response is not None:
-            user_msg = self.default_human_response
-        else:
-            if self.callbacks.get_user_response is not None:
-                # ask user with empty prompt: no need for prompt
-                # since user has seen the conversation so far.
-                # But non-empty prompt can be useful when Agent
-                # uses a tool that requires user input, or in other scenarios.
-                user_msg = self.callbacks.get_user_response(prompt="")
-            else:
-                user_msg = Prompt.ask(
-                    f"[blue]{self.indent}"
-                    + self.config.human_prompt
-                    + f"\n{self.indent}"
-                ).strip()
+            return False
+
+        return True
+
+    def _user_response_final(
+        self, msg: Optional[str | ChatDocument], user_msg: str
+    ) -> Optional[ChatDocument]:
+        """
+        Convert user_msg to final response.
+        """
+        if not user_msg:
+            need_human_response = (
+                isinstance(msg, ChatDocument) and msg.metadata.recipient == Entity.USER
+            )
+            user_msg = (
+                (self.default_human_response or "null") if need_human_response else ""
+            )
+        user_msg = user_msg.strip()
 
         tool_ids = []
         if msg is not None and isinstance(msg, ChatDocument):
             tool_ids = msg.metadata.tool_ids
 
-        user_msg = user_msg.strip() or default_user_msg.strip()
         # only return non-None result if user_msg not empty
         if not user_msg:
             return None
@@ -700,6 +754,72 @@ class Agent(ABC):
                 ),
             )
 
+    async def user_response_async(
+        self,
+        msg: Optional[str | ChatDocument] = None,
+    ) -> Optional[ChatDocument]:
+        """
+        Asynch version of `user_response`. See there for details.
+        """
+        if not self.user_can_respond(msg):
+            return None
+
+        if self.default_human_response is not None:
+            user_msg = self.default_human_response
+        else:
+            if (
+                self.callbacks.get_user_response_async is not None
+                and self.callbacks.get_user_response_async is not async_noop_fn
+            ):
+                user_msg = await self.callbacks.get_user_response_async(prompt="")
+            elif self.callbacks.get_user_response is not None:
+                user_msg = self.callbacks.get_user_response(prompt="")
+            else:
+                user_msg = Prompt.ask(
+                    f"[blue]{self.indent}"
+                    + self.config.human_prompt
+                    + f"\n{self.indent}"
+                )
+
+        return self._user_response_final(msg, user_msg)
+
+    def user_response(
+        self,
+        msg: Optional[str | ChatDocument] = None,
+    ) -> Optional[ChatDocument]:
+        """
+        Get user response to current message. Could allow (human) user to intervene
+        with an actual answer, or quit using "q" or "x"
+
+        Args:
+            msg (str|ChatDocument): the string to respond to.
+
+        Returns:
+            (str) User response, packaged as a ChatDocument
+
+        """
+
+        if not self.user_can_respond(msg):
+            return None
+
+        if self.default_human_response is not None:
+            user_msg = self.default_human_response
+        else:
+            if self.callbacks.get_user_response is not None:
+                # ask user with empty prompt: no need for prompt
+                # since user has seen the conversation so far.
+                # But non-empty prompt can be useful when Agent
+                # uses a tool that requires user input, or in other scenarios.
+                user_msg = self.callbacks.get_user_response(prompt="")
+            else:
+                user_msg = Prompt.ask(
+                    f"[blue]{self.indent}"
+                    + self.config.human_prompt
+                    + f"\n{self.indent}"
+                )
+
+        return self._user_response_final(msg, user_msg)
+
     @no_type_check
     def llm_can_respond(self, message: Optional[str | ChatDocument] = None) -> bool:
         """
@@ -791,7 +911,7 @@ class Agent(ABC):
                     f"""
                 Requested output length has been shortened to {output_len}
                 so that the total length of Prompt + Output is less than
-                the completion context length of the LLM. 
+                the completion context length of the LLM.
                 """
                 )
 
@@ -865,7 +985,7 @@ class Agent(ABC):
                         f"""
                     Requested output length has been shortened to {output_len}
                     so that the total length of Prompt + Output is less than
-                    the completion context length of the LLM. 
+                    the completion context length of the LLM.
                     """
                     )
             if self.llm.get_stream() and not settings.quiet:
@@ -1075,7 +1195,7 @@ class Agent(ABC):
         if tool_name not in self.llm_tools_handled:
             logger.warning(
                 f"""
-                The function_call '{tool_name}' is not handled 
+                The function_call '{tool_name}' is not handled
                 by the agent named '{self.config.name}'!
                 If you intended this agent to handle this function_call,
                 either the fn-call name is incorrectly generated by the LLM,
@@ -1110,7 +1230,7 @@ class Agent(ABC):
             if tool_name not in self.llm_tools_handled:
                 logger.warning(
                     f"""
-                    The tool_call '{tool_name}' is not handled 
+                    The tool_call '{tool_name}' is not handled
                     by the agent named '{self.config.name}'!
                     If you intended this agent to handle this function_call,
                     either the fn-call name is incorrectly generated by the LLM,
@@ -1145,65 +1265,18 @@ class Agent(ABC):
             [f"{e['loc']}: {e['msg']}" for e in ve.errors() if "loc" in e]
         )
         return f"""
-        There were one or more errors in your attempt to use the 
-        TOOL or function_call named '{tool_name}': 
+        There were one or more errors in your attempt to use the
+        TOOL or function_call named '{tool_name}':
         {bad_field_errors}
         Please write your message again, correcting the errors.
         """
 
-    def handle_message(
-        self, msg: str | ChatDocument
-    ) -> None | str | OrderedDict[str, str] | ChatDocument:
+    def _get_multiple_orch_tool_errs(
+        self, tools: List[ToolMessage]
+    ) -> List[str | ChatDocument | None]:
         """
-        Handle a "tool" message either a string containing one or more
-        valid "tool" JSON substrings,  or a
-        ChatDocument containing a `function_call` attribute.
-        Handle with the corresponding handler method, and return
-        the results as a combined string.
-
-        Args:
-            msg (str | ChatDocument): The string or ChatDocument to handle
-
-        Returns:
-            The result of the handler method can be:
-             - None if no tools successfully handled, or no tools present
-             - str if langroid-native JSON tools were handled, and results concatenated,
-                 OR there's a SINGLE OpenAI tool-call.
-                (We do this so the common scenario of a single tool/fn-call
-                 has a simple behavior).
-             - Dict[str, str] if multiple OpenAI tool-calls were handled
-                 (dict is an id->result map)
-             - ChatDocument if a handler returned a ChatDocument, intended to be the
-                 final response of the `agent_response` method.
+        Return error document if the message contains multiple orchestration tools
         """
-        try:
-            tools = self.get_tool_messages(msg)
-            tools = [t for t in tools if self._tool_recipient_match(t)]
-        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
-            # be considered a valid result in task loop, and would be treated
-            # 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:
-                return None
-            return self.to_ChatDocument(
-                fallback_result,
-                chat_doc=msg if isinstance(msg, ChatDocument) else None,
-            )
-        has_ids = all([t.id != "" for t in tools])
-        chat_doc = msg if isinstance(msg, ChatDocument) else None
-
         # check whether there are multiple orchestration-tools (e.g. DoneTool etc),
         # in which case set result to error-string since we don't yet support
         # multi-tools with one or more orch tools.
@@ -1230,20 +1303,24 @@ class Agent(ABC):
         )
 
         has_orch = any(isinstance(t, ORCHESTRATION_TOOLS) for t in tools)
-        results: List[str | ChatDocument | None]
         if has_orch and len(tools) > 1:
             err_str = "ERROR: Use ONE tool at a time!"
-            results = [err_str for _ in tools]
-        else:
-            results = [self.handle_tool_message(t, chat_doc=chat_doc) for t in tools]
-            # if there's a solitary ChatDocument|str result, return it as is
-            if len(results) == 1 and isinstance(results[0], (str, ChatDocument)):
-                return results[0]
-            # extract content from ChatDocument results so we have all str|None
-            results = [r.content if isinstance(r, ChatDocument) else r for r in results]
+            return [err_str for _ in tools]
+
+        return []
+
+    def _handle_message_final(
+        self, tools: List[ToolMessage], results: List[str | ChatDocument | None]
+    ) -> None | str | OrderedDict[str, str] | ChatDocument:
+        """
+        Convert results to final response
+        """
+        # extract content from ChatDocument results so we have all str|None
+        results = [r.content if isinstance(r, ChatDocument) else r for r in results]
 
-        # now all results are str|None
         tool_names = [t.default_value("request") for t in tools]
+
+        has_ids = all([t.id != "" for t in tools])
         if has_ids:
             id2result = OrderedDict(
                 (t.id, r)
@@ -1278,6 +1355,112 @@ class Agent(ABC):
         final = "\n\n".join(str_results)
         return final
 
+    async def handle_message_async(
+        self, msg: str | ChatDocument
+    ) -> None | str | OrderedDict[str, str] | ChatDocument:
+        """
+        Asynch version of `handle_message`. See there for details.
+        """
+        try:
+            tools = self.get_tool_messages(msg)
+            tools = [t for t in tools if self._tool_recipient_match(t)]
+        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
+            # be considered a valid result in task loop, and would be treated
+            # 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:
+                return None
+            return self.to_ChatDocument(
+                fallback_result,
+                chat_doc=msg if isinstance(msg, ChatDocument) else None,
+            )
+        chat_doc = msg if isinstance(msg, ChatDocument) else None
+
+        results = self._get_multiple_orch_tool_errs(tools)
+        if not results:
+            results = [
+                await self.handle_tool_message_async(t, chat_doc=chat_doc)
+                for t in tools
+            ]
+            # if there's a solitary ChatDocument|str result, return it as is
+            if len(results) == 1 and isinstance(results[0], (str, ChatDocument)):
+                return results[0]
+
+        return self._handle_message_final(tools, results)
+
+    def handle_message(
+        self, msg: str | ChatDocument
+    ) -> None | str | OrderedDict[str, str] | ChatDocument:
+        """
+        Handle a "tool" message either a string containing one or more
+        valid "tool" JSON substrings,  or a
+        ChatDocument containing a `function_call` attribute.
+        Handle with the corresponding handler method, and return
+        the results as a combined string.
+
+        Args:
+            msg (str | ChatDocument): The string or ChatDocument to handle
+
+        Returns:
+            The result of the handler method can be:
+             - None if no tools successfully handled, or no tools present
+             - str if langroid-native JSON tools were handled, and results concatenated,
+                 OR there's a SINGLE OpenAI tool-call.
+                (We do this so the common scenario of a single tool/fn-call
+                 has a simple behavior).
+             - Dict[str, str] if multiple OpenAI tool-calls were handled
+                 (dict is an id->result map)
+             - ChatDocument if a handler returned a ChatDocument, intended to be the
+                 final response of the `agent_response` method.
+        """
+        try:
+            tools = self.get_tool_messages(msg)
+            tools = [t for t in tools if self._tool_recipient_match(t)]
+        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
+            # be considered a valid result in task loop, and would be treated
+            # 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:
+                return None
+            return self.to_ChatDocument(
+                fallback_result,
+                chat_doc=msg if isinstance(msg, ChatDocument) else None,
+            )
+        chat_doc = msg if isinstance(msg, ChatDocument) else None
+
+        results = self._get_multiple_orch_tool_errs(tools)
+        if not results:
+            results = [self.handle_tool_message(t, chat_doc=chat_doc) for t in tools]
+            # if there's a solitary ChatDocument|str result, return it as is
+            if len(results) == 1 and isinstance(results[0], (str, ChatDocument)):
+                return results[0]
+
+        return self._handle_message_final(tools, results)
+
     @property
     def all_llm_tools_known(self) -> set[str]:
         """All known tools; this may extend self.llm_tools_known."""
@@ -1546,6 +1729,37 @@ class Agent(ABC):
             ) + truncate_warning
             return result
 
+    async def handle_tool_message_async(
+        self,
+        tool: ToolMessage,
+        chat_doc: Optional[ChatDocument] = None,
+    ) -> None | str | ChatDocument:
+        """
+        Asynch version of `handle_tool_message`. See there for details.
+        """
+        tool_name = tool.default_value("request")
+        handler_method = getattr(self, tool_name + "_async", None)
+        if handler_method is None:
+            return self.handle_tool_message(tool, chat_doc=chat_doc)
+        has_chat_doc_arg = (
+            chat_doc is not None
+            and "chat_doc" in inspect.signature(handler_method).parameters
+        )
+        try:
+            if has_chat_doc_arg:
+                maybe_result = await handler_method(tool, chat_doc=chat_doc)
+            else:
+                maybe_result = await handler_method(tool)
+            result = self.to_ChatDocument(maybe_result, tool_name, chat_doc)
+        except Exception as e:
+            # raise the error here since we are sure it's
+            # not a pydantic validation error,
+            # which we check in `handle_message`
+            raise e
+        return self._maybe_truncate_result(
+            result, tool._max_result_tokens
+        )  # type: ignore
+
     def handle_tool_message(
         self,
         tool: ToolMessage,

langroid/agent/callbacks/chainlit.py

@@ -16,7 +16,6 @@ except ImportError:
     raise LangroidImportError("chainlit", "chainlit")
 
 from chainlit import run_sync
-from chainlit.config import config
 from chainlit.logger import logger
 
 import langroid as lr
@@ -227,7 +226,6 @@ class ChainlitAgentCallbacks:
     def __init__(
         self,
         agent: lr.Agent,
-        msg: cl.Message = None,
         config: ChainlitCallbackConfig = ChainlitCallbackConfig(),
     ):
         """Add callbacks to the agent, and save the initial message,
@@ -240,6 +238,7 @@ class ChainlitAgentCallbacks:
         agent.callbacks.show_llm_response = self.show_llm_response
         agent.callbacks.show_agent_response = self.show_agent_response
         agent.callbacks.get_user_response = self.get_user_response
+        agent.callbacks.get_user_response_async = self.get_user_response_async
         agent.callbacks.get_last_step = self.get_last_step
         agent.callbacks.set_parent_agent = self.set_parent_agent
         agent.callbacks.show_error_message = self.show_error_message
@@ -250,8 +249,6 @@ class ChainlitAgentCallbacks:
             # We don't want to suppress LLM output in async + streaming,
             # since we often use chainlit async callbacks to display LLM output
             self.agent.llm.config.async_stream_quiet = False
-        if msg is not None:
-            self.show_first_user_message(msg)
 
     def _get_parent_id(self) -> str | None:
         """Get step id under which we need to nest the current step:
@@ -281,10 +278,11 @@ class ChainlitAgentCallbacks:
 
     def start_llm_stream(self) -> Callable[[str], None]:
         """Returns a streaming fn that can be passed to the LLM class"""
-        self.stream = cl.Step(
+        self.stream = cl.Message(
+            content="",
             id=self.curr_step.id if self.curr_step is not None else None,
-            name=self._entity_name("llm"),
-            type="llm",
+            author=self._entity_name("llm"),
+            type="assistant_message",
             parent_id=self._get_parent_id(),
         )
         self.last_step = self.stream
@@ -296,7 +294,6 @@ class ChainlitAgentCallbacks:
             under parent {self._get_parent_id()}
         """
         )
-        run_sync(self.stream.send())  # type: ignore
 
         def stream_token(t: str) -> None:
             if self.stream is None:
@@ -307,10 +304,11 @@ class ChainlitAgentCallbacks:
 
     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(
+        self.stream = cl.Message(
+            content="",
             id=self.curr_step.id if self.curr_step is not None else None,
-            name=self._entity_name("llm"),
-            type="llm",
+            author=self._entity_name("llm"),
+            type="assistant_message",
             parent_id=self._get_parent_id(),
         )
         self.last_step = self.stream
@@ -320,9 +318,8 @@ class ChainlitAgentCallbacks:
             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:
@@ -346,14 +343,14 @@ class ChainlitAgentCallbacks:
         else:
             run_sync(self.stream.update())  # type: ignore
         stream_id = self.stream.id if content else None
-        step = cl.Step(
+        step = cl.Message(
+            content=textwrap.dedent(content) or NO_ANSWER,
             id=stream_id,
-            name=self._entity_name("llm", tool=is_tool),
-            type="llm",
+            author=self._entity_name("llm", tool=is_tool),
+            type="assistant_message",
             parent_id=self._get_parent_id(),
             language="json" if is_tool else None,
         )
-        step.output = textwrap.dedent(content) or NO_ANSWER
         logger.info(
             f"""
             Finish STREAM LLM response for {self.agent.config.name}
@@ -371,16 +368,16 @@ class ChainlitAgentCallbacks:
         language: str | None = None,
     ) -> None:
         """Show non-streaming LLM response."""
-        step = cl.Step(
+        step = cl.Message(
+            content=textwrap.dedent(content) or NO_ANSWER,
             id=self.curr_step.id if self.curr_step is not None else None,
-            name=self._entity_name("llm", tool=is_tool, cached=cached),
-            type="llm",
-            parent_id=self._get_parent_id(),
+            author=self._entity_name("llm", tool=is_tool, cached=cached),
+            type="assistant_message",
             language=language or ("json" if is_tool else None),
+            parent_id=self._get_parent_id(),
         )
         self.last_step = step
         self.curr_step = None
-        step.output = textwrap.dedent(content) or NO_ANSWER
         logger.info(
             f"""
             Showing NON-STREAM LLM response for {self.agent.config.name}
@@ -391,34 +388,31 @@ class ChainlitAgentCallbacks:
         run_sync(step.send())  # type: ignore
 
     def show_error_message(self, error: str) -> None:
-        """Show error message as a step."""
-        step = cl.Step(
-            name=self.agent.config.name + f"({ERROR})",
+        """Show error message."""
+        step = cl.Message(
+            content=error,
+            author=self.agent.config.name + f"({ERROR})",
             type="run",
-            parent_id=self._get_parent_id(),
             language="text",
+            parent_id=self._get_parent_id(),
         )
         self.last_step = step
-        step.output = error
         run_sync(step.send())
 
     def show_agent_response(self, content: str, language="text") -> None:
-        """Show message from agent (typically tool handler).
-        Agent response can be considered as a "step"
-        between LLM response and user response
-        """
-        step = cl.Step(
+        """Show message from agent (typically tool handler)."""
+        if language == "text":
+            content = wrap_text_preserving_structure(content, width=90)
+        step = cl.Message(
+            content=content,
             id=self.curr_step.id if self.curr_step is not None else None,
-            name=self._entity_name("agent"),
+            author=self._entity_name("agent"),
             type="tool",
-            parent_id=self._get_parent_id(),
             language=language,
+            parent_id=self._get_parent_id(),
         )
-        if language == "text":
-            content = wrap_text_preserving_structure(content, width=90)
         self.last_step = step
         self.curr_step = None
-        step.output = content
         logger.info(
             f"""
             Showing AGENT response for {self.agent.config.name}
@@ -433,13 +427,13 @@ class ChainlitAgentCallbacks:
         so that the UI displays a spinner while the process is running."""
         if self.curr_step is not None:
             run_sync(self.curr_step.remove())  # type: ignore
-        step = cl.Step(
-            name=self._entity_name(entity),
+        step = cl.Message(
+            content="",
+            author=self._entity_name(entity),
             type="run",
             parent_id=self._get_parent_id(),
             language="text",
         )
-        step.output = ""
         self.last_step = step
         self.curr_step = step
         logger.info(
@@ -503,54 +497,23 @@ class ChainlitAgentCallbacks:
         return ""  # process the "feedback" case here
 
     def get_user_response(self, prompt: str) -> str:
-        """Ask for user response, wait for it, and return it,
-        as a cl.Step rather than as a cl.Message so we can nest it
-        under the parent step.
-        """
-        return run_sync(self.ask_user_step(prompt=prompt, suppress_values=["c"]))
+        """Ask for user response, wait for it, and return it"""
 
-    def show_user_response(self, message: str) -> None:
-        """Show user response as a step."""
-        step = cl.Step(
-            id=cl.context.current_step.id,
-            name=self._entity_name("user"),
-            type="run",
-            parent_id=self._get_parent_id(),
-        )
-        step.output = message
-        logger.info(
-            f"""
-            Showing USER response for {self.agent.config.name}
-            id = {step.id} 
-            under parent {self._get_parent_id()}
-            """
-        )
-        run_sync(step.send())
+        return run_sync(self.ask_user(prompt=prompt, suppress_values=["c"]))
 
-    def show_first_user_message(self, msg: cl.Message):
-        """Show first user message as a step."""
-        step = cl.Step(
-            id=msg.id,
-            name=self._entity_name("user"),
-            type="run",
-            parent_id=self._get_parent_id(),
-        )
-        self.last_step = step
-        step.output = msg.content
-        run_sync(step.update())
+    async def get_user_response_async(self, prompt: str) -> str:
+        """Ask for user response, wait for it, and return it"""
+
+        return await self.ask_user(prompt=prompt, suppress_values=["c"])
 
-    async def ask_user_step(
+    async def ask_user(
         self,
         prompt: str,
         timeout: int = USER_TIMEOUT,
         suppress_values: List[str] = ["c"],
     ) -> str:
         """
-        Ask user for input, as a step nested under parent_id.
-        Rather than rely entirely on AskUserMessage (which doesn't let us
-        nest the question + answer under a step), we instead create fake
-        steps for the question and answer, and only rely on AskUserMessage
-        with an empty prompt to await user response.
+        Ask user for input.
 
         Args:
             prompt (str): Prompt to display to user
@@ -561,31 +524,16 @@ class ChainlitAgentCallbacks:
         Returns:
             str: User response
         """
-
-        # save hide_cot status to restore later
-        # (We should probably use a ctx mgr for this)
-        hide_cot = config.ui.hide_cot
-
-        # force hide_cot to False so that the user question + response is visible
-        config.ui.hide_cot = False
-
-        if prompt != "":
-            # Create a question step to ask user
-            question_step = cl.Step(
-                name=f"{self.agent.config.name} (AskUser ❓)",
-                type="run",
-                parent_id=self._get_parent_id(),
-            )
-            question_step.output = prompt
-            await question_step.send()  # type: ignore
-
-        # Use AskUserMessage to await user response,
-        # but with an empty prompt so the question is not visible,
-        # but still pauses for user input in the input box.
-        res = await cl.AskUserMessage(
-            content="",
+        ask_msg = cl.AskUserMessage(
+            content=prompt,
+            author=f"{self.agent.config.name}(Awaiting user input...)",
+            type="assistant_message",
             timeout=timeout,
-        ).send()
+        )
+        res = await ask_msg.send()
+        if prompt == "":
+            # if there was no actual prompt, clear the row from the UI for clarity.
+            await ask_msg.remove()
 
         if res is None:
             run_sync(
@@ -595,31 +543,10 @@ class ChainlitAgentCallbacks:
             )
             return "x"
 
-        # The above will try to display user response in res
-        # but we create fake step with same id as res and
-        # erase it using empty output so it's not displayed
-        step = cl.Step(
-            id=res["id"],
-            name="TempUserResponse",
-            type="run",
-            parent_id=self._get_parent_id(),
-        )
-        step.output = ""
-        await step.update()  # type: ignore
-
         # Finally, reproduce the user response at right nesting level
         if res["output"] in suppress_values:
-            config.ui.hide_cot = hide_cot  # restore original value
             return ""
 
-        step = cl.Step(
-            name=self._entity_name(entity="user"),
-            type="run",
-            parent_id=self._get_parent_id(),
-        )
-        step.output = res["output"]
-        await step.send()  # type: ignore
-        config.ui.hide_cot = hide_cot  # restore original value
         return res["output"]
 
 
@@ -632,13 +559,12 @@ class ChainlitTaskCallbacks(ChainlitAgentCallbacks):
     def __init__(
         self,
         task: lr.Task,
-        msg: cl.Message = None,
         config: ChainlitCallbackConfig = ChainlitCallbackConfig(),
     ):
         """Inject callbacks recursively, ensuring msg is passed to the
         top-level agent"""
 
-        super().__init__(task.agent, msg, config)
+        super().__init__(task.agent, config)
         self._inject_callbacks(task)
         self.task = task
         if config.show_subtask_response:
@@ -659,12 +585,14 @@ class ChainlitTaskCallbacks(ChainlitAgentCallbacks):
         """Show sub-task response as a step, nested at the right level."""
 
         # The step should nest under the calling agent's last step
-        step = cl.Step(
-            name=self.task.agent.config.name + f"( ⏎ From {task.agent.config.name})",
+        step = cl.Message(
+            content=content or NO_ANSWER,
+            author=(
+                self.task.agent.config.name + f"( ⏎ From {task.agent.config.name})"
+            ),
             type="run",
             parent_id=self._get_parent_id(),
             language="json" if is_tool else None,
         )
-        step.output = content or NO_ANSWER
         self.last_step = step
         run_sync(step.send())

langroid/agent/chat_agent.py

@@ -1077,6 +1077,25 @@ class ChatAgent(Agent):
 
                 return agent.handle_tool_message(tool)
 
+            async def response_async(
+                self, agent: ChatAgent
+            ) -> None | str | ChatDocument:
+                # One-time use
+                agent.set_output_format(None)
+
+                if self.tool is None:
+                    return None
+
+                # As the ToolMessage schema accepts invalid
+                # `tool.request` values, reparse with the
+                # corresponding tool
+                request = self.tool.request
+                if request not in agent.llm_tools_map:
+                    return None
+                tool = agent.llm_tools_map[request].parse_raw(self.tool.to_json())
+
+                return await agent.handle_tool_message_async(tool)
+
         return AnyTool
 
     def _strict_recovery_instructions(

langroid/agent/tools/orchestration.py

@@ -110,7 +110,7 @@ class FinalResultTool(ToolMessage):
     (b) be returned as the final result of the root task, i.e. this tool would appear
          in the final ChatDocument's `tool_messages` list.
     See test_tool_handlers_and_results in test_tool_messages.py, and
-    examples/basic/tool-extract-short-example.py.
+    examples/basic/chat-tool-function.py.
 
     Note:
         - when defining a tool handler or agent_response, you can directly return
@@ -118,8 +118,13 @@ class FinalResultTool(ToolMessage):
             where the values can be arbitrary data structures, including nested
             Pydantic objs, or you can define a subclass of FinalResultTool with the
             fields you want to return.
-        - This is a special ToolMessage that is NOT meant to be used or handled
-            by an agent.
+        - This is a special ToolMessage that is NOT meant to be used by an agent's
+            llm_response, but only by agent_response or tool handlers.
+        - A subclass of this tool can be defined, with specific fields, and
+          with _allow_llm_use = True, to allow the LLM to generate this tool,
+          and have the effect of terminating the current and all parent tasks,
+          with the tool appearing in the final ChatDocument's `tool_messages` list.
+          See examples/basic/multi-agent-return-result.py.
     """
 
     request: str = ""

{langroid-0.24.1.dist-info → langroid-0.26.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: langroid
-Version: 0.24.1
+Version: 0.26.0
 Summary: Harness LLMs with Multi-Agent Programming
 License: MIT
 Author: Prasad Chalasani
@@ -42,7 +42,7 @@ Requires-Dist: arango-datasets (>=1.2.2,<2.0.0) ; extra == "all" or extra == "ar
 Requires-Dist: async-generator (>=1.10,<2.0)
 Requires-Dist: bs4 (>=0.0.1,<0.0.2)
 Requires-Dist: cerebras-cloud-sdk (>=1.1.0,<2.0.0)
-Requires-Dist: chainlit (==1.1.202) ; extra == "all" or extra == "chainlit"
+Requires-Dist: chainlit (>=1.3.2,<2.0.0) ; extra == "all" or extra == "chainlit"
 Requires-Dist: chromadb (>=0.4.21,<=0.4.23) ; extra == "vecdbs" or extra == "all" or extra == "chromadb"
 Requires-Dist: colorlog (>=6.7.0,<7.0.0)
 Requires-Dist: docstring-parser (>=0.15,<0.16)

{langroid-0.24.1.dist-info → langroid-0.26.0.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=QTmWvt1FzrZpIN2JS1cdhcPNwcXMZkBRDF30L9IF2mo,69412
+langroid/agent/base.py,sha256=jAt7tbyPIWoGJDe6Xi75nthl-JY47yWB9Q5O1m9QJq0,76798
 langroid/agent/batch.py,sha256=QZdlt1563hx4l3AXrCaGovE-PNG93M3DsvQAbDzdiS8,13705
 langroid/agent/callbacks/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-langroid/agent/callbacks/chainlit.py,sha256=JJXI3UGTyTDg2FFath4rqY1GyUo_0pbVBt8CZpvdtn4,23289
-langroid/agent/chat_agent.py,sha256=0xezOwMZeF_gXwq5-XbK67fdTr8ujTzyiRxUbYspRG0,78809
+langroid/agent/callbacks/chainlit.py,sha256=C6zzzYC30qC4eMA7al7eFpRoTgoe3475kaMKyXgQM0Q,20695
+langroid/agent/chat_agent.py,sha256=jZaeMOQsGZlrnWj7RBT7RR17Bd0zR9H4D6n_F4rPUn0,79517
 langroid/agent/chat_document.py,sha256=xPUMGzR83rn4iAEXIw2jy5LQ6YJ6Y0TiZ78XRQeDnJQ,17778
 langroid/agent/helpers.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 langroid/agent/junk,sha256=LxfuuW7Cijsg0szAzT81OjWWv1PMNI-6w_-DspVIO2s,339
@@ -45,7 +45,7 @@ langroid/agent/tools/duckduckgo_search_tool.py,sha256=NhsCaGZkdv28nja7yveAhSK_w6
 langroid/agent/tools/file_tools.py,sha256=GjPB5YDILucYapElnvvoYpGJuZQ25ecLs2REv7edPEo,7292
 langroid/agent/tools/google_search_tool.py,sha256=y7b-3FtgXf0lfF4AYxrZ3K5pH2dhidvibUOAGBE--WI,1456
 langroid/agent/tools/metaphor_search_tool.py,sha256=qj4gt453cLEX3EGW7nVzVu6X7LCdrwjSlcNY0qJW104,2489
-langroid/agent/tools/orchestration.py,sha256=IwAZrSQMM0iMNqs5tcmkSBUIIKaLmH3wtcdyuYaY5uI,11004
+langroid/agent/tools/orchestration.py,sha256=851nZQOE1HpGBwH5om_TNP_qCMxxatXYWFZUrpjSfKk,11421
 langroid/agent/tools/recipient_tool.py,sha256=dr0yTxgNEIoxUYxH6TtaExC4G_8WdJ0xGohIa4dFLhY,9808
 langroid/agent/tools/retrieval_tool.py,sha256=zcAV20PP_6VzSd-UE-IJcabaBseFL_QNz59Bnig8-lE,946
 langroid/agent/tools/rewind_tool.py,sha256=XAXL3BpNhCmBGYq_qi_sZfHJuIw7NY2jp4wnojJ7WRs,5606
@@ -142,8 +142,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=FRIhmvm-hdPUnPTa3_3nollKCbdObvmUdb9KihV8aNE,7495
-langroid-0.24.1.dist-info/LICENSE,sha256=EgVbvA6VSYgUlvC3RvPKehSg7MFaxWDsFuzLOsPPfJg,1065
-langroid-0.24.1.dist-info/METADATA,sha256=6nB1o-vQeCT3ULDeZHZn4iIx7xPfeRwFw8ZOjoKnaW8,57514
-langroid-0.24.1.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
-langroid-0.24.1.dist-info/RECORD,,
+pyproject.toml,sha256=hm5QzEMcabDq_y8pe7dEvEfkVvJQe6Bx7qVdtB1A8ro,7495
+langroid-0.26.0.dist-info/LICENSE,sha256=EgVbvA6VSYgUlvC3RvPKehSg7MFaxWDsFuzLOsPPfJg,1065
+langroid-0.26.0.dist-info/METADATA,sha256=E7vU0iufbOSBvgaDtCUEUgEquSch0eMfWsYyXtTJIE0,57519
+langroid-0.26.0.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
+langroid-0.26.0.dist-info/RECORD,,

pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "langroid"
-version = "0.24.1"
+version = "0.26.0"
 description = "Harness LLMs with Multi-Agent Programming"
 authors = ["Prasad Chalasani <pchalasani@gmail.com>"]
 readme = "README.md"
@@ -22,7 +22,7 @@ pymysql = {version = "^1.1.0", optional = true}
 meilisearch-python-sdk = {version="^2.2.3", optional=true}
 litellm = {version = "^1.30.1", optional = true}
 metaphor-python = {version = "^0.1.23", optional = true}
-chainlit = {version = "1.1.202", optional = true}
+chainlit = {version = "^1.3.2", optional = true}
 python-socketio = {version="^5.11.0", optional=true}
 neo4j = {version = "^5.14.1", optional = true}
 huggingface-hub = {version="^0.21.2", optional=true}
@@ -242,7 +242,7 @@ lint.select = [
 lint.exclude = ["docs/**", ".venv", "venv", "examples/**", "examples_dev", "langroid/utils/web", "notebooks", "__init__.py", "langroid/embedding_models/protoc/*"]
 lint.fixable = ["A", "B", "C", "D", "E", "F", "G", "I", "N", "Q", "S", "T", "W", "ANN", "ARG", "BLE", "COM", "DJ", "DTZ", "EM", "ERA", "EXE", "FBT", "ICN", "INP", "ISC", "NPY", "PD", "PGH", "PIE", "PL", "PT", "PTH", "PYI", "RET", "RSE", "RUF", "SIM", "SLF", "TCH", "TID", "TRY", "UP", "YTT"]
 lint.unfixable = []
-lint.extend-ignore = ["F821","F401"]
+lint.extend-ignore = ["F821", "F401"]
 
 [tool.pytest.ini_options]
 filterwarnings = ["ignore::DeprecationWarning"]