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

langroid/agent/tools/recipient_tool.py

@@ -17,7 +17,7 @@ especially with weaker LLMs.
 
 """
 
-from typing import List, Type
+from typing import ClassVar, List, Type
 
 from rich import print
 
@@ -106,8 +106,8 @@ class RecipientTool(ToolMessage):
         only allows certain recipients, and possibly sets a default recipient."""
 
         class RecipientToolRestricted(cls):  # type: ignore
-            allowed_recipients = recipients
-            default_recipient = default
+            allowed_recipients: ClassVar[List[str]] = recipients
+            default_recipient: ClassVar[str] = default
 
         return RecipientToolRestricted
 

langroid/agent/tools/task_tool.py

@@ -6,13 +6,15 @@ TaskTool: A tool that allows agents to delegate a task to a sub-agent with
 import uuid
 from typing import List, Optional
 
+from pydantic import Field
+from pydantic.fields import ModelPrivateAttr
+
 import langroid.language_models as lm
 from langroid import ChatDocument
 from langroid.agent.chat_agent import ChatAgent, ChatAgentConfig
 from langroid.agent.task import Task
 from langroid.agent.tool_message import ToolMessage
 from langroid.agent.tools.orchestration import DoneTool
-from langroid.pydantic_v1 import Field
 
 
 class TaskTool(ToolMessage):
@@ -83,7 +85,7 @@ class TaskTool(ToolMessage):
         """,
     )
     # TODO: ensure valid model name
-    model: str = Field(
+    model: Optional[str] = Field(
         default=None,
         description="""
             Optional name of the LLM model to use for the sub-agent, e.g. 'gpt-4.1'
@@ -148,25 +150,29 @@ class TaskTool(ToolMessage):
         if self.tools == ["ALL"]:
             # Enable all tools from the parent agent:
             # This is the list of all tools KNOWN (whether usable or handle-able or not)
-            tool_classes = [
-                agent.llm_tools_map[t]
-                for t in agent.llm_tools_known
-                if t in agent.llm_tools_map
-                and t != self.request
-                and agent.llm_tools_map[t]._allow_llm_use
-                # Exclude the TaskTool itself!
-            ]
+            tool_classes = []
+            for t in agent.llm_tools_known:
+                if t in agent.llm_tools_map and t != self.request:
+                    tool_class = agent.llm_tools_map[t]
+                    allow_llm_use = tool_class._allow_llm_use
+                    if isinstance(allow_llm_use, ModelPrivateAttr):
+                        allow_llm_use = allow_llm_use.default
+                    if allow_llm_use:
+                        tool_classes.append(tool_class)
         elif self.tools == ["NONE"]:
             # No tools enabled
             tool_classes = []
         else:
             # Enable only specified tools
-            tool_classes = [
-                agent.llm_tools_map[tool_name]
-                for tool_name in self.tools
-                if tool_name in agent.llm_tools_map
-                and agent.llm_tools_map[tool_name]._allow_llm_use
-            ]
+            tool_classes = []
+            for tool_name in self.tools:
+                if tool_name in agent.llm_tools_map:
+                    tool_class = agent.llm_tools_map[tool_name]
+                    allow_llm_use = tool_class._allow_llm_use
+                    if isinstance(allow_llm_use, ModelPrivateAttr):
+                        allow_llm_use = allow_llm_use.default
+                    if allow_llm_use:
+                        tool_classes.append(tool_class)
 
         # always enable the DoneTool to signal task completion
         sub_agent.enable_message(tool_classes + [DoneTool], use=True, handle=True)

langroid/agent/xml_tool_message.py

@@ -1,11 +1,20 @@
 import re
 from collections.abc import Mapping
-from typing import Any, Dict, List, Optional, get_args, get_origin
+from typing import Any, Dict, List, Optional, Union, get_args, get_origin
 
 from lxml import etree
+from pydantic import BaseModel, ConfigDict
 
 from langroid.agent.tool_message import ToolMessage
-from langroid.pydantic_v1 import BaseModel
+
+# For Union type handling - check if we have Python 3.10+ UnionType
+HAS_UNION_TYPE = False
+try:
+    from types import UnionType  # noqa: F401 # Used conditionally
+
+    HAS_UNION_TYPE = True
+except ImportError:
+    pass
 
 
 class XMLToolMessage(ToolMessage):
@@ -27,10 +36,27 @@ class XMLToolMessage(ToolMessage):
     request: str
     purpose: str
 
