langroid 0.1.139__py3-none-any.whl → 0.1.219__py3-none-any.whl

langroid/__init__.py

@@ -20,9 +20,79 @@ from .agent.base import (
     AgentConfig,
 )
 
+from .agent.batch import (
+    run_batch_tasks,
+    llm_response_batch,
+    agent_response_batch,
+)
+
+from .agent.chat_document import (
+    ChatDocument,
+    ChatDocMetaData,
+)
+
+from .agent.tool_message import (
+    ToolMessage,
+)
+
 from .agent.chat_agent import (
     ChatAgent,
     ChatAgentConfig,
 )
 
 from .agent.task import Task
+
+try:
+    from .agent.callbacks.chainlit import (
+        ChainlitAgentCallbacks,
+        ChainlitTaskCallbacks,
+        ChainlitCallbackConfig,
+    )
+
+    chainlit_available = True
+    ChainlitAgentCallbacks
+    ChainlitTaskCallbacks
+    ChainlitCallbackConfig
+except ImportError:
+    chainlit_available = False
+
+
+from .mytypes import (
+    DocMetaData,
+    Document,
+    Entity,
+)
+
+__all__ = [
+    "mytypes",
+    "utils",
+    "parsing",
+    "prompts",
+    "cachedb",
+    "language_models",
+    "embedding_models",
+    "vector_store",
+    "agent",
+    "Agent",
+    "AgentConfig",
+    "ChatAgent",
+    "ChatAgentConfig",
+    "ChatDocument",
+    "ChatDocMetaData",
+    "Task",
+    "DocMetaData",
+    "Document",
+    "Entity",
+    "ToolMessage",
+    "run_batch_tasks",
+    "llm_response_batch",
+    "agent_response_batch",
+]
+if chainlit_available:
+    __all__.extend(
+        [
+            "ChainlitAgentCallbacks",
+            "ChainlitTaskCallbacks",
+            "ChainlitCallbackConfig",
+        ]
+    )

langroid/agent/__init__.py

@@ -13,6 +13,28 @@ from . import base
 from . import chat_document
 from . import chat_agent
 from . import task
+from . import batch
 from . import tool_message
 from . import tools
 from . import special
+
+__all__ = [
+    "Agent",
+    "AgentConfig",
+    "ChatDocAttachment",
+    "ChatDocMetaData",
+    "ChatDocLoggerFields",
+    "ChatDocument",
+    "ChatAgent",
+    "ChatAgentConfig",
+    "ToolMessage",
+    "Task",
+    "base",
+    "chat_document",
+    "chat_agent",
+    "task",
+    "batch",
+    "tool_message",
+    "tools",
+    "special",
+]

langroid/agent/base.py

@@ -4,6 +4,7 @@ import json
 import logging
 from abc import ABC
 from contextlib import ExitStack
