langroid 0.42.8__tar.gz → 0.42.10__tar.gz

{langroid-0.42.8 → langroid-0.42.10}/.gitignore

@@ -135,6 +135,8 @@ dmypy.json
 # Pyre type checker
 .pyre/
 
+# Chainlit
+.chainlit/
 
 .vscode
 

{langroid-0.42.8 → langroid-0.42.10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: langroid
-Version: 0.42.8
+Version: 0.42.10
 Summary: Harness LLMs with Multi-Agent Programming
 Author-email: Prasad Chalasani <pchalasani@gmail.com>
 License: MIT

{langroid-0.42.8 → langroid-0.42.10}/langroid/agent/base.py

@@ -1148,7 +1148,9 @@ class Agent(ABC):
             and msg.function_call is None
         ):
 
-            tools = self.get_formatted_tool_messages(msg.content)
+            tools = self.get_formatted_tool_messages(
+                msg.content, from_llm=msg.metadata.sender == Entity.LLM
+            )
             msg.all_tool_messages = tools
             # filter for actually handle-able tools, and recipient is this agent
             my_tools = [t for t in tools if self._tool_recipient_match(t)]
@@ -1177,7 +1179,9 @@ class Agent(ABC):
         else:
             return my_tools
 
-    def get_formatted_tool_messages(self, input_str: str) -> List[ToolMessage]:
+    def get_formatted_tool_messages(
+        self, input_str: str, from_llm: bool = True
+    ) -> List[ToolMessage]:
         """
         Returns ToolMessage objects (tools) corresponding to
         tool-formatted substrings, if any.
@@ -1190,6 +1194,8 @@ class Agent(ABC):
 
         Args:
             input_str (str): input string, typically a message sent by an LLM
+            from_llm (bool): whether the input was generated by the LLM. If so,
+                we track malformed tool calls.
 
         Returns:
             List[ToolMessage]: list of ToolMessage objects
@@ -1203,7 +1209,7 @@ class Agent(ABC):
             if not is_json:
                 return []
 
-        results = [self._get_one_tool_message(j, is_json) for j in substrings]
+        results = [self._get_one_tool_message(j, is_json, from_llm) for j in substrings]
         valid_results = [r for r in results if r is not None]
         # If any tool is correctly formed we do not set the flag
         if len(valid_results) > 0:
@@ -1219,6 +1225,7 @@ class Agent(ABC):
             return None
         tool_name = msg.function_call.name
         tool_msg = msg.function_call.arguments or {}
+        self.tool_error = False
         if tool_name not in self.llm_tools_handled:
             logger.warning(
                 f"""
@@ -1230,10 +1237,12 @@ class Agent(ABC):
                 or you need to enable this agent to handle this fn-call.
                 """
             )
-            if tool_name not in self.all_llm_tools_known:
+            if (
+                tool_name not in self.all_llm_tools_known
+                and msg.metadata.sender == Entity.LLM
+            ):
                 self.tool_error = True
             return None
-        self.tool_error = False
         tool_class = self.llm_tools_map[tool_name]
         tool_msg.update(dict(request=tool_name))
         tool = tool_class.parse_obj(tool_msg)
@@ -1272,8 +1281,9 @@ class Agent(ABC):
             tool = tool_class.parse_obj(tool_msg)
             tool.id = tc.id or ""
             tools.append(tool)
-        # When no tool is valid, set the recovery flag
-        self.tool_error = all_errors
+        # When no tool is valid and the message was produced
+        # by the LLM, set the recovery flag
+        self.tool_error = all_errors and msg.metadata.sender == Entity.LLM
         return tools
 
     def tool_validation_error(self, ve: ValidationError) -> str:
@@ -1508,7 +1518,7 @@ class Agent(ABC):
         return None
 
     def _get_one_tool_message(
-        self, tool_candidate_str: str, is_json: bool = True
+        self, tool_candidate_str: str, is_json: bool = True, from_llm: bool = True
     ) -> Optional[ToolMessage]:
         """
         Parse the tool_candidate_str into ANY ToolMessage KNOWN to agent --
