letta-nightly 0.6.4.dev20241216104246__py3-none-any.whl → 0.6.4.dev20241217104233__py3-none-any.whl

letta/server/server.py

@@ -19,7 +19,6 @@ from letta.agent import Agent, save_agent
 from letta.chat_only_agent import ChatOnlyAgent
 from letta.credentials import LettaCredentials
 from letta.data_sources.connectors import DataConnector, load_data
-from letta.errors import LettaAgentNotFoundError
 
 # TODO use custom interface
 from letta.interface import AgentInterface  # abstract
@@ -399,9 +398,6 @@ class SyncServer(Server):
         with agent_lock:
             agent_state = self.agent_manager.get_agent_by_id(agent_id=agent_id, actor=actor)
 
-            if agent_state is None:
-                raise LettaAgentNotFoundError(f"Agent (agent_id={agent_id}) does not exist")
-
             interface = interface or self.default_interface_factory()
             if agent_state.agent_type == AgentType.memgpt_agent:
                 agent = Agent(agent_state=agent_state, interface=interface, user=actor)
@@ -824,13 +820,13 @@ class SyncServer(Server):
         actor: User,
     ) -> AgentState:
         """Update the agents core memory block, return the new state"""
+        # Update agent state in the db first
+        self.agent_manager.update_agent(agent_id=agent_id, agent_update=request, actor=actor)
+
         # Get the agent object (loaded in memory)
         letta_agent = self.load_agent(agent_id=agent_id, actor=actor)
 
-        # Update tags
-        if request.tags is not None:  # Allow for empty list
-            letta_agent.agent_state.tags = request.tags
-
+        # TODO: Everything below needs to get removed, no updating anything in memory
         # update the system prompt
         if request.system:
             letta_agent.update_system_prompt(request.system)
@@ -844,42 +840,10 @@ class SyncServer(Server):
 
         # tools
         if request.tool_ids:
-            # Replace tools and also re-link
-
-            # (1) get tools + make sure they exist
-            # Current and target tools as sets of tool names
-            current_tools = letta_agent.agent_state.tools
-            current_tool_ids = set([t.id for t in current_tools])
-            target_tool_ids = set(request.tool_ids)
-
-            # Calculate tools to add and remove
-            tool_ids_to_add = target_tool_ids - current_tool_ids
-            tools_ids_to_remove = current_tool_ids - target_tool_ids
-
-            # update agent tool list
-            for tool_id in tools_ids_to_remove:
-                self.remove_tool_from_agent(agent_id=agent_id, tool_id=tool_id, user_id=actor.id)
-            for tool_id in tool_ids_to_add:
-                self.add_tool_to_agent(agent_id=agent_id, tool_id=tool_id, user_id=actor.id)
-
-            # reload agent
-            letta_agent = self.load_agent(agent_id=agent_id, actor=actor)
-
-        # configs
-        if request.llm_config:
-            letta_agent.agent_state.llm_config = request.llm_config
-        if request.embedding_config:
-            letta_agent.agent_state.embedding_config = request.embedding_config
-
-        # other minor updates
-        if request.name:
-            letta_agent.agent_state.name = request.name
-        if request.metadata_:
-            letta_agent.agent_state.metadata_ = request.metadata_
-
-        # save the agent
-        save_agent(letta_agent)
-        # TODO: probably reload the agent somehow?
+            letta_agent.link_tools(letta_agent.agent_state.tools)
+
+        letta_agent.update_state()
+
         return letta_agent.agent_state
 
     def get_tools_from_agent(self, agent_id: str, user_id: Optional[str]) -> List[Tool]:
@@ -901,32 +865,14 @@ class SyncServer(Server):
         # TODO: Thread actor directly through this function, since the top level caller most likely already retrieved the user
         actor = self.user_manager.get_user_or_default(user_id=user_id)
 
+        agent_state = self.agent_manager.attach_tool(agent_id=agent_id, tool_id=tool_id, actor=actor)
+
+        # TODO: This is very redundant, and should probably be simplified
         # Get the agent object (loaded in memory)
         letta_agent = self.load_agent(agent_id=agent_id, actor=actor)
+        letta_agent.link_tools(agent_state.tools)
 