+from types import SimpleNamespace
 from typing import (
     Any,
     Callable,
@@ -21,6 +22,7 @@ from typing import (
 from pydantic import BaseSettings, ValidationError
 from rich import print
 from rich.console import Console
+from rich.markup import escape
 from rich.prompt import Prompt
 
 from langroid.agent.chat_document import ChatDocMetaData, ChatDocument
@@ -35,11 +37,12 @@ from langroid.language_models.base import (
 )
 from langroid.language_models.openai_gpt import OpenAIGPTConfig
 from langroid.mytypes import Entity
-from langroid.parsing.json import extract_top_level_json
+from langroid.parsing.parse_json import extract_top_level_json
 from langroid.parsing.parser import Parser, ParsingConfig
 from langroid.prompts.prompts_config import PromptsConfig
 from langroid.utils.configuration import settings
 from langroid.utils.constants import NO_ANSWER
+from langroid.utils.output import status
 from langroid.vector_store.base import VectorStore, VectorStoreConfig
 
 console = Console(quiet=settings.quiet)
@@ -62,6 +65,10 @@ class AgentConfig(BaseSettings):
     show_stats: bool = True  # show token usage/cost stats?
 
 
+def noop_fn(*args: List[Any], **kwargs: Dict[str, Any]) -> None:
+    pass
+
+
 class Agent(ABC):
     """
     An Agent is an abstraction that encapsulates mainly two components:
@@ -73,7 +80,7 @@ class Agent(ABC):
     information about any tool/function-calling messages that have been defined.
     """
 
-    def __init__(self, config: AgentConfig):
+    def __init__(self, config: AgentConfig = AgentConfig()):
         self.config = config
         self.lock = asyncio.Lock()  # for async access to update self.llm.usage_cost
         self.dialog: List[Tuple[str, str]] = []  # seq of LLM (prompt, response) tuples
@@ -90,6 +97,18 @@ class Agent(ABC):
         self.parser: Optional[Parser] = (
             Parser(config.parsing) if config.parsing else None
         )
+        self.callbacks = SimpleNamespace(
+            start_llm_stream=lambda: noop_fn,
+            cancel_llm_stream=noop_fn,
+            finish_llm_stream=noop_fn,
+            show_llm_response=noop_fn,
+            show_agent_response=noop_fn,
+            get_user_response=None,
+            get_last_step=noop_fn,
+            set_parent_agent=noop_fn,
+            show_error_message=noop_fn,
+            show_start_response=noop_fn,
+        )
 
     def entity_responders(
         self,
@@ -253,6 +272,10 @@ class Agent(ABC):
         ]
         return "\n\n".join(sample_convo)
 
+    def agent_response_template(self) -> ChatDocument:
+        """Template for agent_response."""
+        return self._response_template(Entity.AGENT)
+
     async def agent_response_async(
         self,
         msg: Optional[str | ChatDocument] = None,
@@ -290,6 +313,11 @@ class Agent(ABC):
         if not settings.quiet:
             console.print(f"[red]{self.indent}", end="")
             print(f"[red]Agent: {results}")
+            maybe_json = len(extract_top_level_json(results)) > 0
+            self.callbacks.show_agent_response(
+                content=results,
+                language="json" if maybe_json else "text",
+            )
         sender_name = self.config.name
         if isinstance(msg, ChatDocument) and msg.function_call is not None:
             # if result was from handling an LLM `function_call`,
@@ -307,6 +335,20 @@ class Agent(ABC):
             ),
         )
 
+    def _response_template(self, e: Entity) -> ChatDocument:
+        """Template for response from entity `e`."""
+        return ChatDocument(
+            content="",
+            tool_messages=[],
+            metadata=ChatDocMetaData(
+                source=e, sender=e, sender_name=self.config.name, tool_ids=[]
+            ),
+        )
+
+    def user_response_template(self) -> ChatDocument:
+        """Template for user_response."""
+        return self._response_template(Entity.USER)
+
     async def user_response_async(
         self,
         msg: Optional[str | ChatDocument] = None,
@@ -334,11 +376,18 @@ class Agent(ABC):
         elif not settings.interactive:
             user_msg = ""
         else:
-            user_msg = Prompt.ask(
-                f"[blue]{self.indent}Human "
-                "(respond or q, x to exit current level, "
-                f"or hit enter to continue)\n{self.indent}",
-            ).strip()
+            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}Human "
+                    "(respond or q, x to exit current level, "
+                    f"or hit enter to continue)\n{self.indent}",
+                ).strip()
 
         tool_ids = []
         if msg is not None and isinstance(msg, ChatDocument):
@@ -377,13 +426,6 @@ class Agent(ABC):
         if self.llm is None:
             return False
 
-        if isinstance(message, ChatDocument) and message.function_call is not None:
-            # LLM should not handle `function_call` messages,
-            # EVEN if message.function_call is not a legit function_call
-            # The OpenAI API raises error if there is a message in history
-            # from a non-Assistant role, with a `function_call` in it
-            return False
-
         if message is not None and len(self.get_tool_messages(message)) > 0:
             # if there is a valid "tool" message (either JSON or via `function_call`)
             # then LLM cannot respond to it
@@ -391,6 +433,10 @@ class Agent(ABC):
 
         return True
 