-    _allow_llm_use = True
+    _allow_llm_use: bool = True
+
+    model_config = ConfigDict(
+        # Inherit settings from ToolMessage
+        extra="allow",
+        arbitrary_types_allowed=False,
+        validate_default=True,
+        validate_assignment=True,
+        json_schema_extra={"exclude": ["purpose", "id"]},
+    )
 
-    class Config(ToolMessage.Config):
-        root_element = "tool"
+    # XMLToolMessage-specific settings as class methods to avoid Pydantic
+    # treating them as model fields
+    @classmethod
+    def _get_excluded_fields(cls) -> set[str]:
+        return {"purpose", "id"}
+
+    # Root element for XML formatting
+    @classmethod
+    def _get_root_element(cls) -> str:
+        return "tool"
 
     @classmethod
     def extract_field_values(cls, formatted_string: str) -> Optional[Dict[str, Any]]:
@@ -67,9 +93,13 @@ class XMLToolMessage(ToolMessage):
             if element.tag.startswith("_"):
                 return {}
 
-            field_info = cls.__fields__.get(element.tag)
-            is_verbatim = field_info and field_info.field_info.extra.get(
-                "verbatim", False
+            field_info = cls.model_fields.get(element.tag)
+            is_verbatim = (
+                field_info
+                and hasattr(field_info, "json_schema_extra")
+                and field_info.json_schema_extra is not None
+                and isinstance(field_info.json_schema_extra, dict)
+                and field_info.json_schema_extra.get("verbatim", False)
             )
 
             if is_verbatim:
@@ -96,8 +126,12 @@ class XMLToolMessage(ToolMessage):
                     # Otherwise, treat as a dictionary
                     result = {child.tag: parse_element(child) for child in element}
                     # Check if this corresponds to a nested Pydantic model
-                    if field_info and issubclass(field_info.type_, BaseModel):
-                        return field_info.type_(**result)
+                    if (
+                        field_info
+                        and isinstance(field_info.annotation, type)
+                        and issubclass(field_info.annotation, BaseModel)
+                    ):
+                        return field_info.annotation(**result)
                     return result
 
         result = parse_element(root)
@@ -124,7 +158,7 @@ class XMLToolMessage(ToolMessage):
                 return None
 
             # Use Pydantic's parse_obj to create and validate the instance
-            return cls.parse_obj(parsed_data)
+            return cls.model_validate(parsed_data)
         except Exception as e:
             from langroid.exceptions import XMLException
 
@@ -132,28 +166,30 @@ class XMLToolMessage(ToolMessage):
 
     @classmethod
     def find_verbatim_fields(
-        cls, prefix: str = "", parent_cls: Optional["BaseModel"] = None
+        cls, prefix: str = "", parent_cls: Optional[type[BaseModel]] = None
     ) -> List[str]:
         verbatim_fields = []
-        for field_name, field_info in (parent_cls or cls).__fields__.items():
+        for field_name, field_info in (parent_cls or cls).model_fields.items():
             full_name = f"{prefix}.{field_name}" if prefix else field_name
             if (
-                field_info.field_info.extra.get("verbatim", False)
-                or field_name == "code"
-            ):
+                hasattr(field_info, "json_schema_extra")
+                and field_info.json_schema_extra is not None
+                and isinstance(field_info.json_schema_extra, dict)
+                and field_info.json_schema_extra.get("verbatim", False)
+            ) or field_name == "code":
                 verbatim_fields.append(full_name)
-            if issubclass(field_info.type_, BaseModel):
+            if isinstance(field_info.annotation, type) and issubclass(
+                field_info.annotation, BaseModel
+            ):
                 verbatim_fields.extend(
-                    cls.find_verbatim_fields(full_name, field_info.type_)
+                    cls.find_verbatim_fields(full_name, field_info.annotation)
                 )
         return verbatim_fields
 
     @classmethod
     def format_instructions(cls, tool: bool = False) -> str:
         fields = [
-            f
-            for f in cls.__fields__.keys()
-            if f not in cls.Config.schema_extra.get("exclude", set())
+            f for f in cls.model_fields.keys() if f not in cls._get_excluded_fields()
         ]
 
         instructions = """
@@ -162,11 +198,11 @@ class XMLToolMessage(ToolMessage):
         """
 
         preamble = "Placeholders:\n"
