langroid 0.58.3__py3-none-any.whl → 0.59.0__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

langroid/agent/callbacks/chainlit.py

@@ -16,8 +16,9 @@ from typing import (
     no_type_check,
 )
 
+from pydantic_settings import BaseSettings
+
 from langroid.exceptions import LangroidImportError
-from langroid.pydantic_v1 import BaseSettings
 
 try:
     import chainlit as cl

langroid/agent/chat_agent.py

@@ -8,6 +8,8 @@ from inspect import isclass
 from typing import Any, Dict, List, Optional, Self, Set, Tuple, Type, Union, cast
 
 import openai
+from pydantic import BaseModel, ValidationError
+from pydantic.fields import ModelPrivateAttr
 from rich import print
 from rich.console import Console
 from rich.markup import escape
@@ -32,7 +34,6 @@ from langroid.language_models.base import (
 )
 from langroid.language_models.openai_gpt import OpenAIGPT
 from langroid.mytypes import Entity, NonToolAction
-from langroid.pydantic_v1 import BaseModel, ValidationError
 from langroid.utils.configuration import settings
 from langroid.utils.object_registry import ObjectRegistry
 from langroid.utils.output import status
@@ -730,7 +731,10 @@ class ChatAgent(Agent):
 
             if use:
                 tool_class = self.llm_tools_map[t]
-                if tool_class._allow_llm_use:
+                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:
                     self.llm_tools_usable.add(t)
                     self.llm_functions_usable.add(t)
                 else:
@@ -844,7 +848,7 @@ class ChatAgent(Agent):
                 use_functions_api,
                 use_tools,
             ) = self.saved_requests_and_tool_setings
-            self.config = self.config.copy()
+            self.config = self.config.model_copy()
             self.enabled_requests_for_inference = requests_for_inference
             self.config.use_functions_api = use_functions_api
             self.config.use_tools = use_tools
@@ -884,15 +888,13 @@ class ChatAgent(Agent):
                         if use:
                             # We must copy `llm_tools_usable` so the base agent
                             # is unmodified
-                            self.llm_tools_usable = copy.copy(self.llm_tools_usable)
-                            self.llm_functions_usable = copy.copy(
-                                self.llm_functions_usable
-                            )
+                            self.llm_tools_usable = self.llm_tools_usable.copy()
+                            self.llm_functions_usable = self.llm_functions_usable.copy()
                         if handle:
                             # If handling the tool, do the same for `llm_tools_handled`
-                            self.llm_tools_handled = copy.copy(self.llm_tools_handled)
-                            self.llm_functions_handled = copy.copy(
-                                self.llm_functions_handled
+                            self.llm_tools_handled = self.llm_tools_handled.copy()
+                            self.llm_functions_handled = (
+                                self.llm_functions_handled.copy()
                             )
                     # Enable `output_type`
                     self.enable_message(
@@ -941,7 +943,7 @@ class ChatAgent(Agent):
                             defaults=self.config.output_format_include_defaults,
                         ).parameters
                     else:
-                        output_format_schema = output_type.schema()
+                        output_format_schema = output_type.model_json_schema()
 
                     format_schema_for_strict(output_format_schema)
 
@@ -960,7 +962,7 @@ class ChatAgent(Agent):
                         output_type.default_value("request")
                     }
                 if self.config.use_functions_api:
-                    self.config = self.config.copy()
+                    self.config = self.config.model_copy()
                     self.config.use_functions_api = False
                     self.config.use_tools = True
 