@@ -1545,7 +1555,7 @@ class Agent(ABC):
         # }
 
         if not isinstance(maybe_tool_dict, dict):
-            self.tool_error = True
+            self.tool_error = from_llm
             return None
 
         properties = maybe_tool_dict.get("properties")
@@ -1593,23 +1603,23 @@ class Agent(ABC):
             if len(candidate_tools) == 1:
                 return candidate_tools[0]
             else:
-                self.tool_error = True
+                self.tool_error = from_llm
                 return None
 
         if not isinstance(request, str) or request not in self.all_llm_tools_known:
-            self.tool_error = True
+            self.tool_error = from_llm
             return None
 
         message_class = self.llm_tools_map.get(request)
         if message_class is None:
             logger.warning(f"No message class found for request '{request}'")
-            self.tool_error = True
+            self.tool_error = from_llm
             return None
 
         try:
             message = message_class.parse_obj(maybe_tool_dict)
         except ValidationError as ve:
-            self.tool_error = True
+            self.tool_error = from_llm
             raise ve
         return message
 

{langroid-0.42.8 → langroid-0.42.10}/langroid/agent/chat_agent.py

@@ -1096,7 +1096,10 @@ class ChatAgent(Agent):
                 else:
                     # We will trigger the strict recovery mechanism to force
                     # the LLM to correct its output, allowing us to parse
-                    self.tool_error = True
+                    if isinstance(msg, ChatDocument):
+                        self.tool_error = msg.metadata.sender == Entity.LLM
+                    else:
+                        self.tool_error = True
 
             raise ve
 
@@ -1265,6 +1268,7 @@ class ChatAgent(Agent):
             and self._json_schema_available()
             and self.config.strict_recovery
         ):
+            self.tool_error = False
             AnyTool = self._get_any_tool_message()
             if AnyTool is None:
                 return None
@@ -1352,6 +1356,7 @@ class ChatAgent(Agent):
             and self._json_schema_available()
             and self.config.strict_recovery
         ):