-        xml_format = f"Formatting example:\n\n<{cls.Config.root_element}>\n"
+        xml_format = f"Formatting example:\n\n<{cls._get_root_element()}>\n"
 
         def format_field(
             field_name: str,
-            field_type: type,
+            field_type: Any,
             indent: str = "",
             path: str = "",
         ) -> None:
@@ -176,6 +212,24 @@ class XMLToolMessage(ToolMessage):
             origin = get_origin(field_type)
             args = get_args(field_type)
 
+            # Handle Union types (including Optional types like List[Person] | None)
+            # Support both typing.Union and types.UnionType (Python 3.10+ | syntax)
+            is_union = origin is Union
+            if HAS_UNION_TYPE:
+                from types import UnionType as _UnionType
+
+                is_union = is_union or origin is _UnionType
+
+            if is_union:
+                # Filter out None type for Optional types
+                non_none_args = [arg for arg in args if arg is not type(None)]
+                if len(non_none_args) == 1:
+                    # This is an Optional type, process the non-None type
+                    field_type = non_none_args[0]
+                    origin = get_origin(field_type)
+                    args = get_args(field_type)
+                # If there are multiple non-None types, fall through to default handling
+
             if (
                 origin is None
                 and isinstance(field_type, type)
@@ -185,10 +239,10 @@ class XMLToolMessage(ToolMessage):
                     f"{field_name.upper()} = [nested structure for {field_name}]\n"
                 )
                 xml_format += f"{indent}<{field_name}>\n"
-                for sub_field, sub_field_info in field_type.__fields__.items():
+                for sub_field, sub_field_info in field_type.model_fields.items():
                     format_field(
                         sub_field,
-                        sub_field_info.outer_type_,
+                        sub_field_info.annotation,
                         indent + "  ",
                         current_path,
                     )
@@ -248,13 +302,14 @@ class XMLToolMessage(ToolMessage):
         verbatim_fields = cls.find_verbatim_fields()
 
         for field in fields:
-            field_info = cls.__fields__[field]
-            field_type = (
-                field_info.outer_type_
-            )  # Use outer_type_ to get the actual type including List, etc.
+            field_info = cls.model_fields[field]
+            field_type = field_info.annotation
+            # Ensure we have a valid type
+            if field_type is None:
+                continue
             format_field(field, field_type)
 
-        xml_format += f"</{cls.Config.root_element}>"
+        xml_format += f"</{cls._get_root_element()}>"
 
         verbatim_alert = ""
         if len(verbatim_fields) > 0:
@@ -312,7 +367,7 @@ class XMLToolMessage(ToolMessage):
                     create_element(elem, k, v, current_path)
             elif isinstance(value, BaseModel):
                 # Handle nested Pydantic models
-                for field_name, field_value in value.dict().items():
+                for field_name, field_value in value.model_dump().items():
                     create_element(elem, field_name, field_value, current_path)
             else:
                 if current_path in self.__class__.find_verbatim_fields():
@@ -320,9 +375,9 @@ class XMLToolMessage(ToolMessage):
                 else:
                     elem.text = str(value)
 
-        root = etree.Element(self.Config.root_element)
-        exclude_fields = self.Config.schema_extra.get("exclude", set())
-        for name, value in self.dict().items():
+        root = etree.Element(self._get_root_element())
+        exclude_fields: set[str] = self._get_excluded_fields()
+        for name, value in self.model_dump().items():
             if name not in exclude_fields:
                 create_element(root, name, value)
 