@@ -1010,7 +1012,7 @@ class ChatAgent(Agent):
         Args:
             message_class: The only ToolMessage class to allow
         """
-        request = message_class.__fields__["request"].default
+        request = message_class.model_fields["request"].default
         to_remove = [r for r in self.llm_tools_usable if r != request]
         for r in to_remove:
             self.llm_tools_usable.discard(r)
@@ -1054,7 +1056,7 @@ class ChatAgent(Agent):
 
                         content = attempt.arguments
 
-                    content_any = self.output_format.parse_obj(content)
+                    content_any = self.output_format.model_validate(content)
 
                     if issubclass(self.output_format, PydanticWrapper):
                         message.content_any = content_any.value  # type: ignore
@@ -1094,34 +1096,36 @@ class ChatAgent(Agent):
         try:
             tools = super().get_tool_messages(msg, all_tools)
         except ValidationError as ve:
-            tool_class = ve.model
-            if issubclass(tool_class, ToolMessage):
-                was_strict = (
-                    self.config.use_functions_api
-                    and self.config.use_tools_api
-                    and self._strict_mode_for_tool(tool_class)
-                )
-                # If the result of strict output for a tool using the
-                # OpenAI tools API fails to parse, we infer that the
-                # schema edits necessary for compatibility prevented
-                # adherence to the underlying `ToolMessage` schema and
-                # disable strict output for the tool
-                if was_strict:
-                    name = tool_class.default_value("request")
-                    self.disable_strict_tools_set.add(name)
-                    logging.warning(
-                        f"""
-                        Validation error occured with strict tool format.
-                        Disabling strict mode for the {name} tool.
-                        """
+            # Check if tool class was attached to the exception
+            if hasattr(ve, "tool_class") and ve.tool_class:
+                tool_class = ve.tool_class  # type: ignore
+                if issubclass(tool_class, ToolMessage):
+                    was_strict = (
+                        self.config.use_functions_api
+                        and self.config.use_tools_api
+                        and self._strict_mode_for_tool(tool_class)
                     )
-                else:
-                    # We will trigger the strict recovery mechanism to force
-                    # the LLM to correct its output, allowing us to parse
-                    if isinstance(msg, ChatDocument):
-                        self.tool_error = msg.metadata.sender == Entity.LLM
+                    # If the result of strict output for a tool using the
+                    # OpenAI tools API fails to parse, we infer that the
+                    # schema edits necessary for compatibility prevented
+                    # adherence to the underlying `ToolMessage` schema and
+                    # disable strict output for the tool
+                    if was_strict:
+                        name = tool_class.default_value("request")
+                        self.disable_strict_tools_set.add(name)
+                        logging.warning(
+                            f"""
+                            Validation error occured with strict tool format.
+                            Disabling strict mode for the {name} tool.
+                            """
+                        )
                     else:
-                        self.tool_error = most_recent_sent_by_llm
+                        # We will trigger the strict recovery mechanism to force
+                        # the LLM to correct its output, allowing us to parse
+                        if isinstance(msg, ChatDocument):
+                            self.tool_error = msg.metadata.sender == Entity.LLM
+                        else:
+                            self.tool_error = most_recent_sent_by_llm
 
             if was_llm:
                 raise ve
@@ -1168,7 +1172,9 @@ class ChatAgent(Agent):
                 request = self.tool.request
                 if request not in agent.llm_tools_map:
                     return None
-                tool = agent.llm_tools_map[request].parse_raw(self.tool.to_json())
+                tool = agent.llm_tools_map[request].model_validate_json(
+                    self.tool.to_json()
+                )
 
                 return agent.handle_tool_message(tool)
 
@@ -1187,7 +1193,9 @@ class ChatAgent(Agent):
                 request = self.tool.request
                 if request not in agent.llm_tools_map:
                     return None
-                tool = agent.llm_tools_map[request].parse_raw(self.tool.to_json())
+                tool = agent.llm_tools_map[request].model_validate_json(
+                    self.tool.to_json()
+                )
 
                 return await agent.handle_tool_message_async(tool)
 
@@ -1269,19 +1277,29 @@ class ChatAgent(Agent):
         """
         parent_message: ChatDocument | None = message.parent
         tools = [] if parent_message is None else parent_message.tool_messages
-        truncate_tools = [t for t in tools if t._max_retained_tokens is not None]
+        truncate_tools = []
+        for t in tools:
+            max_retained_tokens = t._max_retained_tokens
+            if isinstance(max_retained_tokens, ModelPrivateAttr):
+                max_retained_tokens = max_retained_tokens.default
+            if max_retained_tokens is not None:
+                truncate_tools.append(t)
         limiting_tool = truncate_tools[0] if len(truncate_tools) > 0 else None
