langroid 0.16.2__tar.gz → 0.16.4__tar.gz

{langroid-0.16.2 → langroid-0.16.4}/PKG-INFO

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

{langroid-0.16.2 → langroid-0.16.4}/langroid/language_models/base.py

@@ -219,6 +219,8 @@ class LLMMessage(BaseModel):
         # in case has_system_role is False
         if not has_system_role and "role" in d and d["role"] == "system":
             d["role"] = "user"
+            if "content" in d:
+                d["content"] = "[ADDITIONAL SYSTEM MESSAGE:]\n\n" + d["content"]
         # drop None values since API doesn't accept them
         dict_no_none = {k: v for k, v in d.items() if v is not None}
         if "name" in dict_no_none and dict_no_none["name"] == "":

{langroid-0.16.2 → langroid-0.16.4}/langroid/language_models/openai_gpt.py

@@ -1123,8 +1123,13 @@ class OpenAIGPT(LanguageModel):
     ) -> LLMTokenUsage:
         """
         Extracts token usage from ``response`` and computes cost, only when NOT
-        in streaming mode, since the LLM API (OpenAI currently) does not populate the
-        usage fields in streaming mode. In streaming mode, these are set to zero for
+        in streaming mode, since the LLM API (OpenAI currently) was not
+        populating the usage fields in streaming mode (but as of Sep 2024, streaming
+        responses include  usage info as well, so we should update the code
+        to directly use usage information from the streaming response, which is more
+        accurate, esp with "thinking" LLMs like o1 series which consume
+        thinking tokens).
+        In streaming mode, these are set to zero for
         now, and will be updated later by the fn ``update_token_usage``.
         """
         cost = 0.0

{langroid-0.16.2 → langroid-0.16.4}/langroid/parsing/parse_json.py

@@ -4,6 +4,7 @@ from datetime import datetime
 from typing import Any, Dict, Iterator, List, Union
 
 import yaml
+from json_repair import repair_json
 from pyparsing import nestedExpr, originalTextFor
 
 
@@ -47,34 +48,6 @@ def get_json_candidates(s: str) -> List[str]:
         return []
 
 
-def add_quotes(s: str) -> str:
-    """
-    Replace accidentally un-quoted string-like keys and values in a potential json str.
-    Intended to handle cases where a weak LLM may produce a JSON-like string
-    containing, e.g. "rent": DO-NOT-KNOW, where it "forgot" to put quotes on the value,
-    or city: "New York" where it "forgot" to put quotes on the key.
-    It will even handle cases like 'address: do not know'.
-
-    Got this fiendishly clever solution from
-    https://stackoverflow.com/a/66053900/10940584
-    Far better/safer than trying to do it with regexes.
-
-    Args:
-    - s (str): The potential JSON string to parse.
-
-    Returns:
-    - str: The (potential) JSON string with un-quoted string-like values
-        replaced by quoted values.
-    """
-    if is_valid_json(s):
-        return s
-    try:
-        dct = yaml.load(s, yaml.SafeLoader)
-        return json.dumps(dct)
-    except Exception:
-        return s
-
-
 def parse_imperfect_json(json_string: str) -> Union[Dict[str, Any], List[Any]]:
     if not json_string.strip():
         raise ValueError("Empty string is not valid JSON")
@@ -89,7 +62,7 @@ def parse_imperfect_json(json_string: str) -> Union[Dict[str, Any], List[Any]]:
 
     # If ast.literal_eval fails or returns non-dict/list, try json.loads
     try:
-        json_string = add_quotes(json_string)
+        json_string = repair_json(json_string)
         result = json.loads(json_string)
         if isinstance(result, (dict, list)):
             return result
@@ -102,39 +75,33 @@ def parse_imperfect_json(json_string: str) -> Union[Dict[str, Any], List[Any]]:
         except yaml.YAMLError:
             pass
 
-    try:
-        # last resort: try to repair the json using a lib
-        from json_repair import repair_json
-
-        repaired_json = repair_json(json_string)
-        result = json.loads(repaired_json)
-        if isinstance(result, (dict, list)):
-            return result
-    except Exception:
-        pass
-
     # If all methods fail, raise ValueError
     raise ValueError(f"Unable to parse as JSON: {json_string}")
 
 
-def repair_newlines(s: str) -> str:
+def try_repair_json_yaml(s: str) -> str | None:
     """
-    Attempt to load as json, and if it fails, try with newlines replaced by space.
-    Intended to handle cases where weak LLMs produce JSON-like strings where
-    some string-values contain explicit newlines, e.g.:
-    {"text": "This is a text\n with a newline"}
-    These would not be valid JSON, so we try to clean them up here.
+    Attempt to load as json, and if it fails, try repairing the JSON.
+    If that fails, replace any \n with space as a last resort.
+    NOTE - replacing \n with space will result in format loss,
+    which may matter in generated code (e.g. python, toml, etc)
     """
-    try:
-        json.loads(s)
-        return s
-    except Exception:
+    s_repaired = repair_json(s)
+    if s_repaired != "":
+        return s_repaired  # type: ignore
+    else:
         try:
-            s = s.replace("\n", " ")
-            json.loads(s)
-            return s
-        except Exception:
+            yaml_result = yaml.safe_load(s)
+            if isinstance(yaml_result, dict):
+                return json.dumps(yaml_result)
+        except yaml.YAMLError:
+            pass
+        # If it still fails, replace any \n with space as a last resort
+        s = s.replace("\n", " ")
+        if is_valid_json(s):
             return s
+        else:
+            return None  # all failed
 
 
 def extract_top_level_json(s: str) -> List[str]:
@@ -148,18 +115,9 @@ def extract_top_level_json(s: str) -> List[str]:
     """
     # Find JSON object and array candidates
     json_candidates = get_json_candidates(s)
+    maybe_repaired_jsons = map(try_repair_json_yaml, json_candidates)
 
-    normalized_candidates = [
-        candidate.replace("\\{", "{").replace("\\}", "}").replace("\\_", "_")
-        for candidate in json_candidates
-    ]
-    candidates = [add_quotes(candidate) for candidate in normalized_candidates]
-    candidates = [repair_newlines(candidate) for candidate in candidates]
-    top_level_jsons = [
-        candidate for candidate in candidates if is_valid_json(candidate)
-    ]
-
-    return top_level_jsons
+    return [candidate for candidate in maybe_repaired_jsons if candidate is not None]
 
 
 def top_level_json_field(s: str, f: str) -> Any:

{langroid-0.16.2 → langroid-0.16.4}/langroid/utils/logging.py

@@ -4,6 +4,7 @@ from typing import no_type_check
 
 import colorlog
 from rich.console import Console
+from rich.markup import escape
 
 
 # Define a function to set up the colored logger
@@ -129,6 +130,6 @@ class RichFileLogger:
         with open(self.log_file, "a") as f:
             if self.color:
                 console = Console(file=f, force_terminal=True, width=200)
-                console.print(message)
+                console.print(escape(message))
             else:
                 print(message, file=f)

{langroid-0.16.2 → langroid-0.16.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "langroid"
-version = "0.16.2"
+version = "0.16.4"
 description = "Harness LLMs with Multi-Agent Programming"
 authors = ["Prasad Chalasani <pchalasani@gmail.com>"]
 readme = "README.md"