langroid 0.1.196__tar.gz → 0.1.197__tar.gz

{langroid-0.1.196 → langroid-0.1.197}/PKG-INFO

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

{langroid-0.1.196 → langroid-0.1.197}/langroid/agent/chat_agent.py

@@ -225,14 +225,22 @@ class ChatAgent(Agent):
         enabled_classes: List[Type[ToolMessage]] = list(self.llm_tools_map.values())
         if len(enabled_classes) == 0:
             return "You can ask questions in natural language."
-
         json_instructions = "\n\n".join(
             [
-                msg_cls.json_instructions()
+                msg_cls.json_instructions(tool=self.config.use_tools)
                 for _, msg_cls in enumerate(enabled_classes)
                 if msg_cls.default_value("request") in self.llm_tools_usable
             ]
         )
+        # if any of the enabled classes has json_group_instructions, then use that,
+        # else fall back to ToolMessage.json_group_instructions
+        for msg_cls in enabled_classes:
+            if hasattr(msg_cls, "json_group_instructions") and callable(
+                getattr(msg_cls, "json_group_instructions")
+            ):
+                return msg_cls.json_group_instructions().format(
+                    json_instructions=json_instructions
+                )
         return ToolMessage.json_group_instructions().format(
             json_instructions=json_instructions
         )

{langroid-0.1.196 → langroid-0.1.197}/langroid/agent/chat_document.py

@@ -84,7 +84,7 @@ class ChatDocument(Document):
             json_data = json.loads(j)
             tool = json_data.get("request")
             if tool is not None:
-                tools.append(tool)
+                tools.append(str(tool))
         return tools
 
     def log_fields(self) -> ChatDocLoggerFields:

{langroid-0.1.196 → langroid-0.1.197}/langroid/agent/task.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 import copy
 import logging
