langroid 0.58.2__py3-none-any.whl → 0.59.0__py3-none-any.whl

langroid/agent/task.py

@@ -27,6 +27,7 @@ from typing import (
 )
 
 import numpy as np
+from pydantic import BaseModel, ConfigDict
 from rich import print
 from rich.markup import escape
 
@@ -45,7 +46,6 @@ from langroid.exceptions import InfiniteLoopException
 from langroid.mytypes import Entity
 from langroid.parsing.parse_json import extract_top_level_json
 from langroid.parsing.routing import parse_addressed_message
-from langroid.pydantic_v1 import BaseModel
 from langroid.utils.configuration import settings
 from langroid.utils.constants import (
     DONE,
@@ -90,6 +90,9 @@ class AgentEvent(BaseModel):
 
     event_type: EventType
     tool_name: Optional[str] = None  # For SPECIFIC_TOOL
+    tool_class: Optional[Type[Any]] = (
+        None  # For storing tool class references when using SPECIFIC_TOOL events
+    )
     content_pattern: Optional[str] = None  # For CONTENT_MATCH (regex)
     responder: Optional[str] = None  # Specific responder name
     # Optionally match only if the responder was specific entity/task
@@ -146,6 +149,7 @@ class TaskConfig(BaseModel):
         done_sequences (List[DoneSequence]): List of event sequences that trigger task
             completion. Task is done if ANY sequence matches the recent event history.
             Each sequence is checked against the message parent chain.
+            Tool classes can be referenced in sequences like "T[MyToolClass]".
 
     """
 
@@ -298,14 +302,8 @@ class Task:
             set_parent_agent=noop_fn,
         )
         self.config = config
-        # Store parsed done sequences
+        # Store parsed done sequences (will be initialized after agent assignment)
         self._parsed_done_sequences: Optional[List[DoneSequence]] = None
-        if self.config.done_sequences:
-            from .done_sequence_parser import parse_done_sequences
-
-            self._parsed_done_sequences = parse_done_sequences(
-                self.config.done_sequences
-            )
         # how to behave as a sub-task; can be overridden by `add_sub_task()`
         self.config_sub_task = copy.deepcopy(config)
         # counts of distinct pending messages in history,
@@ -340,6 +338,21 @@ class Task:
                 self.agent.set_system_message(system_message)
             if user_message:
                 self.agent.set_user_message(user_message)
+
+        # Initialize parsed done sequences now that self.agent is available
+        if self.config.done_sequences:
+            from .done_sequence_parser import parse_done_sequences
+
+            # Pass agent's llm_tools_map directly
+            tools_map = (
+                self.agent.llm_tools_map
+                if hasattr(self.agent, "llm_tools_map")
+                else None
+            )
+            self._parsed_done_sequences = parse_done_sequences(
+                self.config.done_sequences, tools_map
+            )
+
         self.max_cost: float = 0
         self.max_tokens: int = 0
         self.session_id: str = ""
@@ -483,7 +496,7 @@ class Task:
         self.message_counter.clear()
         # create a unique string that will not likely be in any message,
         # so we always have a message with count=1
-        self.message_counter.update([hash("___NO_MESSAGE___")])
+        self.message_counter.update([str(hash("___NO_MESSAGE___"))])
 
     def _cache_session_store(self, key: str, value: str) -> None:
         """
@@ -2083,7 +2096,7 @@ class Task:
         """
         from langroid.agent.chat_document import ChatDocLoggerFields
 
-        default_values = ChatDocLoggerFields().dict().values()
+        default_values = ChatDocLoggerFields().model_dump().values()
         msg_str_tsv = "\t".join(str(v) for v in default_values)
         if msg is not None:
             msg_str_tsv = msg.tsv_str()
@@ -2144,7 +2157,7 @@ class Task:
             else:
                 # Get fields from the message
                 fields = msg.log_fields()
-                fields_dict = fields.dict()
+                fields_dict = fields.model_dump()
                 fields_dict.update(
                     {
                         "responder": str(resp),
@@ -2155,13 +2168,11 @@ class Task:
 
             # Create a ChatDocLoggerFields-like object for the HTML logger
             # Create a simple BaseModel subclass dynamically
-            from langroid.pydantic_v1 import BaseModel
+            from pydantic import BaseModel
 
             class LogFields(BaseModel):
-                class Config:
-                    extra = "allow"  # Allow extra fields
+                model_config = ConfigDict(extra="allow")  # Allow extra fields
 
-            # Create instance with the fields from fields_dict
             log_obj = LogFields(**fields_dict)
             self.html_logger.log(log_obj)
 
@@ -2173,8 +2184,6 @@ class Task:
         """
         if recipient == "":
             return True
-        # native responders names are USER, LLM, AGENT,
-        # and the names of subtasks are from Task.name attribute
         responder_names = [self.name.lower()] + [
             r.name.lower() for r in self.responders
         ]
@@ -2184,7 +2193,6 @@ class Task:
         """
         Is the recipient explicitly specified and does not match responder "e" ?
         """
-        # Note that recipient could be specified as an Entity or a Task name
         return (
             self.pending_message is not None
             and (recipient := self.pending_message.metadata.recipient) != ""
@@ -2195,8 +2203,6 @@ class Task:
 
     def _user_can_respond(self) -> bool:
         return self.interactive or (
-            # regardless of self.interactive, if a msg is explicitly addressed to
-            # user, then wait for user response
             self.pending_message is not None
             and self.pending_message.metadata.recipient == Entity.USER
             and not self.agent.has_tool_message_attempt(self.pending_message)
@@ -2204,19 +2210,13 @@ class Task:
 
     def _can_respond(self, e: Responder) -> bool:
         user_can_respond = self._user_can_respond()
-
         if self.pending_sender == e or (e == Entity.USER and not user_can_respond):
-            # sender is same as e (an entity cannot respond to its own msg),
-            # or user cannot respond
             return False
-
         if self.pending_message is None:
             return True
         if isinstance(e, Task) and not e.agent.can_respond(self.pending_message):
             return False
-
         if self._recipient_mismatch(e):
-            # Cannot respond if not addressed to this entity
             return False
         return self.pending_message.metadata.block != e
 
@@ -2230,7 +2230,6 @@ class Task:
         Args:
             enable (bool): value of `self.color_log` to set to,
                 which will enable/diable rich logging
-
         """
         self.color_log = enable
 
@@ -2247,16 +2246,13 @@ class Task:
         Args:
             msg (ChatDocument|str|None): message to parse
             addressing_prefix (str): prefix to address other agents or entities,
-                 (e.g. "@". See documentation of `TaskConfig` for details).
+                (e.g. "@". See documentation of `TaskConfig` for details).
         Returns:
             Tuple[bool|None, str|None, str|None]:
                 bool: true=PASS, false=SEND, or None if neither
                 str: recipient, or None
                 str: content to send, or None
         """
-        # handle routing instruction-strings in result if any,
-        # such as PASS, PASS_TO, or SEND
-
         msg_str = msg.content if isinstance(msg, ChatDocument) else msg
         if (
             self.agent.has_tool_message_attempt(msg)
@@ -2264,10 +2260,7 @@ class Task:
             and not msg_str.startswith(PASS_TO)
             and not msg_str.startswith(SEND_TO)
         ):
-            # if there's an attempted tool-call, we ignore any routing strings,
-            # unless they are at the start of the msg
             return None, None, None
-
         content = msg.content if isinstance(msg, ChatDocument) else msg
         content = content.strip()
         if PASS in content and PASS_TO not in content:
@@ -2279,10 +2272,7 @@ class Task:
             and (addressee_content := parse_addressed_message(content, SEND_TO))[0]
             is not None
         ):
-            # Note this will discard any portion of content BEFORE SEND_TO.
-            # TODO maybe make this configurable.
             (addressee, content_to_send) = addressee_content
-            # if no content then treat same as PASS_TO
             if content_to_send == "":
                 return True, addressee, None
             else:
@@ -2296,12 +2286,10 @@ class Task:
             is not None
         ):
             (addressee, content_to_send) = addressee_content
-            # if no content then treat same as PASS_TO
             if content_to_send == "":
                 return True, addressee, None
             else:
                 return False, addressee, content_to_send
-
         return None, None, None
 
     def _classify_event(
@@ -2310,19 +2298,13 @@ class Task:
         """Classify a message into an AgentEvent for sequence matching."""
         if msg is None:
             return AgentEvent(event_type=EventType.NO_RESPONSE)
-
-        # Determine the event type based on responder and message content
         event_type = EventType.NO_RESPONSE
         tool_name = None
-
-        # Check if there are tool messages
         tool_messages = self.agent.try_get_tool_messages(msg, all_tools=True)
         if tool_messages:
             event_type = EventType.TOOL
             if len(tool_messages) == 1:
                 tool_name = tool_messages[0].request
-
-        # Check responder type
         if responder == Entity.LLM and not tool_messages:
             event_type = EventType.LLM_RESPONSE
         elif responder == Entity.AGENT:
@@ -2330,21 +2312,17 @@ class Task:
         elif responder == Entity.USER:
             event_type = EventType.USER_RESPONSE
         elif isinstance(responder, Task):
-            # For sub-task responses, check the sender in metadata
             if msg.metadata.sender == Entity.LLM:
                 event_type = EventType.LLM_RESPONSE
             elif msg.metadata.sender == Entity.AGENT:
                 event_type = EventType.AGENT_RESPONSE
             else:
                 event_type = EventType.USER_RESPONSE
-
-        # Get sender name
         sender_name = None
         if isinstance(responder, Entity):
             sender_name = responder.value
         elif isinstance(responder, Task):
             sender_name = responder.name
-
         return AgentEvent(
             event_type=event_type,
             tool_name=tool_name,
@@ -2356,71 +2334,74 @@ class Task:
     ) -> List[ChatDocument]:
         """Get the chain of messages from response sequence."""
         if max_depth is None:
-            # Get max depth needed from all sequences
             max_depth = 50  # default fallback
-            if self._parsed_done_sequences:
-                max_depth = max(len(seq.events) for seq in self._parsed_done_sequences)
-
-        # Simply return the last max_depth elements from response_sequence
+        if self._parsed_done_sequences:
+            max_depth = max(len(seq.events) for seq in self._parsed_done_sequences)
         return self.response_sequence[-max_depth:]
 
     def _matches_event(self, actual: AgentEvent, expected: AgentEvent) -> bool:
         """Check if an actual event matches an expected event pattern."""
-        # Check event type
         if expected.event_type == EventType.SPECIFIC_TOOL:
             if actual.event_type != EventType.TOOL:
                 return False
+
+            # First try tool_class matching if available
+            if expected.tool_class is not None:
+                # Handle case where actual.tool_class might be a class instance
+                if hasattr(actual, "tool_class") and actual.tool_class is not None:
+                    # If actual.tool_class is an instance, get its class
+                    if isinstance(actual.tool_class, type):
+                        actual_class = actual.tool_class
+                    else:
+                        actual_class = type(actual.tool_class)
+
+                    # Compare the tool classes
+                    if actual_class == expected.tool_class:
+                        return True
+                    # Also check if actual tool is an instance of expected class
+                    if not isinstance(actual.tool_class, type) and isinstance(
+                        actual.tool_class, expected.tool_class
+                    ):
+                        return True
+
+                # If tool_class comparison didn't match, continue to tool_name fallback
+
+            # Fall back to tool_name comparison for backwards compatibility
             if expected.tool_name and actual.tool_name != expected.tool_name:
                 return False
+
         elif actual.event_type != expected.event_type:
             return False
-
-        # Check sender if specified
         if expected.sender and actual.sender != expected.sender:
             return False
-
-        # TODO: Add content pattern matching for CONTENT_MATCH type
-
         return True
 
     def _matches_sequence(
         self, msg_chain: List[ChatDocument], sequence: DoneSequence
     ) -> bool:
         """Check if a message chain matches a done sequence.
-
         We traverse the message chain and try to match the sequence events.
         The events don't have to be consecutive in the chain.
         """
         if not sequence.events:
             return False
-
-        # Convert messages to events
         events = []
         for i, msg in enumerate(msg_chain):
-            # Determine responder from metadata or by checking previous message
             responder = None
             if msg.metadata.sender:
                 responder = msg.metadata.sender
             elif msg.metadata.sender_name:
-                # Could be a task name - keep as None for now since we can't resolve
-                # the actual Task object from just the name
                 responder = None
-
             event = self._classify_event(msg, responder)
             if event:
                 events.append(event)
-
-        # Try to match the sequence
         seq_idx = 0
         for event in events:
             if seq_idx >= len(sequence.events):
                 break
-
             expected = sequence.events[seq_idx]
             if self._matches_event(event, expected):
                 seq_idx += 1
-
-        # Check if we matched the entire sequence
         return seq_idx == len(sequence.events)
 
     def close_loggers(self) -> None:
@@ -2438,43 +2419,26 @@ class Task:
         current_responder: Optional[Responder],
     ) -> bool:
         """Check if the message chain plus current message matches a done sequence.
-
         Process messages in reverse order (newest first) and match against
         the sequence events in reverse order.
         """
-        # Add current message to chain if not already there
         if not msg_chain or msg_chain[-1].id() != current_msg.id():
             msg_chain = msg_chain + [current_msg]
-
-        # If we don't have enough messages for the sequence, can't match
         if len(msg_chain) < len(sequence.events):
             return False
-
-        # Process in reverse order - start from the end of both lists
         seq_idx = len(sequence.events) - 1
         msg_idx = len(msg_chain) - 1
-
         while seq_idx >= 0 and msg_idx >= 0:
             msg = msg_chain[msg_idx]
             expected = sequence.events[seq_idx]
-
-            # Determine responder for this message
             if msg_idx == len(msg_chain) - 1 and current_responder is not None:
-                # For the last message, use the current responder
                 responder = current_responder
             else:
-                # For other messages, determine from metadata
                 responder = msg.metadata.sender
-
-            # Classify the event
             event = self._classify_event(msg, responder)
             if not event:
                 return False
-
-            # Check if it matches
             matched = False
-
-            # Special handling for CONTENT_MATCH
             if (
                 expected.event_type == EventType.CONTENT_MATCH
                 and expected.content_pattern
@@ -2483,14 +2447,9 @@ class Task:
                     matched = True
             elif self._matches_event(event, expected):
                 matched = True
-
             if not matched:
-                # Strict matching - no skipping allowed
                 return False
             else:
-                # Matched! Move to next expected event
                 seq_idx -= 1
                 msg_idx -= 1
-
-        # We matched if we've matched all events in the sequence
         return seq_idx < 0

langroid/agent/tool_message.py

@@ -14,9 +14,9 @@ from random import choice
 from typing import Any, Dict, List, Optional, Tuple, Type, TypeVar
 
 from docstring_parser import parse
+from pydantic import BaseModel, ConfigDict
 
 from langroid.language_models.base import LLMFunctionSpec
-from langroid.pydantic_v1 import BaseModel, Extra
 from langroid.utils.pydantic_utils import (
     _recursive_purge_dict_key,
     generate_simple_schema,
@@ -40,6 +40,14 @@ def format_schema_for_strict(schema: Any) -> None:
     This may not be equivalent to the original schema.
     """
     if isinstance(schema, dict):
+        # Handle $ref nodes - they can't have any other properties
+        if "$ref" in schema:
+            # Keep only the $ref, remove all other properties like description
+            ref_value = schema["$ref"]
+            schema.clear()
+            schema["$ref"] = ref_value
+            return
+
         if "type" in schema and schema["type"] == "object":
             schema["additionalProperties"] = False
 
@@ -111,14 +119,21 @@ class ToolMessage(ABC, BaseModel):
     # Optional param to limit number of tokens in the result of the tool.
     _max_result_tokens: int | None = None
 
-    class Config:
-        extra = Extra.allow
-        arbitrary_types_allowed = False
-        validate_all = True
-        validate_assignment = True
+    model_config = ConfigDict(
+        extra="allow",
+        arbitrary_types_allowed=False,
+        validate_default=True,
+        validate_assignment=True,
         # do not include these fields in the generated schema
         # since we don't require the LLM to specify them
-        schema_extra = {"exclude": {"purpose", "id"}}
+        json_schema_extra={"exclude": ["purpose", "id"]},
+    )
+
+    # Define excluded fields as a class method to avoid Pydantic treating it as
+    # a model field
+    @classmethod
+    def _get_excluded_fields(cls) -> set[str]:
+        return {"purpose", "id"}
 
     @classmethod
     def name(cls) -> str:
@@ -196,18 +211,18 @@ class ToolMessage(ABC, BaseModel):
         return "\n\n".join(formatted_examples)
 
     def to_json(self) -> str:
-        return self.json(indent=4, exclude=self.Config.schema_extra["exclude"])
+        return self.model_dump_json(indent=4, exclude=self._get_excluded_fields())
 
     def format_example(self) -> str:
-        return self.json(indent=4, exclude=self.Config.schema_extra["exclude"])
+        return self.model_dump_json(indent=4, exclude=self._get_excluded_fields())
 
     def dict_example(self) -> Dict[str, Any]:
-        return self.dict(exclude=self.Config.schema_extra["exclude"])
+        return self.model_dump(exclude=self._get_excluded_fields())
 
     def get_value_of_type(self, target_type: Type[Any]) -> Any:
         """Try to find a value of a desired type in the fields of the ToolMessage."""
-        ignore_fields = self.Config.schema_extra["exclude"].union(["request"])
-        for field_name in set(self.dict().keys()) - ignore_fields:
+        ignore_fields = self._get_excluded_fields().union({"request"})
+        for field_name in set(self.model_dump().keys()) - ignore_fields:
             value = getattr(self, field_name)
             if is_instance_of(value, target_type):
                 return value
@@ -224,7 +239,7 @@ class ToolMessage(ABC, BaseModel):
             Any: default value of the field, or None if not set or if the
                 field does not exist.
         """
-        schema = cls.schema()
+        schema = cls.model_json_schema()
         properties = schema["properties"]
         return properties.get(f, {}).get("default", None)
 
@@ -304,7 +319,7 @@ class ToolMessage(ABC, BaseModel):
             LLMFunctionSpec: the schema as an LLMFunctionSpec
 
         """
-        schema = copy.deepcopy(cls.schema())
+        schema = copy.deepcopy(cls.model_json_schema())
         docstring = parse(cls.__doc__ or "")
         parameters = {
             k: v for k, v in schema.items() if k not in ("title", "description")
@@ -316,7 +331,7 @@ class ToolMessage(ABC, BaseModel):
                 if "description" not in parameters["properties"][name]:
                     parameters["properties"][name]["description"] = description
 
-        excludes = cls.Config.schema_extra["exclude"]
+        excludes = cls._get_excluded_fields().copy()
         if not request:
             excludes = excludes.union({"request"})
         # exclude 'excludes' from parameters["properties"]:
@@ -374,7 +389,8 @@ class ToolMessage(ABC, BaseModel):
         _recursive_purge_dict_key(parameters, "additionalProperties")
         return LLMFunctionSpec(
             name=cls.default_value("request"),
-            description=cls.default_value("purpose"),
+            description=cls.default_value("purpose")
+            or f"Tool for {cls.default_value('request')}",
             parameters=parameters,
         )
 
@@ -388,6 +404,6 @@ class ToolMessage(ABC, BaseModel):
         """
         schema = generate_simple_schema(
             cls,
-            exclude=list(cls.Config.schema_extra["exclude"]),
+            exclude=list(cls._get_excluded_fields()),
         )
         return schema

langroid/agent/tools/file_tools.py

@@ -4,10 +4,10 @@ from textwrap import dedent
 from typing import Callable, List, Tuple, Type
 
 import git
+from pydantic import Field
 
 from langroid.agent.tool_message import ToolMessage
 from langroid.agent.xml_tool_message import XMLToolMessage
-from langroid.pydantic_v1 import Field
 from langroid.utils.git_utils import git_commit_file
 from langroid.utils.system import create_file, list_dir, read_file
 
@@ -91,7 +91,9 @@ class WriteFileTool(XMLToolMessage):
     content: str = Field(
         ...,
         description="The content to write to the file",
-        verbatim=True,  # preserve the content as is; uses CDATA section in XML
+        json_schema_extra={
+            "verbatim": True
+        },  # preserve the content as is; uses CDATA section in XML
     )
     _curr_dir: Callable[[], str] | None = None
     _git_repo: Callable[[], git.Repo] | None = None

langroid/agent/tools/mcp/fastmcp_client.py

@@ -27,12 +27,12 @@ from mcp.types import (
     TextResourceContents,
     Tool,
 )
+from pydantic import AnyUrl, BaseModel, Field, create_model
 
 from langroid.agent.base import Agent
 from langroid.agent.chat_document import ChatDocument
 from langroid.agent.tool_message import ToolMessage
 from langroid.parsing.file_attachment import FileAttachment
-from langroid.pydantic_v1 import AnyUrl, BaseModel, Field, create_model
 
 load_dotenv()  # load environment variables from .env
 
@@ -253,11 +253,24 @@ class FastMCPClient:
             from langroid.agent.tools.mcp.fastmcp_client import FastMCPClient
 
             # pack up the payload
-            payload = itself.dict(
-                exclude=itself.Config.schema_extra["exclude"].union(
-                    ["request", "purpose"]
-                ),
-            )
+            # Get exclude fields from model config with proper type checking
+            exclude_fields = set()
+            model_config = getattr(itself, "model_config", {})
+            if (
+                isinstance(model_config, dict)
+                and "json_schema_extra" in model_config
+                and model_config["json_schema_extra"] is not None
+                and isinstance(model_config["json_schema_extra"], dict)
+                and "exclude" in model_config["json_schema_extra"]
+            ):
+                exclude_list = model_config["json_schema_extra"]["exclude"]
+                if isinstance(exclude_list, (list, set, tuple)):
+                    exclude_fields = set(exclude_list)
+
+            # Add standard excluded fields
+            exclude_fields.update(["request", "purpose"])
+
+            payload = itself.model_dump(exclude=exclude_fields)
 
             # restore any renamed fields
             for orig, new in itself.__class__._renamed_fields.items():  # type: ignore

langroid/agent/tools/orchestration.py

@@ -5,11 +5,12 @@ termination, routing to another agent, etc.
 
 from typing import Any, List, Tuple
 
+from pydantic import ConfigDict, field_validator
+
 from langroid.agent.chat_agent import ChatAgent
 from langroid.agent.chat_document import ChatDocument
 from langroid.agent.tool_message import ToolMessage
 from langroid.mytypes import Entity
-from langroid.pydantic_v1 import Extra
 from langroid.utils.types import to_string
 
 
@@ -48,6 +49,12 @@ class DoneTool(ToolMessage):
     request: str = "done_tool"
     content: str = ""
 
+    @field_validator("content", mode="before")
+    @classmethod
+    def convert_content_to_string(cls, v: Any) -> str:
+        """Convert content to string if it's not already."""
+        return str(v) if v is not None else ""
+
     def response(self, agent: ChatAgent) -> ChatDocument:
         return agent.create_agent_response(
             content=self.content,
@@ -90,14 +97,13 @@ class ResultTool(ToolMessage):
     purpose: str = "Ignored; Wrapper for a structured message"
     id: str = ""  # placeholder for OpenAI-API tool_call_id
 
-    class Config:
-        extra = Extra.allow
-        arbitrary_types_allowed = False
-        validate_all = True
-        validate_assignment = True
-        # do not include these fields in the generated schema
-        # since we don't require the LLM to specify them
-        schema_extra = {"exclude": {"purpose", "id", "strict"}}
+    model_config = ConfigDict(
+        extra="allow",
+        arbitrary_types_allowed=False,
+        validate_default=True,
+        validate_assignment=True,
+        json_schema_extra={"exclude": ["purpose", "id", "strict"]},
+    )
 
     def handle(self) -> AgentDoneTool:
         return AgentDoneTool(tools=[self])
@@ -132,14 +138,13 @@ class FinalResultTool(ToolMessage):
     id: str = ""  # placeholder for OpenAI-API tool_call_id
     _allow_llm_use: bool = False
 
-    class Config:
-        extra = Extra.allow
-        arbitrary_types_allowed = False
-        validate_all = True
-        validate_assignment = True
-        # do not include these fields in the generated schema
-        # since we don't require the LLM to specify them
-        schema_extra = {"exclude": {"purpose", "id", "strict"}}
+    model_config = ConfigDict(
+        extra="allow",
+        arbitrary_types_allowed=False,
+        validate_default=True,
+        validate_assignment=True,
+        json_schema_extra={"exclude": ["purpose", "id", "strict"]},
+    )
 
 
 class PassTool(ToolMessage):