-        if limiting_tool is not None and limiting_tool._max_retained_tokens is not None:
-            tool_name = limiting_tool.default_value("request")
-            max_tokens: int = limiting_tool._max_retained_tokens
-            truncation_warning = f"""
-                The result of the {tool_name} tool were too large, 
-                and has been truncated to {max_tokens} tokens.
-                To obtain the full result, the tool needs to be re-used.
-            """
-            self.truncate_message(
-                message.metadata.msg_idx, max_tokens, truncation_warning
-            )
+        if limiting_tool is not None:
+            max_retained_tokens = limiting_tool._max_retained_tokens
+            if isinstance(max_retained_tokens, ModelPrivateAttr):
+                max_retained_tokens = max_retained_tokens.default
+            if max_retained_tokens is not None:
+                tool_name = limiting_tool.default_value("request")
+                max_tokens: int = max_retained_tokens
+                truncation_warning = f"""
+                    The result of the {tool_name} tool were too large, 
+                    and has been truncated to {max_tokens} tokens.
+                    To obtain the full result, the tool needs to be re-used.
+                """
+                self.truncate_message(
+                    message.metadata.msg_idx, max_tokens, truncation_warning
+                )
 
     def llm_response(
         self, message: Optional[str | ChatDocument] = None
@@ -1743,7 +1761,7 @@ class ChatAgent(Agent):
                     function=spec,
                 )
             elif issubclass(self.output_format, BaseModel):
