langroid 0.1.250__tar.gz → 0.1.252__tar.gz

{langroid-0.1.250 → langroid-0.1.252}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: langroid
-Version: 0.1.250
+Version: 0.1.252
 Summary: Harness LLMs with Multi-Agent Programming
 License: MIT
 Author: Prasad Chalasani

{langroid-0.1.250 → langroid-0.1.252}/langroid/__init__.py

@@ -41,7 +41,7 @@ from .agent.chat_agent import (
     ChatAgentConfig,
 )
 
-from .agent.task import Task
+from .agent.task import Task, TaskConfig
 
 try:
     from .agent.callbacks.chainlit import (
@@ -64,8 +64,11 @@ from .mytypes import (
     Entity,
 )
 
+from .exceptions import InfiniteLoopException
+
 __all__ = [
     "mytypes",
+    "exceptions",
     "utils",
     "parsing",
     "prompts",
@@ -82,6 +85,7 @@ __all__ = [
     "ChatDocument",
     "ChatDocMetaData",
     "Task",
+    "TaskConfig",
     "DocMetaData",
     "Document",
     "Entity",
@@ -89,6 +93,7 @@ __all__ = [
     "run_batch_tasks",
     "llm_response_batch",
     "agent_response_batch",
+    "InfiniteLoopException",
 ]
 if chainlit_available:
     __all__.extend(

{langroid-0.1.250 → langroid-0.1.252}/langroid/agent/base.py

@@ -2,6 +2,7 @@ import asyncio
 import inspect
 import json
 import logging
+import re
 from abc import ABC
 from contextlib import ExitStack
 from types import SimpleNamespace
@@ -19,7 +20,7 @@ from typing import (
     no_type_check,
 )
 
-from pydantic import BaseSettings, ValidationError
+from pydantic import BaseSettings, ValidationError, validator
 from rich import print
 from rich.console import Console
 from rich.markup import escape
@@ -64,6 +65,15 @@ class AgentConfig(BaseSettings):
     prompts: Optional[PromptsConfig] = PromptsConfig()
     show_stats: bool = True  # show token usage/cost stats?
 
+    @validator("name")
+    def check_name_alphanum(cls, v: str) -> str:
+        if not re.match(r"^[a-zA-Z0-9_-]+$", v):
+            raise ValueError(
+                "The name must only contain alphanumeric characters, "
+                "underscores, or hyphens, with no spaces"
+            )
+        return v
+
 
 def noop_fn(*args: List[Any], **kwargs: Dict[str, Any]) -> None:
     pass
@@ -87,6 +97,7 @@ class Agent(ABC):
         self.llm_tools_map: Dict[str, Type[ToolMessage]] = {}
         self.llm_tools_handled: Set[str] = set()
         self.llm_tools_usable: Set[str] = set()
+        self.interactive: bool | None = None
         self.total_llm_token_cost = 0.0
         self.total_llm_token_usage = 0
         self.token_stats_str = ""
@@ -223,8 +234,8 @@ class Agent(ABC):
         ):
             setattr(self, tool, lambda obj: obj.response(self))
 
-        if hasattr(message_class, "handle_message_fallback") and inspect.isfunction(
-            message_class.handle_message_fallback
+        if hasattr(message_class, "handle_message_fallback") and (
+            inspect.isfunction(message_class.handle_message_fallback)
         ):
             setattr(
                 self,
@@ -279,9 +290,9 @@ class Agent(ABC):
         ]
         return "\n\n".join(sample_convo)
 
-    def agent_response_template(self) -> ChatDocument:
+    def create_agent_response(self, content: str | None = None) -> ChatDocument:
         """Template for agent_response."""
-        return self._response_template(Entity.AGENT)
+        return self._response_template(Entity.AGENT, content)
 
     async def agent_response_async(
         self,
@@ -342,19 +353,19 @@ class Agent(ABC):
             ),
         )
 
-    def _response_template(self, e: Entity) -> ChatDocument:
+    def _response_template(self, e: Entity, content: str | None = None) -> ChatDocument:
         """Template for response from entity `e`."""
         return ChatDocument(
-            content="",
+            content=content or "",
             tool_messages=[],
             metadata=ChatDocMetaData(
                 source=e, sender=e, sender_name=self.config.name, tool_ids=[]
             ),
         )
 
-    def user_response_template(self) -> ChatDocument:
+    def create_user_response(self, content: str | None = None) -> ChatDocument:
         """Template for user_response."""
-        return self._response_template(Entity.USER)
+        return self._response_template(Entity.USER, content)
 
     async def user_response_async(
         self,
@@ -377,11 +388,21 @@ class Agent(ABC):
             (str) User response, packaged as a ChatDocument
 
         """
-        if self.default_human_response is not None:
+
+        # 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
+        )
+
+        interactive = (
+            self.interactive if self.interactive is not None else settings.interactive
+        )
+        if self.default_human_response is not None and not need_human_response:
             # useful for automated testing
             user_msg = self.default_human_response
-        elif not settings.interactive:
-            user_msg = ""
+        elif not interactive and not need_human_response:
+            return None
         else:
             if self.callbacks.get_user_response is not None:
                 # ask user with empty prompt: no need for prompt
@@ -440,9 +461,9 @@ class Agent(ABC):
 
         return True
 
-    def llm_response_template(self) -> ChatDocument:
+    def create_llm_response(self, content: str | None = None) -> ChatDocument:
         """Template for llm_response."""
-        return self._response_template(Entity.LLM)
+        return self._response_template(Entity.LLM, content)
 
     @no_type_check
     async def llm_response_async(
@@ -736,6 +757,24 @@ class Agent(ABC):
 
     def _get_one_tool_message(self, json_str: str) -> Optional[ToolMessage]:
         json_data = json.loads(json_str)
+        # check if the json_data contains a "properties" field
+        # which further contains the actual tool-call
+        # (some weak LLMs do this). E.g. gpt-4o sometimes generates this:
+        # TOOL: {
+        #     "type": "object",
+        #     "properties": {
+        #         "request": "square",
+        #         "number": 9
+        #     },
+        #     "required": [
+        #         "number",
+        #         "request"
+        #     ]
+        # }
+
+        properties = json_data.get("properties")
+        if properties is not None:
+            json_data = properties
         request = json_data.get("request")
         if (
             request is None

{langroid-0.1.250 → langroid-0.1.252}/langroid/agent/chat_agent.py

@@ -273,10 +273,11 @@ class ChatAgent(Agent):
                 example = "" if self.config.use_tools else (msg_cls.usage_example())
                 if example != "":
                     example = "EXAMPLE: " + example
+                class_instructions = msg_cls.instructions()
                 guidance = (
                     ""
-                    if msg_cls.instructions() == ""
-                    else ("GUIDANCE: " + msg_cls.instructions())
+                    if class_instructions == ""
+                    else ("GUIDANCE: " + class_instructions)
                 )
                 if guidance == "" and example == "":
                     continue
@@ -783,23 +784,20 @@ class ChatAgent(Agent):
         if self.llm is None:
             return
         if not citation_only and (not self.llm.get_stream() or is_cached):
-            # We expect response to be LLMResponse in this context
-            if not isinstance(response, LLMResponse):
-                raise ValueError(
-                    "Expected response to be LLMResponse, but got "
-                    f"{type(response)} instead."
-                )
             # We would have already displayed the msg "live" ONLY if
             # 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 is_cached else ""
             if not settings.quiet:
+                chat_doc = (
+                    response
+                    if isinstance(response, ChatDocument)
+                    else ChatDocument.from_LLMResponse(response, displayed=True)
+                )
                 print(cached + "[green]" + escape(str(response)))
                 self.callbacks.show_llm_response(
                     content=str(response),
-                    is_tool=self.has_tool_message_attempt(
-                        ChatDocument.from_LLMResponse(response, displayed=True),
-                    ),
+                    is_tool=self.has_tool_message_attempt(chat_doc),
                     cached=is_cached,
                 )
         if isinstance(response, LLMResponse):

{langroid-0.1.250 → langroid-0.1.252}/langroid/agent/special/lance_rag/critic_agent.py

@@ -70,13 +70,19 @@ class QueryPlanCriticConfig(LanceQueryPlanAgentConfig):
       plan execution FAILED, and your feedback should say INVALID along 
       with the ERROR message, `suggested_fix` that aims to help the assistant 
       fix the problem (or simply equals "address the the error shown in feedback")
+    - Ask yourself, is the ANSWER in the expected form, e.g. 
+        if the question is asking for the name of an ENTITY with max SIZE,
+        then the answer should be the ENTITY name, NOT the SIZE!! 
     - If the ANSWER is in the expected form, then the QUERY PLAN is likely VALID,
       and your feedback should say VALID, with empty `suggested_fix`.
+      ===> HOWEVER!!! Watch out for a spurious correct-looking answer, for EXAMPLE:
+      the query was to find the ENTITY with a maximum SIZE, 
+      but the dataframe calculation is find the SIZE, NOT the ENTITY!!      
     - If the ANSWER is {NO_ANSWER} or of the wrong form, 
       then try to DIAGNOSE the problem IN THE FOLLOWING ORDER:
       - DATAFRAME CALCULATION -- is it doing the right thing?
         Is it finding the Index of a row instead of the value in a column?
-        Or another example: mmaybe it is finding the maximum population
+        Or another example: maybe it is finding the maximum population
            rather than the CITY with the maximum population?
         If you notice a problem with the DATAFRAME CALCULATION, then
         ONLY SUBMIT FEEDBACK ON THE DATAFRAME CALCULATION, and DO NOT

{langroid-0.1.250 → langroid-0.1.252}/langroid/agent/special/lance_rag/query_planner_agent.py

@@ -195,7 +195,7 @@ class LanceQueryPlanAgent(ChatAgent):
                 plan=self.curr_query_plan,
                 answer=self.result,
             )
-            response_tmpl = self.agent_response_template()
+            response_tmpl = self.create_agent_response()
             # ... add the QueryPlanAnswerTool to the response
             # (Notice how the Agent is directly sending a tool, not the LLM)
             response_tmpl.tool_messages = [query_plan_answer_tool]