@@ -349,7 +404,7 @@ class XMLToolMessage(ToolMessage):
             Returns: ["<tool><field1>data</field1></tool>"]
         """
 
-        root_tag = cls.Config.root_element
+        root_tag = cls._get_root_element()
         opening_tag = f"<{root_tag}>"
         closing_tag = f"</{root_tag}>"
 

langroid/cachedb/base.py

@@ -1,7 +1,7 @@
 from abc import ABC, abstractmethod
 from typing import Any, Dict, List
 
-from langroid.pydantic_v1 import BaseSettings
+from pydantic_settings import BaseSettings
 
 
 class CacheDBConfig(BaseSettings):

langroid/embedding_models/base.py

@@ -2,9 +2,9 @@ import logging
 from abc import ABC, abstractmethod
 
 import numpy as np
+from pydantic_settings import BaseSettings
 
 from langroid.mytypes import EmbeddingFunction
-from langroid.pydantic_v1 import BaseSettings
 
 logging.getLogger("openai").setLevel(logging.ERROR)
 
@@ -57,7 +57,7 @@ class EmbeddingModel(ABC):
         elif isinstance(config, GeminiEmbeddingsConfig):
             return GeminiEmbeddings(config)
         else:
-            raise ValueError(f"Unknown embedding config: {config.__repr_name__}")
+            raise ValueError(f"Unknown embedding config: {config.__class__.__name__}")
 
     @abstractmethod
     def embedding_fn(self) -> EmbeddingFunction:

langroid/embedding_models/models.py

@@ -7,6 +7,7 @@ import requests
 import tiktoken
 from dotenv import load_dotenv
 from openai import AzureOpenAI, OpenAI
+from pydantic_settings import SettingsConfigDict
 
 from langroid.embedding_models.base import EmbeddingModel, EmbeddingModelsConfig
 from langroid.exceptions import LangroidImportError
@@ -27,10 +28,7 @@ class OpenAIEmbeddingsConfig(EmbeddingModelsConfig):
     context_length: int = 8192
     langdb_params: LangDBParams = LangDBParams()
 
-    class Config:
-        # enable auto-loading of env vars with OPENAI_ prefix, e.g.
-        # api_base is set from OPENAI_API_BASE env var, in .env or system env
-        env_prefix = "OPENAI_"
+    model_config = SettingsConfigDict(env_prefix="OPENAI_")
 
 
 class AzureOpenAIEmbeddingsConfig(EmbeddingModelsConfig):
@@ -48,9 +46,7 @@ class AzureOpenAIEmbeddingsConfig(EmbeddingModelsConfig):
     dims: int = 1536
     context_length: int = 8192
 
-    class Config:
-        # enable auto-loading of env vars with AZURE_OPENAI_ prefix
-        env_prefix = "AZURE_OPENAI_"
+    model_config = SettingsConfigDict(env_prefix="AZURE_OPENAI_")
 
 
 class SentenceTransformerEmbeddingsConfig(EmbeddingModelsConfig):

langroid/exceptions.py

@@ -1,4 +1,7 @@
-from typing import List, Optional
+from typing import TYPE_CHECKING, List, Optional
+
+if TYPE_CHECKING:
+    pass
 
 
 class XMLException(Exception):

langroid/language_models/azure_openai.py

@@ -4,6 +4,7 @@ from typing import Callable
 from dotenv import load_dotenv
 from httpx import Timeout
 from openai import AsyncAzureOpenAI, AzureOpenAI
+from pydantic_settings import SettingsConfigDict
 
 from langroid.language_models.openai_gpt import (
     OpenAIGPT,
@@ -56,8 +57,7 @@ class AzureConfig(OpenAIGPTConfig):
     # AZURE_OPENAI_API_VERSION=2023-05-15
     # This is either done in the .env file, or via an explicit
     # `export AZURE_OPENAI_API_VERSION=...`
-    class Config:
-        env_prefix = "AZURE_OPENAI_"
+    model_config = SettingsConfigDict(env_prefix="AZURE_OPENAI_")
 
     def __init__(self, **kwargs) -> None:  # type: ignore
         if "model_name" in kwargs and "chat_model" not in kwargs:

langroid/language_models/base.py

@@ -17,6 +17,9 @@ from typing import (
     cast,
 )
 
+from pydantic import BaseModel, Field
+from pydantic_settings import BaseSettings
+
 from langroid.cachedb.base import CacheDBConfig
 from langroid.cachedb.redis_cachedb import RedisCacheConfig
 from langroid.language_models.model_info import ModelInfo, get_model_info
@@ -24,7 +27,6 @@ from langroid.parsing.agent_chats import parse_message
 from langroid.parsing.file_attachment import FileAttachment
 from langroid.parsing.parse_json import parse_imperfect_json, top_level_json_field
 from langroid.prompts.dialog import collate_chat_history
-from langroid.pydantic_v1 import BaseModel, BaseSettings, Field
 from langroid.utils.configuration import settings
 from langroid.utils.output.printing import show_if_debug
 
@@ -140,7 +142,7 @@ class LLMFunctionCall(BaseModel):
         return fun_call
 
     def __str__(self) -> str:
-        return "FUNC: " + json.dumps(self.dict(), indent=2)
+        return "FUNC: " + json.dumps(self.model_dump(), indent=2)
 
 
 class LLMFunctionSpec(BaseModel):
@@ -186,7 +188,7 @@ class OpenAIToolCall(BaseModel):
     def __str__(self) -> str:
         if self.function is None:
             return ""
-        return "OAI-TOOL: " + json.dumps(self.function.dict(), indent=2)
+        return "OAI-TOOL: " + json.dumps(self.function.model_dump(), indent=2)
 
 
 class OpenAIToolSpec(BaseModel):
@@ -292,7 +294,7 @@ class LLMMessage(BaseModel):
         Returns:
             dict: dictionary representation of LLM message
         """