-                param_spec = self.output_format.schema()
+                param_spec = self.output_format.model_json_schema()
                 format_schema_for_strict(param_spec)
 
                 output_format = OpenAIJsonSchemaSpec(

langroid/agent/chat_document.py

@@ -6,6 +6,8 @@ from collections import OrderedDict
 from enum import Enum
 from typing import Any, Dict, List, Optional, Union, cast
 
+from pydantic import BaseModel, ConfigDict
+
 from langroid.agent.tool_message import ToolMessage
 from langroid.agent.xml_tool_message import XMLToolMessage
 from langroid.language_models.base import (
@@ -21,7 +23,6 @@ from langroid.mytypes import DocMetaData, Document, Entity
 from langroid.parsing.agent_chats import parse_message
 from langroid.parsing.file_attachment import FileAttachment
 from langroid.parsing.parse_json import extract_top_level_json, top_level_json_field
-from langroid.pydantic_v1 import BaseModel, Extra
 from langroid.utils.object_registry import ObjectRegistry
 from langroid.utils.output.printing import shorten_text
 from langroid.utils.types import to_string
@@ -29,8 +30,7 @@ from langroid.utils.types import to_string
 
 class ChatDocAttachment(BaseModel):
     # any additional data that should be attached to the document
-    class Config:
-        extra = Extra.allow
+    model_config = ConfigDict(extra="allow")
 
 
 class StatusCode(str, Enum):
@@ -89,7 +89,7 @@ class ChatDocLoggerFields(BaseModel):
 
     @classmethod
     def tsv_header(cls) -> str:
-        field_names = cls().dict().keys()
+        field_names = cls().model_dump().keys()
         return "\t".join(field_names)
 
 
@@ -259,7 +259,7 @@ class ChatDocument(Document):
     def tsv_str(self) -> str:
         fields = self.log_fields()
         fields.content = shorten_text(fields.content, 80)
-        field_values = fields.dict().values()
+        field_values = fields.model_dump().values()
         return "\t".join(str(v) for v in field_values)
 
     def pop_tool_ids(self) -> None:
@@ -510,5 +510,5 @@ class ChatDocument(Document):
         ]
 
 
-LLMMessage.update_forward_refs()
-ChatDocMetaData.update_forward_refs()
+LLMMessage.model_rebuild()
+ChatDocMetaData.model_rebuild()

langroid/agent/done_sequence_parser.py

@@ -11,16 +11,20 @@ Examples:
 """
 
 import re
-from typing import List, Union
+from typing import Any, Dict, List, Optional, Union
 
 from .task import AgentEvent, DoneSequence, EventType
 
 
-def parse_done_sequence(sequence: Union[str, DoneSequence]) -> DoneSequence:
+def parse_done_sequence(
+    sequence: Union[str, DoneSequence], tools_map: Optional[Dict[str, Any]] = None
+) -> DoneSequence:
     """Parse a string pattern or return existing DoneSequence unchanged.
 
     Args:
         sequence: Either a DoneSequence object or a string pattern to parse
+        tools_map: Optional dict mapping tool names to tool classes
+            (e.g., agent.llm_tools_map)
 
     Returns:
         DoneSequence object
@@ -34,21 +38,25 @@ def parse_done_sequence(sequence: Union[str, DoneSequence]) -> DoneSequence:
     if not isinstance(sequence, str):
         raise ValueError(f"Expected string or DoneSequence, got {type(sequence)}")
 
-    events = _parse_string_pattern(sequence)
+    events = _parse_string_pattern(sequence, tools_map)
     return DoneSequence(events=events)
 
 
-def _parse_string_pattern(pattern: str) -> List[AgentEvent]:
+def _parse_string_pattern(
+    pattern: str, tools_map: Optional[Dict[str, Any]] = None
+) -> List[AgentEvent]:
     """Parse a string pattern into a list of AgentEvent objects.
 
     Pattern format:
         - Single letter codes: T, A, L, U, N, C
-        - Specific tools: T[tool_name]
+        - Specific tools: T[tool_name] or T[ToolClass]
         - Content match: C[regex_pattern]
         - Separated by commas, spaces allowed
 
     Args:
         pattern: String pattern to parse
+        tools_map: Optional dict mapping tool names to tool classes
+            (e.g., agent.llm_tools_map)
 
     Returns:
         List of AgentEvent objects
@@ -65,7 +73,7 @@ def _parse_string_pattern(pattern: str) -> List[AgentEvent]:
         if not part:
             continue
 
-        event = _parse_event_token(part)
+        event = _parse_event_token(part, tools_map)
         events.append(event)
 
     if not events:
@@ -74,11 +82,15 @@ def _parse_string_pattern(pattern: str) -> List[AgentEvent]:
     return events
 
 
-def _parse_event_token(token: str) -> AgentEvent:
+def _parse_event_token(
+    token: str, tools_map: Optional[Dict[str, Any]] = None
+) -> AgentEvent:
     """Parse a single event token into an AgentEvent.
 
     Args:
         token: Single event token (e.g., "T", "T[calc]", "C[quit|exit]")
+        tools_map: Optional dict mapping tool names to tool classes
+            (e.g., agent.llm_tools_map)
 
     Returns:
         AgentEvent object
@@ -94,8 +106,28 @@ def _parse_event_token(token: str) -> AgentEvent:
         param = bracket_match.group(2)
 
         if event_code == "T":
-            # Specific tool: T[tool_name]
-            return AgentEvent(event_type=EventType.SPECIFIC_TOOL, tool_name=param)
+            # Specific tool: T[tool_name] or T[ToolClass]
+            tool_class = None
+            tool_name = param
+
+            # First try direct lookup in tools_map by the param (tool name)
+            if tools_map and param in tools_map:
+                tool_class = tools_map[param]
+                tool_name = param
+            elif tools_map:
+                # If not found, loop through tools_map to find a tool class
+                # whose __name__ matches param
+                for name, cls in tools_map.items():
+                    if hasattr(cls, "__name__") and cls.__name__ == param:
+                        tool_class = cls
+                        tool_name = name
+                        break
+
+            return AgentEvent(
+                event_type=EventType.SPECIFIC_TOOL,
+                tool_name=tool_name,
+                tool_class=tool_class,
+            )
         elif event_code == "C":
             # Content match: C[regex_pattern]
             return AgentEvent(event_type=EventType.CONTENT_MATCH, content_pattern=param)
@@ -136,14 +168,17 @@ def _parse_event_token(token: str) -> AgentEvent:
 
 
 def parse_done_sequences(
-    sequences: List[Union[str, DoneSequence]]
+    sequences: List[Union[str, DoneSequence]],
+    tools_map: Optional[Dict[str, Any]] = None,
 ) -> List[DoneSequence]:
     """Parse a list of mixed string patterns and DoneSequence objects.
 
     Args:
         sequences: List containing strings and/or DoneSequence objects
+        tools_map: Optional dict mapping tool names to tool classes
+            (e.g., agent.llm_tools_map)
 
     Returns:
         List of DoneSequence objects
     """
-    return [parse_done_sequence(seq) for seq in sequences]
+    return [parse_done_sequence(seq, tools_map) for seq in sequences]

langroid/agent/openai_assistant.py

@@ -15,6 +15,7 @@ from openai.types.beta.assistant_update_params import (
 )
 from openai.types.beta.threads import Message, Run
 from openai.types.beta.threads.runs import RunStep
+from pydantic import BaseModel
 from rich import print
 
 from langroid.agent.chat_agent import ChatAgent, ChatAgentConfig
@@ -26,7 +27,6 @@ from langroid.language_models.openai_gpt import (
     OpenAIGPT,
     OpenAIGPTConfig,
 )
-from langroid.pydantic_v1 import BaseModel
 from langroid.utils.configuration import settings
 from langroid.utils.system import generate_user_id, update_hash
 
@@ -44,7 +44,7 @@ class AssistantTool(BaseModel):
     function: Dict[str, Any] | None = None
 
     def dct(self) -> Dict[str, Any]:
-        d = super().dict()
+        d = super().model_dump()
         d["type"] = d["type"].value
         if self.type != ToolType.FUNCTION:
             d.pop("function")
@@ -72,14 +72,14 @@ class RunStatus(str, Enum):
 class OpenAIAssistantConfig(ChatAgentConfig):
     use_cached_assistant: bool = False  # set in script via user dialog
     assistant_id: str | None = None
-    use_tools = False
-    use_functions_api = True
+    use_tools: bool = False
+    use_functions_api: bool = True
     use_cached_thread: bool = False  # set in script via user dialog
     thread_id: str | None = None
     # set to True once we can add Assistant msgs in threads
     cache_responses: bool = True
     timeout: int = 30  # can be different from llm.timeout
-    llm = OpenAIGPTConfig(chat_model=OpenAIChatModel.GPT4o)
+    llm: OpenAIGPTConfig = OpenAIGPTConfig(chat_model=OpenAIChatModel.GPT4o)
     tools: List[AssistantTool] = []
     files: List[str] = []
 
@@ -214,7 +214,7 @@ class OpenAIAssistant(ChatAgent):
             [
                 {
                     "type": "function",  # type: ignore
-                    "function": f.dict(),
+                    "function": f.model_dump(),
                 }
                 for f in functions
             ]
@@ -272,7 +272,7 @@ class OpenAIAssistant(ChatAgent):
         cached_dict = self.llm.cache.retrieve(key)
         if cached_dict is None:
             return None
-        return LLMResponse.parse_obj(cached_dict)
+        return LLMResponse.model_validate(cached_dict)
 
     def _cache_store(self) -> None:
         """
@@ -638,7 +638,7 @@ class OpenAIAssistant(ChatAgent):
             cached=False,  # TODO - revisit when able to insert Assistant responses
         )
         if self.llm.cache is not None:
-            self.llm.cache.store(key, result.dict())
+            self.llm.cache.store(key, result.model_dump())
         return result
 
     def _parse_run_required_action(self) -> List[AssistantToolCall]:
@@ -773,7 +773,7 @@ class OpenAIAssistant(ChatAgent):
             # it looks like assistant produced it
             if self.config.cache_responses:
                 self._add_thread_message(
-                    json.dumps(response.dict()), role=Role.ASSISTANT
+                    json.dumps(response.model_dump()), role=Role.ASSISTANT
                 )
             return response  # type: ignore
         else: