letta-nightly 0.11.7.dev20251006104136__py3-none-any.whl → 0.11.7.dev20251008104128__py3-none-any.whl

letta/services/agent_manager.py

@@ -10,6 +10,7 @@ from sqlalchemy.dialects.postgresql import insert as pg_insert
 from letta.constants import (
     BASE_MEMORY_TOOLS,
     BASE_MEMORY_TOOLS_V2,
+    BASE_MEMORY_TOOLS_V3,
     BASE_SLEEPTIME_CHAT_TOOLS,
     BASE_SLEEPTIME_TOOLS,
     BASE_TOOLS,
@@ -73,7 +74,7 @@ from letta.serialize_schemas.marshmallow_tool import SerializedToolSchema
 from letta.serialize_schemas.pydantic_agent_schema import AgentSchema
 from letta.server.db import db_registry
 from letta.services.archive_manager import ArchiveManager
-from letta.services.block_manager import BlockManager
+from letta.services.block_manager import BlockManager, validate_block_limit_constraint
 from letta.services.context_window_calculator.context_window_calculator import ContextWindowCalculator
 from letta.services.context_window_calculator.token_counter import AnthropicTokenCounter, TiktokenCounter
 from letta.services.file_processor.chunker.line_chunker import LineChunker
@@ -301,185 +302,6 @@ class AgentManager:
     # ======================================================================================================================
     # Basic CRUD operations
     # ======================================================================================================================
-    @trace_method
-    def create_agent(self, agent_create: CreateAgent, actor: PydanticUser, _test_only_force_id: Optional[str] = None) -> PydanticAgentState:
-        # validate required configs
-        if not agent_create.llm_config or not agent_create.embedding_config:
-            raise ValueError("llm_config and embedding_config are required")
-
-        # blocks
-        block_ids = list(agent_create.block_ids or [])
-        if agent_create.memory_blocks:
-            pydantic_blocks = [PydanticBlock(**b.model_dump(to_orm=True)) for b in agent_create.memory_blocks]
-            created_blocks = self.block_manager.batch_create_blocks(
-                pydantic_blocks,
-                actor=actor,
-            )
-            block_ids.extend([blk.id for blk in created_blocks])
-
-        # tools
-        tool_names = set(agent_create.tools or [])
-        if agent_create.include_base_tools:
-            if agent_create.agent_type == AgentType.voice_sleeptime_agent:
-                tool_names |= set(BASE_VOICE_SLEEPTIME_TOOLS)
-            elif agent_create.agent_type == AgentType.voice_convo_agent:
-                tool_names |= set(BASE_VOICE_SLEEPTIME_CHAT_TOOLS)
-            elif agent_create.agent_type == AgentType.sleeptime_agent:
-                tool_names |= set(BASE_SLEEPTIME_TOOLS)
-            elif agent_create.enable_sleeptime:
-                tool_names |= set(BASE_SLEEPTIME_CHAT_TOOLS)
-            elif agent_create.agent_type == AgentType.memgpt_v2_agent:
-                tool_names |= calculate_base_tools(is_v2=True)
-            elif agent_create.agent_type == AgentType.react_agent:
-                pass  # no default tools
-            elif agent_create.agent_type == AgentType.workflow_agent:
-                pass  # no default tools
-            else:
-                tool_names |= calculate_base_tools(is_v2=False)
-        if agent_create.include_multi_agent_tools:
-            tool_names |= calculate_multi_agent_tools()
-
-        supplied_ids = set(agent_create.tool_ids or [])
-
-        source_ids = agent_create.source_ids or []
-        identity_ids = agent_create.identity_ids or []
-        tag_values = agent_create.tags or []
-
-        with db_registry.session() as session:
-            with session.begin():
-                name_to_id, id_to_name = self._resolve_tools(
-                    session,
-                    tool_names,
-                    supplied_ids,
-                    actor.organization_id,
-                )
-
-                tool_ids = set(name_to_id.values()) | set(id_to_name.keys())
-                tool_names = set(name_to_id.keys())  # now canonical
-
-                tool_rules = list(agent_create.tool_rules or [])
-
-                # Override include_base_tool_rules to False if model matches exclusion keywords and include_base_tool_rules is not explicitly set to True
-                if (
-                    (
-                        self._should_exclude_model_from_base_tool_rules(agent_create.llm_config.model)
-                        and agent_create.include_base_tool_rules is None
-                    )
-                    and agent_create.agent_type != AgentType.sleeptime_agent
-                ) or agent_create.include_base_tool_rules is False:
-                    agent_create.include_base_tool_rules = False
-                    logger.info(f"Overriding include_base_tool_rules to False for model: {agent_create.llm_config.model}")
-                else:
-                    agent_create.include_base_tool_rules = True
-
-                should_add_base_tool_rules = agent_create.include_base_tool_rules
-                if should_add_base_tool_rules:
-                    for tn in tool_names:
-                        if tn in {"send_message", "send_message_to_agent_async", "memory_finish_edits"}:
-                            tool_rules.append(TerminalToolRule(tool_name=tn))
-                        elif tn in (BASE_TOOLS + BASE_MEMORY_TOOLS + BASE_MEMORY_TOOLS_V2 + BASE_SLEEPTIME_TOOLS):
-                            tool_rules.append(ContinueToolRule(tool_name=tn))
-
-                if tool_rules:
-                    check_supports_structured_output(model=agent_create.llm_config.model, tool_rules=tool_rules)
-
-                new_agent = AgentModel(
-                    name=agent_create.name,
-                    system=derive_system_message(
-                        agent_type=agent_create.agent_type,
-                        enable_sleeptime=agent_create.enable_sleeptime,
-                        system=agent_create.system,
-                    ),
-                    hidden=agent_create.hidden,
-                    agent_type=agent_create.agent_type,
-                    llm_config=agent_create.llm_config,
-                    embedding_config=agent_create.embedding_config,
-                    organization_id=actor.organization_id,
-                    description=agent_create.description,
-                    metadata_=agent_create.metadata,
-                    tool_rules=tool_rules,
-                    project_id=agent_create.project_id,
-                    template_id=agent_create.template_id,
-                    base_template_id=agent_create.base_template_id,
-                    message_buffer_autoclear=agent_create.message_buffer_autoclear,
-                    enable_sleeptime=agent_create.enable_sleeptime,
-                    response_format=agent_create.response_format,
-                    created_by_id=actor.id,
-                    last_updated_by_id=actor.id,
-                    timezone=agent_create.timezone,
-                    max_files_open=agent_create.max_files_open,
-                    per_file_view_window_char_limit=agent_create.per_file_view_window_char_limit,
-                )
-
-                # Set template fields for InternalTemplateAgentCreate (similar to group creation)
-                if isinstance(agent_create, InternalTemplateAgentCreate):
-                    new_agent.base_template_id = agent_create.base_template_id
-                    new_agent.template_id = agent_create.template_id
-                    new_agent.deployment_id = agent_create.deployment_id
-                    new_agent.entity_id = agent_create.entity_id
-
-                if _test_only_force_id:
-                    new_agent.id = _test_only_force_id
-
-                session.add(new_agent)
-                session.flush()
-                aid = new_agent.id
-
-                # Note: These methods may need async versions if they perform database operations
-                self._bulk_insert_pivot(
-                    session,
-                    ToolsAgents.__table__,
-                    [{"agent_id": aid, "tool_id": tid} for tid in tool_ids],
-                )
-
-                if block_ids:
-                    result = session.execute(select(BlockModel.id, BlockModel.label).where(BlockModel.id.in_(block_ids)))
-                    rows = [{"agent_id": aid, "block_id": bid, "block_label": lbl} for bid, lbl in result.all()]
-                    self._bulk_insert_pivot(session, BlocksAgents.__table__, rows)
-
-                self._bulk_insert_pivot(
-                    session,
-                    SourcesAgents.__table__,
-                    [{"agent_id": aid, "source_id": sid} for sid in source_ids],
-                )
-                self._bulk_insert_pivot(
-                    session,
-                    AgentsTags.__table__,
-                    [{"agent_id": aid, "tag": tag} for tag in tag_values],
-                )
-                self._bulk_insert_pivot(
-                    session,
-                    IdentitiesAgents.__table__,
-                    [{"agent_id": aid, "identity_id": iid} for iid in identity_ids],
-                )
-
-                agent_secrets = agent_create.secrets or agent_create.tool_exec_environment_variables
-                if agent_secrets:
-                    env_rows = [
-                        {
-                            "agent_id": aid,
-                            "key": key,
-                            "value": val,
-                            "organization_id": actor.organization_id,
-                        }
-                        for key, val in agent_secrets.items()
-                    ]
-                    session.execute(insert(AgentEnvironmentVariable).values(env_rows))
-
-                # initial message sequence
-                init_messages = self._generate_initial_message_sequence(
-                    actor,
-                    agent_state=new_agent.to_pydantic(include_relationships={"memory"}),
-                    supplied_initial_message_sequence=agent_create.initial_message_sequence,
-                )
-                new_agent.message_ids = [msg.id for msg in init_messages]
-
-            session.refresh(new_agent)
-
-        # Using the synchronous version since we don't have an async version yet
-        # If you implement an async version of create_many_messages, you can switch to that
-        self.message_manager.create_many_messages(pydantic_msgs=init_messages, actor=actor)
-        return new_agent.to_pydantic()
 
     @trace_method
     async def create_agent_async(
@@ -493,8 +315,24 @@ class AgentManager:
         if not agent_create.llm_config or not agent_create.embedding_config:
             raise ValueError("llm_config and embedding_config are required")
 
-        if agent_create.reasoning is not None:
-            agent_create.llm_config = LLMConfig.apply_reasoning_setting_to_config(agent_create.llm_config, agent_create.reasoning)
+        # For v1 agents, enforce sane defaults even when reasoning is omitted
+        if agent_create.agent_type == AgentType.letta_v1_agent:
+            # Claude 3.7/4 or OpenAI o1/o3/o4/gpt-5
+            default_reasoning = LLMConfig.is_anthropic_reasoning_model(agent_create.llm_config) or LLMConfig.is_openai_reasoning_model(
+                agent_create.llm_config
+            )
+            agent_create.llm_config = LLMConfig.apply_reasoning_setting_to_config(
+                agent_create.llm_config,
+                agent_create.reasoning if agent_create.reasoning is not None else default_reasoning,
+                agent_create.agent_type,
+            )
+        else:
+            if agent_create.reasoning is not None:
+                agent_create.llm_config = LLMConfig.apply_reasoning_setting_to_config(
+                    agent_create.llm_config,
+                    agent_create.reasoning,
+                    agent_create.agent_type,
+                )
 
         # blocks
         block_ids = list(agent_create.block_ids or [])
@@ -531,6 +369,15 @@ class AgentManager:
                 tool_names |= calculate_base_tools(is_v2=True)
             elif agent_create.agent_type == AgentType.react_agent:
                 pass  # no default tools
+            elif agent_create.agent_type == AgentType.letta_v1_agent:
+                tool_names |= calculate_base_tools(is_v2=True)
+                # Remove `send_message` if it exists
+                tool_names.discard("send_message")
+                # NOTE: also overwriting inner_thoughts_in_kwargs to force False
+                agent_create.llm_config.put_inner_thoughts_in_kwargs = False
+                # NOTE: also overwrite initial message sequence to empty by default
+                if agent_create.initial_message_sequence is None:
+                    agent_create.initial_message_sequence = []
             elif agent_create.agent_type == AgentType.workflow_agent:
                 pass  # no default tools
             else:
@@ -593,7 +440,7 @@ class AgentManager:
                     for tn in tool_names:
                         if tn in {"send_message", "send_message_to_agent_async", "memory_finish_edits"}:
                             tool_rules.append(TerminalToolRule(tool_name=tn))
-                        elif tn in (BASE_TOOLS + BASE_MEMORY_TOOLS + BASE_MEMORY_TOOLS_V2 + BASE_SLEEPTIME_TOOLS):
+                        elif tn in (BASE_TOOLS + BASE_MEMORY_TOOLS + BASE_MEMORY_TOOLS_V2 + BASE_MEMORY_TOOLS_V3 + BASE_SLEEPTIME_TOOLS):
                             tool_rules.append(ContinueToolRule(tool_name=tn))
 
                 for tool_with_requires_approval in requires_approval:
@@ -783,14 +630,6 @@ class AgentManager:
 
         return init_messages
 
-    @enforce_types
-    @trace_method
-    def append_initial_message_sequence_to_in_context_messages(
-        self, actor: PydanticUser, agent_state: PydanticAgentState, initial_message_sequence: Optional[List[MessageCreate]] = None
-    ) -> PydanticAgentState:
-        init_messages = self._generate_initial_message_sequence(actor, agent_state, initial_message_sequence)
-        return self.append_to_in_context_messages(init_messages, agent_id=agent_state.id, actor=actor)
-
     @enforce_types
     @trace_method
     async def append_initial_message_sequence_to_in_context_messages_async(
@@ -799,130 +638,6 @@ class AgentManager:
         init_messages = await self._generate_initial_message_sequence_async(actor, agent_state, initial_message_sequence)
         return await self.append_to_in_context_messages_async(init_messages, agent_id=agent_state.id, actor=actor)
 
-    @enforce_types
-    @trace_method
-    def update_agent(
-        self,
-        agent_id: str,
-        agent_update: UpdateAgent,
-        actor: PydanticUser,
-    ) -> PydanticAgentState:
-        new_tools = set(agent_update.tool_ids or [])
-        new_sources = set(agent_update.source_ids or [])
-        new_blocks = set(agent_update.block_ids or [])
-        new_idents = set(agent_update.identity_ids or [])
-        new_tags = set(agent_update.tags or [])
-
-        with db_registry.session() as session, session.begin():
-            agent: AgentModel = AgentModel.read(db_session=session, identifier=agent_id, actor=actor)
-            agent.updated_at = datetime.now(timezone.utc)
-            agent.last_updated_by_id = actor.id
-
-            scalar_updates = {
-                "name": agent_update.name,
-                "system": agent_update.system,
-                "llm_config": agent_update.llm_config,
-                "embedding_config": agent_update.embedding_config,
-                "message_ids": agent_update.message_ids,
-                "tool_rules": agent_update.tool_rules,
-                "description": agent_update.description,
-                "project_id": agent_update.project_id,
-                "template_id": agent_update.template_id,
-                "base_template_id": agent_update.base_template_id,
-                "message_buffer_autoclear": agent_update.message_buffer_autoclear,
-                "enable_sleeptime": agent_update.enable_sleeptime,
-                "response_format": agent_update.response_format,
-                "last_run_completion": agent_update.last_run_completion,
-                "last_run_duration_ms": agent_update.last_run_duration_ms,
-                "max_files_open": agent_update.max_files_open,
-                "per_file_view_window_char_limit": agent_update.per_file_view_window_char_limit,
-                "timezone": agent_update.timezone,
-            }
-            for col, val in scalar_updates.items():
-                if val is not None:
-                    setattr(agent, col, val)
-
-            if agent_update.metadata is not None:
-                agent.metadata_ = agent_update.metadata
-
-            aid = agent.id
-
-            if agent_update.tool_ids is not None:
-                self._replace_pivot_rows(
-                    session,
-                    ToolsAgents.__table__,
-                    aid,
-                    [{"agent_id": aid, "tool_id": tid} for tid in new_tools],
-                )
-                session.expire(agent, ["tools"])
-
-            if agent_update.source_ids is not None:
-                self._replace_pivot_rows(
-                    session,
-                    SourcesAgents.__table__,
-                    aid,
-                    [{"agent_id": aid, "source_id": sid} for sid in new_sources],
-                )
-                session.expire(agent, ["sources"])
-
-            if agent_update.block_ids is not None:
-                rows = []
-                if new_blocks:
-                    label_map = {
-                        bid: lbl
-                        for bid, lbl in session.execute(select(BlockModel.id, BlockModel.label).where(BlockModel.id.in_(new_blocks)))
-                    }
-                    rows = [{"agent_id": aid, "block_id": bid, "block_label": label_map[bid]} for bid in new_blocks]
-
-                self._replace_pivot_rows(session, BlocksAgents.__table__, aid, rows)
-                session.expire(agent, ["core_memory"])
-
-            if agent_update.identity_ids is not None:
-                self._replace_pivot_rows(
-                    session,
-                    IdentitiesAgents.__table__,
-                    aid,
-                    [{"agent_id": aid, "identity_id": iid} for iid in new_idents],
-                )
-                session.expire(agent, ["identities"])
-
-            if agent_update.tags is not None:
-                self._replace_pivot_rows(
-                    session,
-                    AgentsTags.__table__,
-                    aid,
-                    [{"agent_id": aid, "tag": tag} for tag in new_tags],
-                )
-                session.expire(agent, ["tags"])
-
-            agent_secrets = agent_update.secrets or agent_update.tool_exec_environment_variables
-            if agent_secrets is not None:
-                session.execute(delete(AgentEnvironmentVariable).where(AgentEnvironmentVariable.agent_id == aid))
-                env_rows = [
-                    {
-                        "agent_id": aid,
-                        "key": k,
-                        "value": v,
-                        "organization_id": agent.organization_id,
-                    }
-                    for k, v in agent_secrets.items()
-                ]
-                if env_rows:
-                    self._bulk_insert_pivot(session, AgentEnvironmentVariable.__table__, env_rows)
-                session.expire(agent, ["tool_exec_environment_variables"])
-
-            if agent_update.enable_sleeptime and agent_update.system is None:
-                agent.system = derive_system_message(
-                    agent_type=agent.agent_type,
-                    enable_sleeptime=agent_update.enable_sleeptime,
-                    system=agent.system,
-                )
-
-            session.flush()
-            session.refresh(agent)
-
-            return agent.to_pydantic()
-
     @enforce_types
     @trace_method
     async def update_agent_async(
@@ -944,7 +659,11 @@ class AgentManager:
 
             if agent_update.reasoning is not None:
                 llm_config = agent_update.llm_config or agent.llm_config
-                agent_update.llm_config = LLMConfig.apply_reasoning_setting_to_config(llm_config, agent_update.reasoning)
+                agent_update.llm_config = LLMConfig.apply_reasoning_setting_to_config(
+                    llm_config,
+                    agent_update.reasoning,
+                    agent.agent_type,
+                )
 
             scalar_updates = {
                 "name": agent_update.name,
@@ -1073,67 +792,6 @@ class AgentManager:
             await agent.update_async(db_session=session, actor=actor, no_commit=True, no_refresh=True)
             await session.commit()
 
-    # TODO: Make this general and think about how to roll this into sqlalchemybase
-    @trace_method
-    def list_agents(
-        self,
-        actor: PydanticUser,
-        name: Optional[str] = None,
-        tags: Optional[List[str]] = None,
-        match_all_tags: bool = False,
-        before: Optional[str] = None,
-        after: Optional[str] = None,
-        limit: Optional[int] = 50,
-        query_text: Optional[str] = None,
-        project_id: Optional[str] = None,
-        template_id: Optional[str] = None,
-        base_template_id: Optional[str] = None,
-        identity_id: Optional[str] = None,
-        identifier_keys: Optional[List[str]] = None,
-        include_relationships: Optional[List[str]] = None,
-        ascending: bool = True,
-        sort_by: Optional[str] = "created_at",
-    ) -> List[PydanticAgentState]:
-        """
-        Retrieves agents with optimized filtering and optional field selection.
-
-        Args:
-            actor: The User requesting the list
-            name (Optional[str]): Filter by agent name.
-            tags (Optional[List[str]]): Filter agents by tags.
-            match_all_tags (bool): If True, only return agents that match ALL given tags.
-            before (Optional[str]): Cursor for pagination.
-            after (Optional[str]): Cursor for pagination.
-            limit (Optional[int]): Maximum number of agents to return.
-            query_text (Optional[str]): Search agents by name.
-            project_id (Optional[str]): Filter by project ID.
-            template_id (Optional[str]): Filter by template ID.
-            base_template_id (Optional[str]): Filter by base template ID.
-            identity_id (Optional[str]): Filter by identifier ID.
-            identifier_keys (Optional[List[str]]): Search agents by identifier keys.
-            include_relationships (Optional[List[str]]): List of fields to load for performance optimization.
-            ascending
-
-        Returns:
-            List[PydanticAgentState]: The filtered list of matching agents.
-        """
-        with db_registry.session() as session:
-            query = select(AgentModel).distinct(AgentModel.created_at, AgentModel.id)
-            query = AgentModel.apply_access_predicate(query, actor, ["read"], AccessType.ORGANIZATION)
-
-            # Apply filters
-            query = _apply_filters(query, name, query_text, project_id, template_id, base_template_id)
-            query = _apply_identity_filters(query, identity_id, identifier_keys)
-            query = _apply_tag_filter(query, tags, match_all_tags)
-            query = _apply_pagination(query, before, after, session, ascending=ascending, sort_by=sort_by)
-
-            if limit:
-                query = query.limit(limit)
-
-            result = session.execute(query)
-            agents = result.scalars().all()
-            return [agent.to_pydantic(include_relationships=include_relationships) for agent in agents]
-
     @trace_method
     async def list_agents_async(
         self,
@@ -1201,50 +859,6 @@ class AgentManager:
             agents = result.scalars().all()
             return await asyncio.gather(*[agent.to_pydantic_async(include_relationships=include_relationships) for agent in agents])
 
-    @enforce_types
-    @trace_method
-    def list_agents_matching_tags(
-        self,
-        actor: PydanticUser,
-        match_all: List[str],
-        match_some: List[str],
-        limit: Optional[int] = 50,
-    ) -> List[PydanticAgentState]:
-        """
-        Retrieves agents in the same organization that match all specified `match_all` tags
-        and at least one tag from `match_some`. The query is optimized for efficiency by
-        leveraging indexed filtering and aggregation.
-
-        Args:
-            actor (PydanticUser): The user requesting the agent list.
-            match_all (List[str]): Agents must have all these tags.
-            match_some (List[str]): Agents must have at least one of these tags.
-            limit (Optional[int]): Maximum number of agents to return.
-
-        Returns:
-            List[PydanticAgentState: The filtered list of matching agents.
-        """
-        with db_registry.session() as session:
-            query = select(AgentModel).where(AgentModel.organization_id == actor.organization_id)
-
-            if match_all:
-                # Subquery to find agent IDs that contain all match_all tags
-                subquery = (
-                    select(AgentsTags.agent_id)
-                    .where(AgentsTags.tag.in_(match_all))
-                    .group_by(AgentsTags.agent_id)
-                    .having(func.count(AgentsTags.tag) == literal(len(match_all)))
-                )
-                query = query.where(AgentModel.id.in_(subquery))
-
-            if match_some:
-                # Ensures agents match at least one tag in match_some
-                query = query.join(AgentsTags).where(AgentsTags.tag.in_(match_some))
-
-            query = query.distinct(AgentModel.id).order_by(AgentModel.id).limit(limit)
-
-            return list(session.execute(query).scalars())
-
     @enforce_types
     @trace_method
     async def list_agents_matching_tags_async(
@@ -1289,17 +903,6 @@ class AgentManager:
             result = await session.execute(query)
             return await asyncio.gather(*[agent.to_pydantic_async() for agent in result.scalars()])
 
-    @trace_method
-    def size(
-        self,
-        actor: PydanticUser,
-    ) -> int:
-        """
-        Get the total count of agents for the given user.
-        """
-        with db_registry.session() as session:
-            return AgentModel.size(db_session=session, actor=actor)
-
     @trace_method
     async def size_async(
         self,
@@ -1311,14 +914,6 @@ class AgentManager:
         async with db_registry.async_session() as session:
             return await AgentModel.size_async(db_session=session, actor=actor)
 
-    @enforce_types
-    @trace_method
-    def get_agent_by_id(self, agent_id: str, actor: PydanticUser) -> PydanticAgentState:
-        """Fetch an agent by its ID."""
-        with db_registry.session() as session:
-            agent = AgentModel.read(db_session=session, identifier=agent_id, actor=actor)
-            return agent.to_pydantic()
-
     @enforce_types
     @trace_method
     async def get_agent_by_id_async(
@@ -1342,6 +937,9 @@ class AgentManager:
                     raise NoResultFound(f"Agent with ID {agent_id} not found")
 
                 return await agent.to_pydantic_async(include_relationships=include_relationships)
+            except NoResultFound:
+                # Re-raise NoResultFound without logging to preserve 404 handling
+                raise
             except Exception as e:
                 logger.error(f"Error fetching agent {agent_id}: {str(e)}")
                 raise
@@ -1374,14 +972,6 @@ class AgentManager:
                 logger.error(f"Error fetching agents with IDs {agent_ids}: {str(e)}")
                 raise
 
-    @enforce_types
-    @trace_method
-    def get_agent_by_name(self, agent_name: str, actor: PydanticUser) -> PydanticAgentState:
-        """Fetch an agent by its ID."""
-        with db_registry.session() as session:
-            agent = AgentModel.read(db_session=session, name=agent_name, actor=actor)
-            return agent.to_pydantic()
-
     @enforce_types
     @trace_method
     async def get_agent_archive_ids_async(self, agent_id: str, actor: PydanticUser) -> List[str]:
@@ -1395,54 +985,6 @@ class AgentManager:
             archive_ids = [row[0] for row in result.fetchall()]
             return archive_ids
 
-    @enforce_types
-    @trace_method
-    def delete_agent(self, agent_id: str, actor: PydanticUser) -> None:
-        """
-        Deletes an agent and its associated relationships.
-        Ensures proper permission checks and cascades where applicable.
-
-        Args:
-            agent_id: ID of the agent to be deleted.
-            actor: User performing the action.
-
-        Raises:
-            NoResultFound: If agent doesn't exist
-        """
-        with db_registry.session() as session:
-            # Retrieve the agent
-            logger.debug(f"Hard deleting Agent with ID: {agent_id} with actor={actor}")
-            agent = AgentModel.read(db_session=session, identifier=agent_id, actor=actor)
-            agents_to_delete = [agent]
-            sleeptime_group_to_delete = None
-
-            # Delete sleeptime agent and group (TODO this is flimsy pls fix)
-            if agent.multi_agent_group:
-                participant_agent_ids = agent.multi_agent_group.agent_ids
-                if agent.multi_agent_group.manager_type in {ManagerType.sleeptime, ManagerType.voice_sleeptime} and participant_agent_ids:
-                    for participant_agent_id in participant_agent_ids:
-                        try:
-                            sleeptime_agent = AgentModel.read(db_session=session, identifier=participant_agent_id, actor=actor)
-                            agents_to_delete.append(sleeptime_agent)
-                        except NoResultFound:
-                            pass  # agent already deleted
-                    sleeptime_agent_group = GroupModel.read(db_session=session, identifier=agent.multi_agent_group.id, actor=actor)
-                    sleeptime_group_to_delete = sleeptime_agent_group
-
-            try:
-                if sleeptime_group_to_delete is not None:
-                    session.delete(sleeptime_group_to_delete)
-                    session.commit()
-                for agent in agents_to_delete:
-                    session.delete(agent)
-                session.commit()
-            except Exception as e:
-                session.rollback()
-                logger.exception(f"Failed to hard delete Agent with ID {agent_id}")
-                raise ValueError(f"Failed to hard delete Agent with ID {agent_id}: {e}")
-            else:
-                logger.debug(f"Agent with ID {agent_id} successfully hard deleted")
-
     @enforce_types
     @trace_method
     async def delete_agent_async(self, agent_id: str, actor: PydanticUser) -> None:
@@ -1493,168 +1035,9 @@ class AgentManager:
             else:
                 logger.debug(f"Agent with ID {agent_id} successfully hard deleted")
 
-    @enforce_types
-    @trace_method
-    def serialize(self, agent_id: str, actor: PydanticUser, max_steps: Optional[int] = None) -> AgentSchema:
-        with db_registry.session() as session:
-            agent = AgentModel.read(db_session=session, identifier=agent_id, actor=actor)
-            schema = MarshmallowAgentSchema(session=session, actor=actor, max_steps=max_steps)
-            data = schema.dump(agent)
-            return AgentSchema(**data)
-
-    @enforce_types
-    @trace_method
-    def deserialize(
-        self,
-        serialized_agent: AgentSchema,
-        actor: PydanticUser,
-        append_copy_suffix: bool = True,
-        override_existing_tools: bool = True,
-        project_id: Optional[str] = None,
-        strip_messages: Optional[bool] = False,
-        env_vars: Optional[dict[str, Any]] = None,
-    ) -> PydanticAgentState:
-        serialized_agent_dict = serialized_agent.model_dump()
-        tool_data_list = serialized_agent_dict.pop("tools", [])
-        messages = serialized_agent_dict.pop(MarshmallowAgentSchema.FIELD_MESSAGES, [])
-
-        for msg in messages:
-            msg[MarshmallowAgentSchema.FIELD_ID] = SerializedMessageSchema.generate_id()  # Generate new ID
-
-        message_ids = []
-        in_context_message_indices = serialized_agent_dict.pop(MarshmallowAgentSchema.FIELD_IN_CONTEXT_INDICES)
-        for idx in in_context_message_indices:
-            message_ids.append(messages[idx][MarshmallowAgentSchema.FIELD_ID])
-
-        serialized_agent_dict[MarshmallowAgentSchema.FIELD_MESSAGE_IDS] = message_ids
-
-        with db_registry.session() as session:
-            schema = MarshmallowAgentSchema(session=session, actor=actor)
-            agent = schema.load(serialized_agent_dict, session=session)
-
-            agent.organization_id = actor.organization_id
-            for block in agent.core_memory:
-                block.organization_id = actor.organization_id
-            if append_copy_suffix:
-                agent.name += "_copy"
-            if project_id:
-                agent.project_id = project_id
-
-            if strip_messages:
-                # we want to strip all but the first (system) message
-                agent.message_ids = [agent.message_ids[0]]
-
-            if env_vars:
-                for var in agent.tool_exec_environment_variables:
-                    var.value = env_vars.get(var.key, "")
-                for var in agent.secrets:
-                    var.value = env_vars.get(var.key, "")
-
-            agent = agent.create(session, actor=actor)
-
-            pydantic_agent = agent.to_pydantic()
-
-        pyd_msgs = []
-        message_schema = SerializedMessageSchema(session=session, actor=actor)
-
-        for serialized_message in messages:
-            pydantic_message = message_schema.load(serialized_message, session=session).to_pydantic()
-            pydantic_message.agent_id = agent.id
-            pyd_msgs.append(pydantic_message)
-        self.message_manager.create_many_messages(pyd_msgs, actor=actor)
-
-        # Need to do this separately as there's some fancy upsert logic that SqlAlchemy cannot handle
-        for tool_data in tool_data_list:
-            pydantic_tool = SerializedToolSchema(actor=actor).load(tool_data, transient=True).to_pydantic()
-
-            existing_pydantic_tool = self.tool_manager.get_tool_by_name(pydantic_tool.name, actor=actor)
-            if existing_pydantic_tool and (
-                existing_pydantic_tool.tool_type in {ToolType.LETTA_CORE, ToolType.LETTA_MULTI_AGENT_CORE, ToolType.LETTA_MEMORY_CORE}
-                or not override_existing_tools
-            ):
-                pydantic_tool = existing_pydantic_tool
-            else:
-                pydantic_tool = self.tool_manager.create_or_update_tool(pydantic_tool, actor=actor, bypass_name_check=True)
-
-            pydantic_agent = self.attach_tool(agent_id=pydantic_agent.id, tool_id=pydantic_tool.id, actor=actor)
-
-        return pydantic_agent
-
     # ======================================================================================================================
     # Per Agent Environment Variable Management
     # ======================================================================================================================
-    @enforce_types
-    @trace_method
-    def _set_environment_variables(
-        self,
-        agent_id: str,
-        env_vars: Dict[str, str],
-        actor: PydanticUser,
-    ) -> PydanticAgentState:
-        """
-        Adds or replaces the environment variables for the specified agent.
-
-        Args:
-            agent_id: The agent id.
-            env_vars: A dictionary of environment variable key-value pairs.
-            actor: The user performing the action.
-
-        Returns:
-            PydanticAgentState: The updated agent as a Pydantic model.
-        """
-        with db_registry.session() as session:
-            # Retrieve the agent
-            agent = AgentModel.read(db_session=session, identifier=agent_id, actor=actor)
-
-            # Fetch existing environment variables as a dictionary
-            existing_vars = {var.key: var for var in agent.tool_exec_environment_variables}
-
-            # Update or create environment variables
-            updated_vars = []
-            for key, value in env_vars.items():
-                if key in existing_vars:
-                    # Update existing variable
-                    existing_vars[key].value = value
-                    updated_vars.append(existing_vars[key])
-                else:
-                    # Create new variable
-                    updated_vars.append(
-                        AgentEnvironmentVariableModel(
-                            key=key,
-                            value=value,
-                            agent_id=agent_id,
-                            organization_id=actor.organization_id,
-                            created_by_id=actor.id,
-                            last_updated_by_id=actor.id,
-                        )
-                    )
-
-            # Remove stale variables
-            stale_keys = set(existing_vars) - set(env_vars)
-            agent.tool_exec_environment_variables = [var for var in updated_vars if var.key not in stale_keys]
-            agent.secrets = [var for var in updated_vars if var.key not in stale_keys]
-
-            # Update the agent in the database
-            agent.update(session, actor=actor)
-
-            # Return the updated agent state
-            return agent.to_pydantic()
-
-    @enforce_types
-    @trace_method
-    def list_groups(self, agent_id: str, actor: PydanticUser, manager_type: Optional[str] = None) -> List[PydanticGroup]:
-        with db_registry.session() as session:
-            query = (
-                select(GroupModel)
-                .join(GroupsAgents, GroupModel.id == GroupsAgents.group_id)
-                .where(GroupsAgents.agent_id == agent_id, GroupModel.organization_id == actor.organization_id)
-            )
-
-            if manager_type:
-                query = query.where(GroupModel.manager_type == manager_type)
-
-            result = session.execute(query)
-            return [group.to_pydantic() for group in result.scalars()]
 
     # ======================================================================================================================
     # In Context Messages Management
@@ -1666,9 +1049,9 @@ class AgentManager:
     # TODO: This can also be made more efficient, instead of getting, setting, we can do it all in one db session for one query.
     @enforce_types
     @trace_method
-    def get_in_context_messages(self, agent_id: str, actor: PydanticUser) -> List[PydanticMessage]:
-        message_ids = self.get_agent_by_id(agent_id=agent_id, actor=actor).message_ids
-        return self.message_manager.get_messages_by_ids(message_ids=message_ids, actor=actor)
+    async def get_in_context_messages(self, agent_id: str, actor: PydanticUser) -> List[PydanticMessage]:
+        agent_state = await self.get_agent_by_id_async(agent_id=agent_id, actor=actor)
+        return await self.message_manager.get_messages_by_ids_async(message_ids=agent_state.message_ids, actor=actor)
 
     @enforce_types
     @trace_method
@@ -1924,10 +1307,8 @@ class AgentManager:
             PydanticAgentState: The updated agent state with only the original system message preserved.
         """
         async with db_registry.async_session() as session:
-            # Retrieve the existing agent (will raise NoResultFound if invalid)
             agent = await AgentModel.read_async(db_session=session, identifier=agent_id, actor=actor)
 
-            # Ensure agent has message_ids with at least one message
             if not agent.message_ids or len(agent.message_ids) == 0:
                 logger.error(
                     f"Agent {agent_id} has no message_ids. Agent details: "
@@ -1936,13 +1317,12 @@ class AgentManager:
                 )
                 raise ValueError(f"Agent {agent_id} has no message_ids - cannot preserve system message")
 
-            # Get the system message ID (first message)
             system_message_id = agent.message_ids[0]
 
-            # Delete all messages for the agent except the system message
-            await self.message_manager.delete_all_messages_for_agent_async(agent_id=agent_id, actor=actor, exclude_ids=[system_message_id])
+        await self.message_manager.delete_all_messages_for_agent_async(agent_id=agent_id, actor=actor, exclude_ids=[system_message_id])
 
-            # Update agent to only keep the system message
+        async with db_registry.async_session() as session:
+            agent = await AgentModel.read_async(db_session=session, identifier=agent_id, actor=actor)
             agent.message_ids = [system_message_id]
             await agent.update_async(db_session=session, actor=actor)
             agent_state = await agent.to_pydantic_async(include_relationships=["sources"])
@@ -1989,19 +1369,22 @@ class AgentManager:
         )
         if new_memory_str not in system_message.content[0].text:
             # update the blocks (LRW) in the DB
-            for label in agent_state.memory.list_block_labels():
-                updated_value = new_memory.get_block(label).value
-                if updated_value != agent_state.memory.get_block(label).value:
-                    # update the block if it's changed
-                    block_id = agent_state.memory.get_block(label).id
-                    await self.block_manager.update_block_async(
-                        block_id=block_id, block_update=BlockUpdate(value=updated_value), actor=actor
-                    )
+            for label in new_memory.list_block_labels():
+                if label in agent_state.memory.list_block_labels():
+                    # Block exists in both old and new memory - check if value changed
+                    updated_value = new_memory.get_block(label).value
+                    if updated_value != agent_state.memory.get_block(label).value:
+                        # update the block if it's changed
+                        block_id = agent_state.memory.get_block(label).id
+                        await self.block_manager.update_block_async(
+                            block_id=block_id, block_update=BlockUpdate(value=updated_value), actor=actor
+                        )
 
-            # refresh memory from DB (using block ids)
-            blocks = await self.block_manager.get_all_blocks_by_ids_async(
-                block_ids=[b.id for b in agent_state.memory.get_blocks()], actor=actor
-            )
+                # Note: New blocks are already persisted in the creation methods,
+                # so we don't need to handle them here
+
+            # refresh memory from DB (using block ids from the new memory)
+            blocks = await self.block_manager.get_all_blocks_by_ids_async(block_ids=[b.id for b in new_memory.get_blocks()], actor=actor)
 
             agent_state.memory = Memory(
                 blocks=blocks,
@@ -2166,16 +1549,28 @@ class AgentManager:
 
     @enforce_types
     @trace_method
-    async def list_attached_sources_async(self, agent_id: str, actor: PydanticUser) -> List[PydanticSource]:
+    async def list_attached_sources_async(
+        self,
+        agent_id: str,
+        actor: PydanticUser,
+        before: Optional[str] = None,
+        after: Optional[str] = None,
+        limit: Optional[int] = None,
+        ascending: bool = False,
+    ) -> List[PydanticSource]:
         """
-        Lists all sources attached to an agent.
+        Lists all sources attached to an agent with pagination.
 
         Args:
             agent_id: ID of the agent to list sources for
             actor: User performing the action
+            before: Source ID cursor for pagination. Returns sources that come before this source ID.
+            after: Source ID cursor for pagination. Returns sources that come after this source ID.
+            limit: Maximum number of sources to return.
+            ascending: Sort order by creation time.
 
         Returns:
-            List[str]: List of source IDs attached to the agent
+            List[PydanticSource]: List of sources attached to the agent
 
         Raises:
             NoResultFound: If agent doesn't exist or user doesn't have access
@@ -2194,9 +1589,24 @@ class AgentManager:
                     SourceModel.organization_id == actor.organization_id,
                     SourceModel.is_deleted == False,
                 )
-                .order_by(SourceModel.created_at.desc(), SourceModel.id)
             )
 
+            # Apply cursor-based pagination
+            if before:
+                query = query.where(SourceModel.id < before)
+            if after:
+                query = query.where(SourceModel.id > after)
+
+            # Apply sorting
+            if ascending:
+                query = query.order_by(SourceModel.created_at.asc(), SourceModel.id.asc())
+            else:
+                query = query.order_by(SourceModel.created_at.desc(), SourceModel.id.desc())
+
+            # Apply limit
+            if limit:
+                query = query.limit(limit)
+
             result = await session.execute(query)
             sources = result.scalars().all()
 
@@ -2240,22 +1650,6 @@ class AgentManager:
     # ======================================================================================================================
     # Block management
     # ======================================================================================================================
-    @enforce_types
-    @trace_method
-    def get_block_with_label(
-        self,
-        agent_id: str,
-        block_label: str,
-        actor: PydanticUser,
-    ) -> PydanticBlock:
-        """Gets a block attached to an agent by its label."""
-        with db_registry.session() as session:
-            agent = AgentModel.read(db_session=session, identifier=agent_id, actor=actor)
-            for block in agent.core_memory:
-                if block.label == block_label:
-                    return block.to_pydantic()
-            raise NoResultFound(f"No block with label '{block_label}' found for agent '{agent_id}'")
-
     @enforce_types
     @trace_method
     async def get_block_with_label_async(
@@ -2294,67 +1688,15 @@ class AgentManager:
 
             update_data = block_update.model_dump(to_orm=True, exclude_unset=True, exclude_none=True)
 
+            # Validate limit constraints before updating
+            validate_block_limit_constraint(update_data, block)
+
             for key, value in update_data.items():
                 setattr(block, key, value)
 
             await block.update_async(session, actor=actor)
             return block.to_pydantic()
 
-    @enforce_types
-    @trace_method
-    def update_block_with_label(
-        self,
-        agent_id: str,
-        block_label: str,
-        new_block_id: str,
-        actor: PydanticUser,
-    ) -> PydanticAgentState:
-        """Updates which block is assigned to a specific label for an agent."""
-        with db_registry.session() as session:
-            agent = AgentModel.read(db_session=session, identifier=agent_id, actor=actor)
-            new_block = BlockModel.read(db_session=session, identifier=new_block_id, actor=actor)
-
-            if new_block.label != block_label:
-                raise ValueError(f"New block label '{new_block.label}' doesn't match required label '{block_label}'")
-
-            # Remove old block with this label if it exists
-            agent.core_memory = [b for b in agent.core_memory if b.label != block_label]
-
-            # Add new block
-            agent.core_memory.append(new_block)
-            agent.update(session, actor=actor)
-            return agent.to_pydantic()
-
-    @enforce_types
-    @trace_method
-    def attach_block(self, agent_id: str, block_id: str, actor: PydanticUser) -> PydanticAgentState:
-        """Attaches a block to an agent. For sleeptime agents, also attaches to paired agents in the same group."""
-        with db_registry.session() as session:
-            agent = AgentModel.read(db_session=session, identifier=agent_id, actor=actor)
-            block = BlockModel.read(db_session=session, identifier=block_id, actor=actor)
-
-            # Attach block to the main agent
-            agent.core_memory.append(block)
-            agent.update(session, actor=actor, no_commit=True)
-
-            # If agent is part of a sleeptime group, attach block to the sleeptime_agent
-            if agent.multi_agent_group and agent.multi_agent_group.manager_type == ManagerType.sleeptime:
-                group = agent.multi_agent_group
-                # Find the sleeptime_agent in the group
-                for other_agent_id in group.agent_ids or []:
-                    if other_agent_id != agent_id:
-                        try:
-                            other_agent = AgentModel.read(db_session=session, identifier=other_agent_id, actor=actor)
-                            if other_agent.agent_type == AgentType.sleeptime_agent and block not in other_agent.core_memory:
-                                other_agent.core_memory.append(block)
-                                other_agent.update(session, actor=actor, no_commit=True)
-                        except NoResultFound:
-                            # Agent might not exist anymore, skip
-                            continue
-            session.commit()
-
-            return agent.to_pydantic()
-
     @enforce_types
     @trace_method
     async def attach_block_async(self, agent_id: str, block_id: str, actor: PydanticUser) -> PydanticAgentState:
@@ -2391,27 +1733,6 @@ class AgentManager:
 
             return await agent.to_pydantic_async()
 
-    @enforce_types
-    @trace_method
-    def detach_block(
-        self,
-        agent_id: str,
-        block_id: str,
-        actor: PydanticUser,
-    ) -> PydanticAgentState:
-        """Detaches a block from an agent."""
-        with db_registry.session() as session:
-            agent = AgentModel.read(db_session=session, identifier=agent_id, actor=actor)
-            original_length = len(agent.core_memory)
-
-            agent.core_memory = [b for b in agent.core_memory if b.id != block_id]
-
-            if len(agent.core_memory) == original_length:
-                raise NoResultFound(f"No block with id '{block_id}' found for agent '{agent_id}' with actor id: '{actor.id}'")
-
-            agent.update(session, actor=actor)
-            return agent.to_pydantic()
-
     @enforce_types
     @trace_method
     async def detach_block_async(
@@ -2433,27 +1754,6 @@ class AgentManager:
             await agent.update_async(session, actor=actor)
             return await agent.to_pydantic_async()
 
-    @enforce_types
-    @trace_method
-    def detach_block_with_label(
-        self,
-        agent_id: str,
-        block_label: str,
-        actor: PydanticUser,
-    ) -> PydanticAgentState:
-        """Detaches a block with the specified label from an agent."""
-        with db_registry.session() as session:
-            agent = AgentModel.read(db_session=session, identifier=agent_id, actor=actor)
-            original_length = len(agent.core_memory)
-
-            agent.core_memory = [b for b in agent.core_memory if b.label != block_label]
-
-            if len(agent.core_memory) == original_length:
-                raise NoResultFound(f"No block with label '{block_label}' found for agent '{agent_id}' with actor id: '{actor.id}'")
-
-            agent.update(session, actor=actor)
-            return agent.to_pydantic()
-
     # ======================================================================================================================
     # Passage Management
     # ======================================================================================================================
@@ -2985,41 +2285,6 @@ class AgentManager:
     # Tool Management
     # ======================================================================================================================
     @enforce_types
-    @trace_method
-    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 db_registry.session() 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
     @trace_method
     async def attach_tool_async(self, agent_id: str, tool_id: str, actor: PydanticUser) -> None:
@@ -3253,40 +2518,6 @@ class AgentManager:
 
         return PydanticAgentState(**agent_state_dict)
 
-    @enforce_types
-    @trace_method
-    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 db_registry.session() 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()
-
     @enforce_types
     @trace_method
     async def detach_tool_async(self, agent_id: str, tool_id: str, actor: PydanticUser) -> None:
@@ -3381,24 +2612,15 @@ class AgentManager:
 
     @enforce_types
     @trace_method
-    def list_attached_tools(self, agent_id: str, actor: PydanticUser) -> List[PydanticTool]:
-        """
-        List all tools attached to an agent.
-
-        Args:
-            agent_id: ID of the agent to list tools for.
-            actor: User performing the action.
-
-        Returns:
-            List[PydanticTool]: List of tools attached to the agent.
-        """
-        with db_registry.session() as session:
-            agent = AgentModel.read(db_session=session, identifier=agent_id, actor=actor)
-            return [tool.to_pydantic() for tool in agent.tools]
-
-    @enforce_types
-    @trace_method
-    async def list_attached_tools_async(self, agent_id: str, actor: PydanticUser) -> List[PydanticTool]:
+    async def list_attached_tools_async(
+        self,
+        agent_id: str,
+        actor: PydanticUser,
+        before: Optional[str] = None,
+        after: Optional[str] = None,
+        limit: Optional[int] = None,
+        ascending: bool = False,
+    ) -> List[PydanticTool]:
         """
         List all tools attached to an agent (async version with optimized performance).
         Uses direct SQL queries to avoid SqlAlchemyBase overhead.
@@ -3406,6 +2628,10 @@ class AgentManager:
         Args:
             agent_id: ID of the agent to list tools for.
             actor: User performing the action.
+            before: Tool ID cursor for pagination. Returns tools that come before this tool ID.
+            after: Tool ID cursor for pagination. Returns tools that come after this tool ID.
+            limit: Maximum number of tools to return.
+            ascending: Sort order by creation time.
 
         Returns:
             List[PydanticTool]: List of tools attached to the agent.
@@ -3421,10 +2647,140 @@ class AgentManager:
                 .where(ToolsAgents.agent_id == agent_id, ToolModel.organization_id == actor.organization_id)
             )
 
+            # Apply cursor-based pagination
+            if before:
+                query = query.where(ToolModel.id < before)
+            if after:
+                query = query.where(ToolModel.id > after)
+
+            # Apply sorting
+            if ascending:
+                query = query.order_by(ToolModel.created_at.asc())
+            else:
+                query = query.order_by(ToolModel.created_at.desc())
+
+            # Apply limit
+            if limit:
+                query = query.limit(limit)
+
             result = await session.execute(query)
             tools = result.scalars().all()
             return [tool.to_pydantic() for tool in tools]
 
+    @enforce_types
+    @trace_method
+    async def list_agent_blocks_async(
+        self,
+        agent_id: str,
+        actor: PydanticUser,
+        before: Optional[str] = None,
+        after: Optional[str] = None,
+        limit: Optional[int] = None,
+        ascending: bool = False,
+    ) -> List[PydanticBlock]:
+        """
+        List all blocks for a specific agent with pagination.
+
+        Args:
+            agent_id: ID of the agent to find blocks for.
+            actor: User performing the action.
+            before: Block ID cursor for pagination. Returns blocks that come before this block ID.
+            after: Block ID cursor for pagination. Returns blocks that come after this block ID.
+            limit: Maximum number of blocks to return.
+            ascending: Sort order by creation time.
+
+        Returns:
+            List[PydanticBlock]: List of blocks for the agent.
+        """
+        async with db_registry.async_session() as session:
+            # First verify agent exists and user has access
+            await AgentModel.read_async(db_session=session, identifier=agent_id, actor=actor)
+
+            # Build query to get blocks for this agent with pagination
+            query = (
+                select(BlockModel)
+                .join(BlocksAgents, BlockModel.id == BlocksAgents.block_id)
+                .where(BlocksAgents.agent_id == agent_id, BlockModel.organization_id == actor.organization_id)
+            )
+
+            # Apply cursor-based pagination
+            if before:
+                query = query.where(BlockModel.id < before)
+            if after:
+                query = query.where(BlockModel.id > after)
+
+            # Apply sorting - use id instead of created_at for core memory blocks
+            if ascending:
+                query = query.order_by(BlockModel.id.asc())
+            else:
+                query = query.order_by(BlockModel.id.desc())
+
+            # Apply limit
+            if limit:
+                query = query.limit(limit)
+
+            result = await session.execute(query)
+            blocks = result.scalars().all()
+
+            return [block.to_pydantic() for block in blocks]
+
+    @enforce_types
+    @trace_method
+    async def list_groups_async(
+        self,
+        agent_id: str,
+        actor: PydanticUser,
+        manager_type: Optional[str] = None,
+        before: Optional[str] = None,
+        after: Optional[str] = None,
+        limit: Optional[int] = None,
+        ascending: bool = False,
+    ) -> List[PydanticGroup]:
+        """
+        List all groups that contain the specified agent.
+
+        Args:
+            agent_id: ID of the agent to find groups for.
+            actor: User performing the action.
+            manager_type: Optional manager type to filter by.
+            before: Group ID cursor for pagination. Returns groups that come before this group ID.
+            after: Group ID cursor for pagination. Returns groups that come after this group ID.
+            limit: Maximum number of groups to return.
+            ascending: Sort order by creation time.
+
+        Returns:
+            List[PydanticGroup]: List of groups containing the agent.
+        """
+        async with db_registry.async_session() as session:
+            query = (
+                select(GroupModel)
+                .join(GroupsAgents, GroupModel.id == GroupsAgents.group_id)
+                .where(GroupsAgents.agent_id == agent_id, GroupModel.organization_id == actor.organization_id)
+            )
+
+            if manager_type:
+                query = query.where(GroupModel.manager_type == manager_type)
+
+            # Apply cursor-based pagination
+            if before:
+                query = query.where(GroupModel.id < before)
+            if after:
+                query = query.where(GroupModel.id > after)
+
+            # Apply sorting
+            if ascending:
+                query = query.order_by(GroupModel.created_at.asc())
+            else:
+                query = query.order_by(GroupModel.created_at.desc())
+
+            # Apply limit
+            if limit:
+                query = query.limit(limit)
+
+            result = await session.execute(query)
+            groups = result.scalars().all()
+            return [group.to_pydantic() for group in groups]
+
     # ======================================================================================================================
     # File Management
     # ======================================================================================================================
@@ -3505,45 +2861,6 @@ class AgentManager:
     # ======================================================================================================================
     # Tag Management
     # ======================================================================================================================
-    @enforce_types
-    @trace_method
-    def list_tags(
-        self, actor: PydanticUser, after: Optional[str] = None, limit: Optional[int] = 50, query_text: Optional[str] = None
-    ) -> List[str]:
-        """
-        Get all tags a user has created, ordered alphabetically.
-
-        Args:
-            actor: User performing the action.
-            after: Cursor for forward pagination.
-            limit: Maximum number of tags to return.
-            query_text: Query text to filter tags by.
-
-        Returns:
-            List[str]: List of all tags.
-        """
-        with db_registry.session() as session:
-            query = (
-                session.query(AgentsTags.tag)
-                .join(AgentModel, AgentModel.id == AgentsTags.agent_id)
-                .filter(AgentModel.organization_id == actor.organization_id)
-                .distinct()
-            )
-
-            if query_text:
-                if settings.database_engine is DatabaseChoice.POSTGRES:
-                    # PostgreSQL: Use ILIKE for case-insensitive search
-                    query = query.filter(AgentsTags.tag.ilike(f"%{query_text}%"))
-                else:
-                    # SQLite: Use LIKE with LOWER for case-insensitive search
-                    query = query.filter(func.lower(AgentsTags.tag).like(func.lower(f"%{query_text}%")))
-
-            if after:
-                query = query.filter(AgentsTags.tag > after)
-
-            query = query.order_by(AgentsTags.tag).limit(limit)
-            results = [tag[0] for tag in query.all()]
-            return results
 
     @enforce_types
     @trace_method