+            self.tool_error = False
             AnyTool = self._get_any_tool_message()
             self.set_output_format(
                 AnyTool,

{langroid-0.42.8 → langroid-0.42.10}/langroid/agent/task.py

@@ -1572,7 +1572,10 @@ class Task:
             response_fn = self._entity_responder_async_map[cast(Entity, e)]
             result = await response_fn(self.pending_message)
             # update result.tool_messages if any
-            if isinstance(result, ChatDocument):
+            if (
+                isinstance(result, ChatDocument)
+                and result.metadata.sender == Entity.LLM
+            ):
                 self.agent.try_get_tool_messages(result)
 
         result_chat_doc = self.agent.to_ChatDocument(

{langroid-0.42.8 → langroid-0.42.10}/langroid/language_models/openai_gpt.py

@@ -85,9 +85,6 @@ GLHF_BASE_URL = "https://glhf.chat/api/openai/v1"
 OLLAMA_API_KEY = "ollama"
 DUMMY_API_KEY = "xxx"
 
-VLLM_API_KEY = os.environ.get("VLLM_API_KEY", DUMMY_API_KEY)
-LLAMACPP_API_KEY = os.environ.get("LLAMA_API_KEY", DUMMY_API_KEY)
-
 
 openai_chat_model_pref_list = [
     OpenAIChatModel.GPT4o,
@@ -215,11 +212,20 @@ class OpenAIGPTConfig(LLMConfig):
     (a) locally-served models behind an OpenAI-compatible API
     (b) non-local models, using a proxy adaptor lib like litellm that provides
         an OpenAI-compatible API.
-    We could rename this class to OpenAILikeConfig.
+    (We could rename this class to OpenAILikeConfig, but we keep it as-is for now)
+
+    Important Note:
+    Due to the `env_prefix = "OPENAI_"` defined below,
+    all of the fields below can be set AND OVERRIDDEN via env vars,
+    # by upper-casing the name and prefixing with OPENAI_, e.g.
+    # OPENAI_MAX_OUTPUT_TOKENS=1000.
+    # If any of these is defined in this way in the environment
+    # (either via explicit setenv or export or via .env file + load_dotenv()),
+    # the environment variable takes precedence over the value in the config.
     """
 
     type: str = "openai"
-    api_key: str = DUMMY_API_KEY  # CAUTION: set this ONLY via env var OPENAI_API_KEY
+    api_key: str = DUMMY_API_KEY
     organization: str = ""
     api_base: str | None = None  # used for local or other non-OpenAI models
     litellm: bool = False  # use litellm api?
@@ -273,11 +279,6 @@ class OpenAIGPTConfig(LLMConfig):
 
         super().__init__(**kwargs)
 
-    # all of the vars above can be set via env vars,
-    # by upper-casing the name and prefixing with OPENAI_, e.g.
-    # OPENAI_MAX_OUTPUT_TOKENS=1000.
-    # This is either done in the .env file, or via an explicit
-    # `export OPENAI_MAX_OUTPUT_TOKENS=1000` or `setenv OPENAI_MAX_OUTPUT_TOKENS 1000`
     class Config:
         env_prefix = "OPENAI_"
 
@@ -417,6 +418,9 @@ class OpenAIGPT(LanguageModel):
         self.supports_json_schema: bool = self.config.supports_json_schema or False
         self.supports_strict_tools: bool = self.config.supports_strict_tools or False
 
+        OPENAI_API_KEY = os.getenv("OPENAI_API_KEY", DUMMY_API_KEY)
+        self.api_key = config.api_key
+
         # if model name starts with "litellm",
         # set the actual model name by stripping the "litellm/" prefix
         # and set the litellm flag to True
@@ -445,12 +449,14 @@ class OpenAIGPT(LanguageModel):
 
             # use api_base from config if set, else fall back on OLLAMA_BASE_URL
             self.api_base = self.config.api_base or OLLAMA_BASE_URL
-            self.api_key = OLLAMA_API_KEY
+            if self.api_key == OPENAI_API_KEY:
+                self.api_key = OLLAMA_API_KEY
             self.config.chat_model = self.config.chat_model.replace("ollama/", "")
         elif self.config.chat_model.startswith("vllm/"):
             self.supports_json_schema = True
             self.config.chat_model = self.config.chat_model.replace("vllm/", "")
-            self.api_key = VLLM_API_KEY
+            if self.api_key == OPENAI_API_KEY:
+                self.api_key = os.environ.get("VLLM_API_KEY", DUMMY_API_KEY)
             self.api_base = self.config.api_base or "http://localhost:8000/v1"
             if not self.api_base.startswith("http"):
                 self.api_base = "http://" + self.api_base
@@ -461,7 +467,8 @@ class OpenAIGPT(LanguageModel):
             self.api_base = self.config.chat_model.split("/", 1)[1]
             if not self.api_base.startswith("http"):
                 self.api_base = "http://" + self.api_base
-            self.api_key = LLAMACPP_API_KEY
+            if self.api_key == OPENAI_API_KEY:
+                self.api_key = os.environ.get("LLAMA_API_KEY", DUMMY_API_KEY)
         else:
             self.api_base = self.config.api_base
             # If api_base is unset we use OpenAI's endpoint, which supports
@@ -483,18 +490,6 @@ class OpenAIGPT(LanguageModel):
         if self.config.use_completion_for_chat:
             self.config.use_chat_for_completion = False
 
-        # NOTE: The api_key should be set in the .env file, or via
-        # an explicit `export OPENAI_API_KEY=xxx` or `setenv OPENAI_API_KEY xxx`
-        # Pydantic's BaseSettings will automatically pick it up from the
-        # .env file
-        # The config.api_key is ignored when not using an OpenAI model
-        if self.is_openai_completion_model() or self.is_openai_chat_model():
-            self.api_key = config.api_key
-            if self.api_key == DUMMY_API_KEY:
-                self.api_key = os.getenv("OPENAI_API_KEY", DUMMY_API_KEY)
-        else:
-            self.api_key = DUMMY_API_KEY
-
         self.is_groq = self.config.chat_model.startswith("groq/")
         self.is_cerebras = self.config.chat_model.startswith("cerebras/")
         self.is_gemini = self.is_gemini_model()
@@ -505,7 +500,8 @@ class OpenAIGPT(LanguageModel):
         if self.is_groq:
             # use groq-specific client
             self.config.chat_model = self.config.chat_model.replace("groq/", "")
-            self.api_key = os.getenv("GROQ_API_KEY", DUMMY_API_KEY)
+            if self.api_key == OPENAI_API_KEY:
+                self.api_key = os.getenv("GROQ_API_KEY", DUMMY_API_KEY)
             self.client = Groq(
                 api_key=self.api_key,
             )
@@ -515,7 +511,8 @@ class OpenAIGPT(LanguageModel):
         elif self.is_cerebras:
             # use cerebras-specific client
             self.config.chat_model = self.config.chat_model.replace("cerebras/", "")
-            self.api_key = os.getenv("CEREBRAS_API_KEY", DUMMY_API_KEY)
+            if self.api_key == OPENAI_API_KEY:
+                self.api_key = os.getenv("CEREBRAS_API_KEY", DUMMY_API_KEY)
             self.client = Cerebras(
                 api_key=self.api_key,
             )
@@ -527,22 +524,26 @@ class OpenAIGPT(LanguageModel):
             # in these cases, there's no specific client: OpenAI python client suffices
             if self.is_gemini:
                 self.config.chat_model = self.config.chat_model.replace("gemini/", "")
-                self.api_key = os.getenv("GEMINI_API_KEY", DUMMY_API_KEY)
+                if self.api_key == OPENAI_API_KEY:
+                    self.api_key = os.getenv("GEMINI_API_KEY", DUMMY_API_KEY)
                 self.api_base = GEMINI_BASE_URL
             elif self.is_glhf:
                 self.config.chat_model = self.config.chat_model.replace("glhf/", "")
-                self.api_key = os.getenv("GLHF_API_KEY", DUMMY_API_KEY)
+                if self.api_key == OPENAI_API_KEY:
+                    self.api_key = os.getenv("GLHF_API_KEY", DUMMY_API_KEY)
                 self.api_base = GLHF_BASE_URL
             elif self.is_openrouter:
                 self.config.chat_model = self.config.chat_model.replace(
                     "openrouter/", ""
                 )
-                self.api_key = os.getenv("OPENROUTER_API_KEY", DUMMY_API_KEY)
+                if self.api_key == OPENAI_API_KEY:
+                    self.api_key = os.getenv("OPENROUTER_API_KEY", DUMMY_API_KEY)
                 self.api_base = OPENROUTER_BASE_URL
             elif self.is_deepseek:
                 self.config.chat_model = self.config.chat_model.replace("deepseek/", "")
                 self.api_base = DEEPSEEK_BASE_URL
-                self.api_key = os.getenv("DEEPSEEK_API_KEY", DUMMY_API_KEY)
+                if self.api_key == OPENAI_API_KEY:
+                    self.api_key = os.getenv("DEEPSEEK_API_KEY", DUMMY_API_KEY)
 
             self.client = OpenAI(
                 api_key=self.api_key,

{langroid-0.42.8 → langroid-0.42.10}/langroid/parsing/document_parser.py

@@ -415,13 +415,15 @@ class DocumentParser(Parser):
             # that it needs to be combined with the next chunk.
             while len(split) > self.config.chunk_size:
                 # pretty formatting of pages (e.g. 1-3, 4, 5-7)
-                pg = "-".join([pages[0], pages[-1]])
+                p_0 = int(pages[0])
+                p_n = int(pages[-1])
+                page_str = f"pages {p_0}-{p_n}" if p_0 != p_n else f"page {p_0}"
                 text = self.tokenizer.decode(split[: self.config.chunk_size])
                 docs.append(
                     Document(
                         content=text,
                         metadata=DocMetaData(
-                            source=f"{self.source} pages {pg}",
+                            source=f"{self.source} {page_str}",
                             is_chunk=True,
                             id=common_id,
                         ),

{langroid-0.42.8 → langroid-0.42.10}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "langroid"
-version = "0.42.8"
+version = "0.42.10"
 authors = [
     {name = "Prasad Chalasani", email = "pchalasani@gmail.com"},
 ]