-        # Get all the tool objects from the request
-        tool_objs = []
-        tool_obj = self.tool_manager.get_tool_by_id(tool_id=tool_id, actor=actor)
-        assert tool_obj, f"Tool with id={tool_id} does not exist"
-        tool_objs.append(tool_obj)
-
-        for tool in letta_agent.agent_state.tools:
-            tool_obj = self.tool_manager.get_tool_by_id(tool_id=tool.id, actor=actor)
-            assert tool_obj, f"Tool with id={tool.id} does not exist"
-
-            # If it's not the already added tool
-            if tool_obj.id != tool_id:
-                tool_objs.append(tool_obj)
-
-        # replace the list of tool names ("ids") inside the agent state
-        letta_agent.agent_state.tools = tool_objs
-
-        # then attempt to link the tools modules
-        letta_agent.link_tools(tool_objs)
-
-        # save the agent
-        save_agent(letta_agent)
-        return letta_agent.agent_state
+        return agent_state
 
     def remove_tool_from_agent(
         self,
@@ -937,29 +883,13 @@ class SyncServer(Server):
         """Remove tools from an existing agent"""
         # TODO: Thread actor directly through this function, since the top level caller most likely already retrieved the user
         actor = self.user_manager.get_user_or_default(user_id=user_id)
+        agent_state = self.agent_manager.detach_tool(agent_id=agent_id, tool_id=tool_id, actor=actor)
 
         # Get the agent object (loaded in memory)
         letta_agent = self.load_agent(agent_id=agent_id, actor=actor)
+        letta_agent.link_tools(agent_state.tools)
 
-        # Get all the tool_objs
-        tool_objs = []
-        for tool in letta_agent.agent_state.tools:
-            tool_obj = self.tool_manager.get_tool_by_id(tool_id=tool.id, actor=actor)
-            assert tool_obj, f"Tool with id={tool.id} does not exist"
-
-            # If it's not the tool we want to remove
-            if tool_obj.id != tool_id:
-                tool_objs.append(tool_obj)
-
-        # replace the list of tool names ("ids") inside the agent state
-        letta_agent.agent_state.tools = tool_objs
-
-        # then attempt to link the tools modules
-        letta_agent.link_tools(tool_objs)
-
-        # save the agent
-        save_agent(letta_agent)
-        return letta_agent.agent_state
+        return agent_state
 
     # convert name->id
 
@@ -970,7 +900,7 @@ class SyncServer(Server):
 
     def get_archival_memory_summary(self, agent_id: str, actor: User) -> ArchivalMemorySummary:
         agent = self.load_agent(agent_id=agent_id, actor=actor)
-        return ArchivalMemorySummary(size=agent.passage_manager.size(actor=self.default_user))
+        return ArchivalMemorySummary(size=self.agent_manager.passage_size(actor=actor, agent_id=agent_id))
 
     def get_recall_memory_summary(self, agent_id: str, actor: User) -> RecallMemorySummary:
         agent = self.load_agent(agent_id=agent_id, actor=actor)
@@ -987,18 +917,9 @@ class SyncServer(Server):
         # TODO: Thread actor directly through this function, since the top level caller most likely already retrieved the user
         actor = self.user_manager.get_user_or_default(user_id=user_id)
 
-        # Get the agent object (loaded in memory)
-        letta_agent = self.load_agent(agent_id=agent_id, actor=actor)
-
-        # iterate over records
-        records = letta_agent.passage_manager.list_passages(
-            actor=actor,
-            agent_id=agent_id,
-            cursor=cursor,
-            limit=limit,
-        )
+        passages = self.agent_manager.list_passages(agent_id=agent_id, actor=actor)
 
-        return records
+        return passages
 
     def get_agent_archival_cursor(
         self,
@@ -1012,15 +933,13 @@ class SyncServer(Server):
         # TODO: Thread actor directly through this function, since the top level caller most likely already retrieved the user
         actor = self.user_manager.get_user_or_default(user_id=user_id)
 
-        # Get the agent object (loaded in memory)
-        letta_agent = self.load_agent(agent_id=agent_id, actor=actor)
-
         # iterate over records
-        records = letta_agent.passage_manager.list_passages(
-            actor=self.default_user,
+        records = self.agent_manager.list_passages(
+            actor=actor,
             agent_id=agent_id,
             cursor=cursor,
             limit=limit,
+            ascending=not reverse,
         )
         return records
 
@@ -1105,7 +1024,7 @@ class SyncServer(Server):
                     config_copy[k] = server_utils.shorten_key_middle(v, chars_each_side=5)
             return config_copy
 
-        # TODO: do we need a seperate server config?
+        # TODO: do we need a separate server config?
         base_config = vars(self.config)
         clean_base_config = clean_keys(base_config)
 
@@ -1136,7 +1055,8 @@ class SyncServer(Server):
         self.source_manager.delete_source(source_id=source_id, actor=actor)
 
         # delete data from passage store
-        self.passage_manager.delete_passages(actor=actor, limit=None, source_id=source_id)
+        passages_to_be_deleted = self.agent_manager.list_passages(actor=actor, source_id=source_id, limit=None)
+        self.passage_manager.delete_passages(actor=actor, passages=passages_to_be_deleted)
 
         # TODO: delete data from agent passage stores (?)
 
@@ -1167,9 +1087,11 @@ class SyncServer(Server):
         for agent_state in agent_states:
             agent_id = agent_state.id
             agent = self.load_agent(agent_id=agent_id, actor=actor)
-            curr_passage_size = self.passage_manager.size(actor=actor, agent_id=agent_id, source_id=source_id)
+
+            # Attach source to agent
+            curr_passage_size = self.agent_manager.passage_size(actor=actor, agent_id=agent_id)
             agent.attach_source(user=actor, source_id=source_id, source_manager=self.source_manager, agent_manager=self.agent_manager)
-            new_passage_size = self.passage_manager.size(actor=actor, agent_id=agent_id, source_id=source_id)
+            new_passage_size = self.agent_manager.passage_size(actor=actor, agent_id=agent_id)
             assert new_passage_size >= curr_passage_size  # in case empty files are added
 
         return job
@@ -1233,14 +1155,9 @@ class SyncServer(Server):
             source = self.source_manager.get_source_by_id(source_id=source_id, actor=actor)
         elif source_name:
             source = self.source_manager.get_source_by_name(source_name=source_name, actor=actor)
+            source_id = source.id
         else:
             raise ValueError(f"Need to provide at least source_id or source_name to find the source.")
-        source_id = source.id
-
-        # TODO: This should be done with the ORM?
-        # delete all Passage objects with source_id==source_id from agent's archival memory
-        agent = self.load_agent(agent_id=agent_id, actor=actor)
-        agent.passage_manager.delete_passages(actor=actor, limit=100, source_id=source_id)
 
         # delete agent-source mapping
         self.agent_manager.detach_source(agent_id=agent_id, source_id=source_id, actor=actor)
@@ -1262,7 +1179,7 @@ class SyncServer(Server):
         for source in sources:
 
             # count number of passages
-            num_passages = self.passage_manager.size(actor=actor, source_id=source.id)
+            num_passages = self.agent_manager.passage_size(actor=actor, source_id=source.id)
 
             # TODO: add when files table implemented
             ## count number of files

letta/server/ws_api/server.py

@@ -33,7 +33,7 @@ class WebSocketServer:
         self.initialize_server()
         # Can play with ping_interval and ping_timeout
         # See: https://websockets.readthedocs.io/en/stable/topics/timeouts.html
-        # and https://github.com/cpacker/Letta/issues/471
+        # and https://github.com/letta-ai/letta/issues/471
         async with websockets.serve(self.handle_client, self.host, self.port):
             await asyncio.Future()  # Run forever
 

letta/services/agent_manager.py

@@ -1,16 +1,26 @@
 from typing import Dict, List, Optional
+from datetime import datetime
+import numpy as np
 
-from letta.constants import BASE_MEMORY_TOOLS, BASE_TOOLS
+from sqlalchemy import select, union_all, literal, func, Select
+
+from letta.constants import BASE_MEMORY_TOOLS, BASE_TOOLS, MAX_EMBEDDING_DIM
+from letta.embeddings import embedding_model
+from letta.log import get_logger
 from letta.orm import Agent as AgentModel
 from letta.orm import Block as BlockModel
 from letta.orm import Source as SourceModel
 from letta.orm import Tool as ToolModel
+from letta.orm import AgentPassage, SourcePassage
+from letta.orm import SourcesAgents
 from letta.orm.errors import NoResultFound
+from letta.orm.sqlite_functions import adapt_array
 from letta.schemas.agent import AgentState as PydanticAgentState
 from letta.schemas.agent import AgentType, CreateAgent, UpdateAgent
 from letta.schemas.block import Block as PydanticBlock
 from letta.schemas.embedding_config import EmbeddingConfig
 from letta.schemas.llm_config import LLMConfig
+from letta.schemas.passage import Passage as PydanticPassage
 from letta.schemas.source import Source as PydanticSource
 from letta.schemas.tool_rule import ToolRule as PydanticToolRule
 from letta.schemas.user import User as PydanticUser
@@ -20,11 +30,13 @@ from letta.services.helpers.agent_manager_helper import (
     _process_tags,
     derive_system_message,
 )
-from letta.services.passage_manager import PassageManager
 from letta.services.source_manager import SourceManager
 from letta.services.tool_manager import ToolManager
+from letta.settings import settings
 from letta.utils import enforce_types
 
+logger = get_logger(__name__)
+
 
 # Agent Manager Class
 class AgentManager:
@@ -226,13 +238,6 @@ class AgentManager:
         with self.session_maker() as session:
             # Retrieve the agent
             agent = AgentModel.read(db_session=session, identifier=agent_id, actor=actor)
-
-            # TODO: @mindy delete this piece when we have a proper passages/sources implementation
-            # TODO: This is done very hacky on purpose
-            # TODO: 1000 limit is also wack
-            passage_manager = PassageManager()
-            passage_manager.delete_passages(actor=actor, agent_id=agent_id, limit=1000)
-
             agent_state = agent.to_pydantic()
             agent.hard_delete(session)
             return agent_state
@@ -403,3 +408,330 @@ class AgentManager:
 
             agent.update(session, actor=actor)
             return agent.to_pydantic()
+
+    # ======================================================================================================================
+    # Passage Management
+    # ======================================================================================================================
+    def _build_passage_query(
+        self,
+        actor: PydanticUser,
+        agent_id: Optional[str] = None,
+        file_id: Optional[str] = None,
+        query_text: Optional[str] = None,
+        start_date: Optional[datetime] = None,
+        end_date: Optional[datetime] = None,
+        cursor: Optional[str] = None,
+        source_id: Optional[str] = None,
+        embed_query: bool = False,
+        ascending: bool = True,
+        embedding_config: Optional[EmbeddingConfig] = None,
+        agent_only: bool = False,
+    ) -> Select:
+        """Helper function to build the base passage query with all filters applied.
+        
+        Returns the query before any limit or count operations are applied.
+        """
+        embedded_text = None
+        if embed_query:
+            assert embedding_config is not None, "embedding_config must be specified for vector search"
+            assert query_text is not None, "query_text must be specified for vector search"
+            embedded_text = embedding_model(embedding_config).get_text_embedding(query_text)
+            embedded_text = np.array(embedded_text)
+            embedded_text = np.pad(embedded_text, (0, MAX_EMBEDDING_DIM - embedded_text.shape[0]), mode="constant").tolist()
+
+        with self.session_maker() as session:
+            # Start with base query for source passages
+            source_passages = None
+            if not agent_only:  # Include source passages
+                if agent_id is not None:
+                    source_passages = (
+                        select(
+                            SourcePassage,
+                            literal(None).label('agent_id')
+                        )
+                        .join(SourcesAgents, SourcesAgents.source_id == SourcePassage.source_id)
+                        .where(SourcesAgents.agent_id == agent_id)
+                        .where(SourcePassage.organization_id == actor.organization_id)
+                    )
+                else:
+                    source_passages = (
+                        select(
+                            SourcePassage,
+                            literal(None).label('agent_id')
+                        )
+                        .where(SourcePassage.organization_id == actor.organization_id)
+                    )
+
+                if source_id:
+                    source_passages = source_passages.where(SourcePassage.source_id == source_id)
+                if file_id:
+                    source_passages = source_passages.where(SourcePassage.file_id == file_id)
+
+            # Add agent passages query
+            agent_passages = None
+            if agent_id is not None:
+                agent_passages = (
+                    select(
+                        AgentPassage.id,
+                        AgentPassage.text,
+                        AgentPassage.embedding_config,
+                        AgentPassage.metadata_,
+                        AgentPassage.embedding,
+                        AgentPassage.created_at,
+                        AgentPassage.updated_at,
+                        AgentPassage.is_deleted,
+                        AgentPassage._created_by_id,
+                        AgentPassage._last_updated_by_id,
+                        AgentPassage.organization_id,
+                        literal(None).label('file_id'),
+                        literal(None).label('source_id'),
+                        AgentPassage.agent_id
+                    )
+                    .where(AgentPassage.agent_id == agent_id)
+                    .where(AgentPassage.organization_id == actor.organization_id)
+                )
+
+            # Combine queries
+            if source_passages is not None and agent_passages is not None:
+                combined_query = union_all(source_passages, agent_passages).cte('combined_passages')
+            elif agent_passages is not None:
+                combined_query = agent_passages.cte('combined_passages')
+            elif source_passages is not None:
+                combined_query = source_passages.cte('combined_passages')
+            else:
+                raise ValueError("No passages found")
+
+            # Build main query from combined CTE
+            main_query = select(combined_query)
+
+            # Apply filters
+            if start_date:
+                main_query = main_query.where(combined_query.c.created_at >= start_date)
+            if end_date:
+                main_query = main_query.where(combined_query.c.created_at <= end_date)
+            if source_id:
+                main_query = main_query.where(combined_query.c.source_id == source_id)
+            if file_id:
+                main_query = main_query.where(combined_query.c.file_id == file_id)
+
+            # Vector search
+            if embedded_text:
+                if settings.letta_pg_uri_no_default:
+                    # PostgreSQL with pgvector
+                    main_query = main_query.order_by(
+                        combined_query.c.embedding.cosine_distance(embedded_text).asc()
+                    )
+                else:
+                    # SQLite with custom vector type
+                    query_embedding_binary = adapt_array(embedded_text)
+                    if ascending:
+                        main_query = main_query.order_by(
+                            func.cosine_distance(combined_query.c.embedding, query_embedding_binary).asc(),
+                            combined_query.c.created_at.asc(),
+                            combined_query.c.id.asc()
+                        )
+                    else:
+                        main_query = main_query.order_by(
+                            func.cosine_distance(combined_query.c.embedding, query_embedding_binary).asc(),
+                            combined_query.c.created_at.desc(),
+                            combined_query.c.id.asc()
+                        )
+            else:
+                if query_text:
+                    main_query = main_query.where(func.lower(combined_query.c.text).contains(func.lower(query_text)))
+
+            # Handle cursor-based pagination
+            if cursor:
+                cursor_query = select(combined_query.c.created_at).where(
+                    combined_query.c.id == cursor
+                ).scalar_subquery()
+                
+                if ascending:
+                    main_query = main_query.where(
+                        combined_query.c.created_at > cursor_query
+                    )
+                else:
+                    main_query = main_query.where(
+                        combined_query.c.created_at < cursor_query
+                    )
+
+            # Add ordering if not already ordered by similarity
+            if not embed_query:
+                if ascending:
+                    main_query = main_query.order_by(
+                        combined_query.c.created_at.asc(),
+                        combined_query.c.id.asc(),
+                    )
+                else:
+                    main_query = main_query.order_by(
+                        combined_query.c.created_at.desc(),
+                        combined_query.c.id.asc(),
+                    )
+
+            return main_query
+
+    @enforce_types
+    def list_passages(
+        self,
+        actor: PydanticUser,
+        agent_id: Optional[str] = None,
+        file_id: Optional[str] = None,
+        limit: Optional[int] = 50,
+        query_text: Optional[str] = None,
+        start_date: Optional[datetime] = None,
+        end_date: Optional[datetime] = None,
+        cursor: Optional[str] = None,
+        source_id: Optional[str] = None,
+        embed_query: bool = False,
+        ascending: bool = True,
+        embedding_config: Optional[EmbeddingConfig] = None,
+        agent_only: bool = False
+    ) -> List[PydanticPassage]:
+        """Lists all passages attached to an agent."""
+        with self.session_maker() as session:
+            main_query = self._build_passage_query(
+                actor=actor,
+                agent_id=agent_id,
+                file_id=file_id,
+                query_text=query_text,
+                start_date=start_date,
+                end_date=end_date,
+                cursor=cursor,
+                source_id=source_id,
+                embed_query=embed_query,
+                ascending=ascending,
+                embedding_config=embedding_config,
+                agent_only=agent_only,
+            )
+
+            # Add limit
+            if limit:
+                main_query = main_query.limit(limit)
+
+            # Execute query
+            results = list(session.execute(main_query))
+
+            passages = []
+            for row in results:
+                data = dict(row._mapping)
+                if data['agent_id'] is not None:
+                    # This is an AgentPassage - remove source fields
+                    data.pop('source_id', None)
+                    data.pop('file_id', None)
+                    passage = AgentPassage(**data)
+                else:
+                    # This is a SourcePassage - remove agent field
+                    data.pop('agent_id', None)
+                    passage = SourcePassage(**data)
+                passages.append(passage)
+            
+            return [p.to_pydantic() for p in passages]
+
+
+    @enforce_types
+    def passage_size(
+        self,
+        actor: PydanticUser,
+        agent_id: Optional[str] = None,
+        file_id: Optional[str] = None,
+        query_text: Optional[str] = None,
+        start_date: Optional[datetime] = None,
+        end_date: Optional[datetime] = None,
+        cursor: Optional[str] = None,
+        source_id: Optional[str] = None,
+        embed_query: bool = False,
+        ascending: bool = True,
+        embedding_config: Optional[EmbeddingConfig] = None,
+        agent_only: bool = False
+    ) -> int:
+        """Returns the count of passages matching the given criteria."""
+        with self.session_maker() as session:
+            main_query = self._build_passage_query(
+                actor=actor,
+                agent_id=agent_id,
+                file_id=file_id,
+                query_text=query_text,
+                start_date=start_date,
+                end_date=end_date,
+                cursor=cursor,
+                source_id=source_id,
+                embed_query=embed_query,
+                ascending=ascending,
+                embedding_config=embedding_config,
+                agent_only=agent_only,
+            )
+            
+            # Convert to count query
+            count_query = select(func.count()).select_from(main_query.subquery())
+            return session.scalar(count_query) or 0
+
+    # ======================================================================================================================
+    # Tool Management
+    # ======================================================================================================================
+    @enforce_types
+    def attach_tool(self, agent_id: str, tool_id: str, actor: PydanticUser) -> PydanticAgentState:
+        """
+        Attaches a tool to an agent.
+
+        Args:
+            agent_id: ID of the agent to attach the tool to.
+            tool_id: ID of the tool to attach.
+            actor: User performing the action.
+
+        Raises:
+            NoResultFound: If the agent or tool is not found.
+
+        Returns:
+            PydanticAgentState: The updated agent state.
+        """
+        with self.session_maker() as session:
+            # Verify the agent exists and user has permission to access it
+            agent = AgentModel.read(db_session=session, identifier=agent_id, actor=actor)
+
+            # Use the _process_relationship helper to attach the tool
+            _process_relationship(
+                session=session,
+                agent=agent,
+                relationship_name="tools",
+                model_class=ToolModel,
+                item_ids=[tool_id],
+                allow_partial=False,  # Ensure the tool exists
+                replace=False,  # Extend the existing tools
+            )
+
+            # Commit and refresh the agent
+            agent.update(session, actor=actor)
+            return agent.to_pydantic()
+
+    @enforce_types
+    def detach_tool(self, agent_id: str, tool_id: str, actor: PydanticUser) -> PydanticAgentState:
+        """
+        Detaches a tool from an agent.
+
+        Args:
+            agent_id: ID of the agent to detach the tool from.
+            tool_id: ID of the tool to detach.
+            actor: User performing the action.
+
+        Raises:
+            NoResultFound: If the agent or tool is not found.
+
+        Returns:
+            PydanticAgentState: The updated agent state.
+        """
+        with self.session_maker() as session:
+            # Verify the agent exists and user has permission to access it
+            agent = AgentModel.read(db_session=session, identifier=agent_id, actor=actor)
+
+            # Filter out the tool to be detached
+            remaining_tools = [tool for tool in agent.tools if tool.id != tool_id]
+
+            if len(remaining_tools) == len(agent.tools):  # Tool ID was not in the relationship
+                logger.warning(f"Attempted to remove unattached tool id={tool_id} from agent id={agent_id} by actor={actor}")
+
+            # Update the tools relationship
+            agent.tools = remaining_tools
+
+            # Commit and refresh the agent
+            agent.update(session, actor=actor)
+            return agent.to_pydantic()