-        d = self.dict()
+        d = self.model_dump()
         files: List[FileAttachment] = d.pop("files")
         if len(files) > 0 and self.role == Role.USER:
             # In there are files, then content is an array of

langroid/language_models/config.py

@@ -1,12 +1,10 @@
-from langroid.pydantic_v1 import BaseSettings
+from pydantic_settings import BaseSettings, SettingsConfigDict
 
 
 class PromptFormatterConfig(BaseSettings):
     type: str = "llama2"
 
-    class Config:
-        env_prefix = "FORMAT_"
-        case_sensitive = False
+    model_config = SettingsConfigDict(env_prefix="FORMAT_", case_sensitive=False)
 
 
 class Llama2FormatterConfig(PromptFormatterConfig):

langroid/language_models/model_info.py

@@ -1,7 +1,7 @@
 from enum import Enum
 from typing import Dict, List, Optional
 
-from langroid.pydantic_v1 import BaseModel
+from pydantic import BaseModel
 
 
 class ModelProvider(str, Enum):
@@ -173,6 +173,7 @@ MODEL_INFO: Dict[str, ModelInfo] = {
     OpenAIChatModel.GPT4_1_NANO.value: ModelInfo(
         name=OpenAIChatModel.GPT4_1_NANO.value,
         provider=ModelProvider.OPENAI,
+        has_structured_output=True,
         context_length=1_047_576,
         max_output_tokens=32_768,
         input_cost_per_million=0.10,
@@ -183,6 +184,7 @@ MODEL_INFO: Dict[str, ModelInfo] = {
     OpenAIChatModel.GPT4_1_MINI.value: ModelInfo(
         name=OpenAIChatModel.GPT4_1_MINI.value,
         provider=ModelProvider.OPENAI,
+        has_structured_output=True,
         context_length=1_047_576,
         max_output_tokens=32_768,
         input_cost_per_million=0.40,
@@ -193,6 +195,7 @@ MODEL_INFO: Dict[str, ModelInfo] = {
     OpenAIChatModel.GPT4_1.value: ModelInfo(
         name=OpenAIChatModel.GPT4_1.value,
         provider=ModelProvider.OPENAI,
+        has_structured_output=True,
         context_length=1_047_576,
         max_output_tokens=32_768,
         input_cost_per_million=2.00,
@@ -232,6 +235,7 @@ MODEL_INFO: Dict[str, ModelInfo] = {
         output_cost_per_million=60.0,
         allows_streaming=True,
         allows_system_message=False,
+        has_structured_output=True,
         unsupported_params=["temperature"],
         rename_params={"max_tokens": "max_completion_tokens"},
         has_tools=False,
@@ -247,6 +251,7 @@ MODEL_INFO: Dict[str, ModelInfo] = {
         output_cost_per_million=8.0,
         allows_streaming=True,
         allows_system_message=False,
+        has_structured_output=True,
         unsupported_params=["temperature"],
         rename_params={"max_tokens": "max_completion_tokens"},
         has_tools=False,
@@ -262,6 +267,7 @@ MODEL_INFO: Dict[str, ModelInfo] = {
         output_cost_per_million=4.4,
         allows_streaming=False,
         allows_system_message=False,
+        has_structured_output=True,
         unsupported_params=["temperature", "stream"],
         rename_params={"max_tokens": "max_completion_tokens"},
         has_tools=False,
@@ -277,6 +283,7 @@ MODEL_INFO: Dict[str, ModelInfo] = {
         output_cost_per_million=4.4,
         allows_streaming=False,
         allows_system_message=False,
+        has_structured_output=True,
         unsupported_params=["temperature", "stream"],
         rename_params={"max_tokens": "max_completion_tokens"},
         has_tools=False,
@@ -292,6 +299,7 @@ MODEL_INFO: Dict[str, ModelInfo] = {
         output_cost_per_million=4.40,
         allows_streaming=False,
         allows_system_message=False,
+        has_structured_output=True,
         unsupported_params=["temperature", "stream"],
         rename_params={"max_tokens": "max_completion_tokens"},
         has_tools=False,