langroid 0.58.3__py3-none-any.whl → 0.59.0b1__py3-none-any.whl

langroid/agent/base.py

@@ -25,6 +25,8 @@ from typing import (
     no_type_check,
 )
 
+from pydantic import Field, ValidationError, field_validator
+from pydantic_settings import BaseSettings
 from rich import print
 from rich.console import Console
 from rich.markup import escape
@@ -51,12 +53,6 @@ from langroid.parsing.file_attachment import FileAttachment
 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.pydantic_v1 import (
-    BaseSettings,
-    Field,
-    ValidationError,
-    validator,
-)
 from langroid.utils.configuration import settings
 from langroid.utils.constants import (
     DONE,
@@ -100,7 +96,8 @@ class AgentConfig(BaseSettings):
         "Human (respond or q, x to exit current level, " "or hit enter to continue)"
     )
 
-    @validator("name")
+    @field_validator("name")
+    @classmethod
     def check_name_alphanum(cls, v: str) -> str:
         if not re.match(r"^[a-zA-Z0-9_-]+$", v):
             raise ValueError(
@@ -1450,7 +1447,12 @@ class Agent(ABC):
             return None
         tool_class = self.llm_tools_map[tool_name]
         tool_msg.update(dict(request=tool_name))
-        tool = tool_class.parse_obj(tool_msg)
+        try:
+            tool = tool_class.model_validate(tool_msg)
+        except ValidationError as ve:
+            # Store tool class as an attribute on the exception
+            ve.tool_class = tool_class  # type: ignore
+            raise ve
         return tool
 
     def get_oai_tool_calls_classes(self, msg: ChatDocument) -> List[ToolMessage]:
@@ -1483,7 +1485,12 @@ class Agent(ABC):
             all_errors = False
             tool_class = self.llm_tools_map[tool_name]
             tool_msg.update(dict(request=tool_name))
-            tool = tool_class.parse_obj(tool_msg)
+            try:
+                tool = tool_class.model_validate(tool_msg)
+            except ValidationError as ve:
+                # Store tool class as an attribute on the exception
+                ve.tool_class = tool_class  # type: ignore
+                raise ve
             tool.id = tc.id or ""
             tools.append(tool)
         # When no tool is valid and the message was produced
@@ -1491,18 +1498,28 @@ class Agent(ABC):
         self.tool_error = all_errors and msg.metadata.sender == Entity.LLM
         return tools
 
-    def tool_validation_error(self, ve: ValidationError) -> str:
+    def tool_validation_error(
+        self, ve: ValidationError, tool_class: Optional[Type[ToolMessage]] = None
+    ) -> str:
         """
         Handle a validation error raised when parsing a tool message,
             when there is a legit tool name used, but it has missing/bad fields.
         Args:
-            tool (ToolMessage): The tool message that failed validation
             ve (ValidationError): The exception raised
+            tool_class (Optional[Type[ToolMessage]]): The tool class that
+                failed validation
 
         Returns:
             str: The error message to send back to the LLM
         """
-        tool_name = cast(ToolMessage, ve.model).default_value("request")
+        # First try to get tool class from the exception itself
+        if hasattr(ve, "tool_class") and ve.tool_class:
+            tool_name = ve.tool_class.default_value("request")  # type: ignore
+        elif tool_class is not None:
+            tool_name = tool_class.default_value("request")
+        else:
+            # Fallback: try to extract from error context if available
+            tool_name = "Unknown Tool"
         bad_field_errors = "\n".join(
             [f"{e['loc']}: {e['msg']}" for e in ve.errors() if "loc" in e]
         )
@@ -1778,11 +1795,11 @@ class Agent(ABC):
                 )
                 possible = [self.llm_tools_map[r] for r in allowable]
 
-            default_keys = set(ToolMessage.__fields__.keys())
+            default_keys = set(ToolMessage.model_fields.keys())
             request_keys = set(maybe_tool_dict.keys())
 
             def maybe_parse(tool: type[ToolMessage]) -> Optional[ToolMessage]:
-                all_keys = set(tool.__fields__.keys())
+                all_keys = set(tool.model_fields.keys())
                 non_inherited_keys = all_keys.difference(default_keys)
                 # If the request has any keys not valid for the tool and
                 # does not specify some key specific to the type
@@ -1794,7 +1811,7 @@ class Agent(ABC):
                     return None
 
                 try:
-                    return tool.parse_obj(maybe_tool_dict)
+                    return tool.model_validate(maybe_tool_dict)
                 except ValidationError:
                     return None
 
@@ -1824,9 +1841,11 @@ class Agent(ABC):
             return None
 
         try:
-            message = message_class.parse_obj(maybe_tool_dict)
+            message = message_class.model_validate(maybe_tool_dict)
         except ValidationError as ve:
             self.tool_error = from_llm
+            # Store tool class as an attribute on the exception
+            ve.tool_class = message_class  # type: ignore
             raise ve
         return message
 
@@ -1940,11 +1959,14 @@ class Agent(ABC):
         return None
 
     def _maybe_truncate_result(
-        self, result: str | ChatDocument | None, max_tokens: int | None
+        self,
+        result: str | ChatDocument | None,
+        max_tokens: int | None,
     ) -> str | ChatDocument | None:
         """
         Truncate the result string to `max_tokens` tokens.
         """
+
         if result is None or max_tokens is None:
             return result
         result_str = result.content if isinstance(result, ChatDocument) else result