+import re
 from collections import Counter
 from types import SimpleNamespace
 from typing import (
@@ -781,17 +782,20 @@ class Task:
         # handle routing instruction in result if any,
         # of the form PASS=<recipient>
         content = msg.content if isinstance(msg, ChatDocument) else msg
+        content = content.strip()
         if PASS in content and PASS_TO not in content:
             return True, None
         if PASS_TO in content and content.split(":")[1] != "":
             return True, content.split(":")[1]
-        if SEND_TO in content and content.split(":")[1] != "":
-            recipient = content.split(":")[1]
+        if SEND_TO in content and (send_parts := re.split(r"[,: ]", content))[1] != "":
+            # assume syntax is SEND_TO:<recipient> <content>
+            # or SEND_TO:<recipient>,<content> or SEND_TO:<recipient>:<content>
+            recipient = send_parts[1].strip()
             # get content to send, clean out routing instruction, and
             # start from 1 char after SEND_TO:<recipient>,
             # because we expect there is either a blank or some other separator
             # after the recipient
-            content_to_send = content.replace(f"{SEND_TO}:{recipient}", "").strip()[1:]
+            content_to_send = content.replace(f"{SEND_TO}{recipient}", "").strip()[1:]
             # if no content then treat same as PASS_TO
             if content_to_send == "":
                 return True, recipient

{langroid-0.1.196 → langroid-0.1.197}/langroid/agent/tool_message.py

@@ -16,7 +16,10 @@ from docstring_parser import parse
 from pydantic import BaseModel
 
 from langroid.language_models.base import LLMFunctionSpec
-from langroid.utils.pydantic_utils import _recursive_purge_dict_key
+from langroid.utils.pydantic_utils import (
+    _recursive_purge_dict_key,
+    generate_simple_schema,
+)
 
 
 class ToolMessage(ABC, BaseModel):
@@ -101,22 +104,30 @@ class ToolMessage(ABC, BaseModel):
         return properties.get(f, {}).get("default", None)
 
     @classmethod
-    def json_instructions(cls) -> str:
+    def json_instructions(cls, tool: bool = False) -> str:
         """
         Default Instructions to the LLM showing how to use the tool/function-call.
         Works for GPT4 but override this for weaker LLMs if needed.
+
+        Args:
+            tool: instructions for Langroid-native tool use? (e.g. for non-OpenAI LLM)
+                (or else it would be for OpenAI Function calls)
         Returns:
             str: instructions on how to use the message
         """
+        # TODO: when we attempt to use a "simpler schema"
+        # (i.e. all nested fields explicit without definitions),
+        # we seem to get worse results, so we turn it off for now
+        param_dict = (
+            # cls.simple_schema() if tool else
+            cls.llm_function_schema(request=True).parameters
+        )
         return textwrap.dedent(
             f"""
             TOOL: {cls.default_value("request")}
             PURPOSE: {cls.default_value("purpose")} 
             JSON FORMAT: {
-                json.dumps(
-                    cls.llm_function_schema(request=True).parameters,
-                    indent=4,
-                )
+                json.dumps(param_dict, indent=4)
             }
             {"EXAMPLE: " + cls.usage_example() if cls.examples() else ""}
             """.lstrip()
@@ -210,3 +221,14 @@ class ToolMessage(ABC, BaseModel):
             description=cls.default_value("purpose"),
             parameters=parameters,
         )
+
+    @classmethod
+    def simple_schema(cls) -> Dict[str, Any]:
+        """
+        Return a simplified schema for the message, with only the request and
+        required fields.
+        Returns:
+            Dict[str, Any]: simplified schema
+        """
+        schema = generate_simple_schema(cls, exclude=["result", "purpose"])
+        return schema

{langroid-0.1.196 → langroid-0.1.197}/langroid/parsing/json.py

@@ -1,4 +1,5 @@
 import json
+import re
 from typing import Any, Iterator, List
 
 from pyparsing import nestedExpr, originalTextFor
@@ -44,6 +45,40 @@ def get_json_candidates(s: str) -> List[str]:
         return []
 
 
+def replace_undefined(s: str, undefined_placeholder: str = '"<undefined>"') -> str:
+    """
+    Replace undefined values in a potential json str with a placeholder.
+
+    Args:
+    - s (str): The potential JSON string to parse.
+    - undefined_placeholder (str): The placeholder or error message
+        for undefined values.
+
+    Returns:
+    - str: The (potential) JSON string with undefined values
+        replaced by the placeholder.
+    """
+
+    # Preprocess the string to replace undefined values with the placeholder
+    # This regex looks for patterns like ": <identifier>" and replaces them
+    # with the placeholder.
+    # It's a simple approach and might need adjustments for complex cases
+    # This is an attempt to handle cases where a weak LLM may produce
+    # a JSON-like string without quotes around some values, e.g.
+    # {"rent": DO-NOT-KNOW }
+    preprocessed_s = re.sub(
+        r":\s*([a-zA-Z_][a-zA-Z_0-9\-]*)", f": {undefined_placeholder}", s
+    )
+
+    # Now, attempt to parse the preprocessed string as JSON
+    try:
+        return preprocessed_s
+    except Exception:
+        # If parsing fails, return an error message instead
+        # (this should be rare after preprocessing)
+        return s
+
+
 def extract_top_level_json(s: str) -> List[str]:
     """Extract all top-level JSON-formatted substrings from a given string.
 
@@ -53,15 +88,16 @@ def extract_top_level_json(s: str) -> List[str]:
     Returns:
         List[str]: A list of top-level JSON-formatted substrings.
     """
-    # Find JSON object and array candidates using regular expressions
+    # Find JSON object and array candidates
     json_candidates = get_json_candidates(s)
 
     normalized_candidates = [
         candidate.replace("\\{", "{").replace("\\}", "}").replace("\\_", "_")
         for candidate in json_candidates
     ]
+    candidates = [replace_undefined(candidate) for candidate in normalized_candidates]
     top_level_jsons = [
-        candidate for candidate in normalized_candidates if is_valid_json(candidate)
+        candidate for candidate in candidates if is_valid_json(candidate)
     ]
 
     return top_level_jsons

{langroid-0.1.196 → langroid-0.1.197}/langroid/utils/pydantic_utils.py

@@ -135,6 +135,53 @@ def flatten_pydantic_model(
     return create_model("FlatModel", __base__=base_model, **flattened_fields)
 
 
+def get_field_names(model: Type[BaseModel]) -> List[str]:
+    """Get all field names from a possibly nested Pydantic model."""
+    mdl = flatten_pydantic_model(model)
+    fields = list(mdl.__fields__.keys())
+    # fields may be like a__b__c , so we only want the last part
+    return [f.split("__")[-1] for f in fields]
+
+
+def generate_simple_schema(
+    model: Type[BaseModel], exclude: List[str] = []
+) -> Dict[str, Any]:
+    """
+    Generates a JSON schema for a Pydantic model,
+    with options to exclude specific fields.
+
+    This function traverses the Pydantic model's fields, including nested models,
+    to generate a dictionary representing the JSON schema. Fields specified in
+    the exclude list will not be included in the generated schema.
+
+    Args:
+        model (Type[BaseModel]): The Pydantic model class to generate the schema for.
+        exclude (List[str]): A list of string field names to be excluded from the
+                             generated schema. Defaults to an empty list.
+
+    Returns:
+        Dict[str, Any]: A dictionary representing the JSON schema of the provided model,
+                        with specified fields excluded.
+    """
+    if hasattr(model, "__fields__"):
+        output: Dict[str, Any] = {}
+        for field_name, field in model.__fields__.items():
+            if field_name in exclude:
+                continue  # Skip excluded fields
+
+            field_type = field.type_
+            if issubclass(field_type, BaseModel):
+                # Recursively generate schema for nested models
+                output[field_name] = generate_simple_schema(field_type, exclude)
+            else:
+                # Represent the type as a string here
+                output[field_name] = {"type": field_type.__name__}
+        return output
+    else:
+        # Non-model type, return a simplified representation
+        return {"type": model.__name__}
+
+
 def flatten_pydantic_instance(
     instance: BaseModel,
     prefix: str = "",

{langroid-0.1.196 → langroid-0.1.197}/langroid/utils/system.py

@@ -1,10 +1,12 @@
 import getpass
 import hashlib
+import importlib
 import inspect
 import logging
 import shutil
 import socket
 import traceback
+from typing import Any
 
 logger = logging.getLogger(__name__)
 
@@ -15,6 +17,39 @@ DELETION_ALLOWED_PATHS = [
 ]
 
 
+class LazyLoad:
+    """Lazy loading of modules or classes."""
+
+    def __init__(self, import_path: str) -> None:
+        self.import_path = import_path
+        self._target = None
+        self._is_target_loaded = False
+
+    def _load_target(self) -> None:
+        if not self._is_target_loaded:
+            try:
+                # Attempt to import as a module
+                self._target = importlib.import_module(self.import_path)  # type: ignore
+            except ImportError:
+                # If module import fails, attempt to import as a
+                # class or function from a module
+                module_path, attr_name = self.import_path.rsplit(".", 1)
+                module = importlib.import_module(module_path)
+                self._target = getattr(module, attr_name)
+            self._is_target_loaded = True
+
+    def __getattr__(self, name: str) -> Any:
+        self._load_target()
+        return getattr(self._target, name)
+
+    def __call__(self, *args: Any, **kwargs: Any) -> Any:
+        self._load_target()
+        if callable(self._target):
+            return self._target(*args, **kwargs)
+        else:
+            raise TypeError(f"{self.import_path!r} object is not callable")
+
+
 def rmdir(path: str) -> bool:
     """
     Remove a directory recursively.

{langroid-0.1.196 → langroid-0.1.197}/pyproject.toml

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