+    def llm_response_template(self) -> ChatDocument:
+        """Template for llm_response."""
+        return self._response_template(Entity.LLM)
+
     @no_type_check
     async def llm_response_async(
         self,
@@ -434,7 +480,7 @@ class Agent(ABC):
             # streaming was enabled, AND we did not find a cached response.
             # If we are here, it means the response has not yet been displayed.
             cached = f"[red]{self.indent}(cached)[/red]" if response.cached else ""
-            print(cached + "[green]" + response.message)
+            print(cached + "[green]" + escape(response.message))
         async with self.lock:
             self.update_token_usage(
                 response,
@@ -472,7 +518,7 @@ class Agent(ABC):
         with ExitStack() as stack:  # for conditionally using rich spinner
             if not self.llm.get_stream():
                 # show rich spinner only if not streaming!
-                cm = console.status("LLM responding to message...")
+                cm = status("LLM responding to message...")
                 stack.enter_context(cm)
             output_len = self.config.llm.max_output_tokens
             if (
@@ -507,7 +553,7 @@ class Agent(ABC):
             # If we are here, it means the response has not yet been displayed.
             cached = f"[red]{self.indent}(cached)[/red]" if response.cached else ""
             console.print(f"[green]{self.indent}", end="")
-            print(cached + "[green]" + response.message)
+            print(cached + "[green]" + escape(response.message))
         self.update_token_usage(
             response,
             prompt,
@@ -520,17 +566,38 @@ class Agent(ABC):
         cdoc.metadata.tool_ids = [] if isinstance(msg, str) else msg.metadata.tool_ids
         return cdoc
 
+    def has_tool_message_attempt(self, msg: str | ChatDocument | None) -> bool:
+        """Check whether msg contains a Tool/fn-call attempt (by the LLM)"""
+        if msg is None:
+            return False
+        try:
+            tools = self.get_tool_messages(msg)
+            return len(tools) > 0
+        except ValidationError:
+            # there is a tool/fn-call attempt but had a validation error,
+            # so we still consider this a tool message "attempt"
+            return True
+        return False
+
     def get_tool_messages(self, msg: str | ChatDocument) -> List[ToolMessage]:
         if isinstance(msg, str):
             return self.get_json_tool_messages(msg)
+        if len(msg.tool_messages) > 0:
+            # We've already found tool_messages
+            # (either via OpenAI Fn-call or Langroid-native ToolMessage)
+            return msg.tool_messages
         assert isinstance(msg, ChatDocument)
         # when `content` is non-empty, we assume there will be no `function_call`
         if msg.content != "":
-            return self.get_json_tool_messages(msg.content)
+            tools = self.get_json_tool_messages(msg.content)
+            msg.tool_messages = tools
+            return tools
 
         # otherwise, we look for a `function_call`
         fun_call_cls = self.get_function_call_class(msg)
-        return [fun_call_cls] if fun_call_cls is not None else []
+        tools = [fun_call_cls] if fun_call_cls is not None else []
+        msg.tool_messages = tools
+        return tools
 
     def get_json_tool_messages(self, input_str: str) -> List[ToolMessage]:
         """
@@ -554,7 +621,17 @@ class Agent(ABC):
         tool_name = msg.function_call.name
         tool_msg = msg.function_call.arguments or {}
         if tool_name not in self.llm_tools_handled:
-            raise ValueError(f"{tool_name} is not a valid function_call!")
+            logger.warning(
+                f"""
+                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,
+                (in which case you may need to adjust your LLM instructions),
+                or you need to enable this agent to handle this fn-call.
+                """
+            )
+            return None
         tool_class = self.llm_tools_map[tool_name]
         tool_msg.update(dict(request=tool_name))
         tool = tool_class.parse_obj(tool_msg)
@@ -573,7 +650,7 @@ class Agent(ABC):
         """
         tool_name = cast(ToolMessage, ve.model).default_value("request")
         bad_field_errors = "\n".join(
-            [f"{e['loc'][0]}: {e['msg']}" for e in ve.errors() if "loc" in e]
+            [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 
@@ -617,7 +694,7 @@ class Agent(ABC):
 
         results_list = [r for r in results if r is not None]
         if len(results_list) == 0:
-            return self.handle_message_fallback(msg)
+            return None  # self.handle_message_fallback(msg)
         # there was a non-None result
         chat_doc_results = [r for r in results_list if isinstance(r, ChatDocument)]
         if len(chat_doc_results) > 1:
@@ -632,19 +709,13 @@ class Agent(ABC):
 
         str_doc_results = [r for r in results_list if isinstance(r, str)]
         final = "\n".join(str_doc_results)
-        if final == "":
-            logger.warning(
-                """final result from a tool handler should not be empty str, since  
-             it would be considered an invalid result and other responders 
-             will be tried, and we may not necessarily want that"""
-            )
         return final
 
     def handle_message_fallback(
         self, msg: str | ChatDocument
     ) -> str | ChatDocument | None:
         """
-        Fallback method to handle possible "tool" msg if not other method applies
+        Fallback method to handle possible "tool" msg if no other method applies
         or if an error is thrown.
         This method can be overridden by subclasses.
 
@@ -659,7 +730,11 @@ class Agent(ABC):
     def _get_one_tool_message(self, json_str: str) -> Optional[ToolMessage]:
         json_data = json.loads(json_str)
         request = json_data.get("request")
-        if request is None or request not in self.llm_tools_handled:
+        if (
+            request is None
+            or not (isinstance(request, str))
+            or request not in self.llm_tools_handled
+        ):
             return None
 
         message_class = self.llm_tools_map.get(request)
@@ -702,7 +777,13 @@ class Agent(ABC):
         if isinstance(prompt, str):
             return self.parser.num_tokens(prompt)
         else:
-            return sum([self.parser.num_tokens(m.content) for m in prompt])
+            return sum(
+                [
+                    self.parser.num_tokens(m.content)
+                    + self.parser.num_tokens(str(m.function_call or ""))
+                    for m in prompt
+                ]
+            )
 
     def _get_response_stats(
         self, chat_length: int, tot_cost: float, response: LLMResponse
@@ -727,11 +808,17 @@ class Agent(ABC):
             assert isinstance(self.llm, LanguageModel)
             context_length = self.llm.chat_context_length()
             max_out = self.config.llm.max_output_tokens
+
+            llm_model = (
+                "no-LLM" if self.config.llm is None else self.llm.config.chat_model
+            )
+
             return (
-                f"[bold]Stats:[/bold] [magenta] N_MSG={chat_length}, "
+                f"[bold]Stats:[/bold] [magenta]N_MSG={chat_length}, "
                 f"TOKENS: in={in_tokens}, out={out_tokens}, "
                 f"max={max_out}, ctx={context_length}, "
-                f"COST: now=${llm_response_cost}, cumul=${cumul_cost}[/magenta]"
+                f"COST: now=${llm_response_cost}, cumul=${cumul_cost} "
+                f"[bold]({llm_model})[/bold][/magenta]"
             )
         return ""