letta-nightly 0.6.48.dev20250406104033__py3-none-any.whl → 0.6.49.dev20250408030511__py3-none-any.whl

letta/server/rest_api/routers/v1/runs.py

@@ -19,6 +19,7 @@ router = APIRouter(prefix="/runs", tags=["runs"])
 @router.get("/", response_model=List[Run], operation_id="list_runs")
 def list_runs(
     server: "SyncServer" = Depends(get_letta_server),
+    agent_ids: Optional[List[str]] = Query(None, description="The unique identifier of the agent associated with the run."),
     actor_id: Optional[str] = Header(None, alias="user_id"),  # Extract user_id from header, default to None if not present
 ):
     """
@@ -26,12 +27,18 @@ def list_runs(
     """
     actor = server.user_manager.get_user_or_default(user_id=actor_id)
 
-    return [Run.from_job(job) for job in server.job_manager.list_jobs(actor=actor, job_type=JobType.RUN)]
+    runs = [Run.from_job(job) for job in server.job_manager.list_jobs(actor=actor, job_type=JobType.RUN)]
+
+    if not agent_ids:
+        return runs
+
+    return [run for run in runs if "agent_id" in run.metadata and run.metadata["agent_id"] in agent_ids]
 
 
 @router.get("/active", response_model=List[Run], operation_id="list_active_runs")
 def list_active_runs(
     server: "SyncServer" = Depends(get_letta_server),
+    agent_ids: Optional[List[str]] = Query(None, description="The unique identifier of the agent associated with the run."),
     actor_id: Optional[str] = Header(None, alias="user_id"),  # Extract user_id from header, default to None if not present
 ):
     """
@@ -41,7 +48,12 @@ def list_active_runs(
 
     active_runs = server.job_manager.list_jobs(actor=actor, statuses=[JobStatus.created, JobStatus.running], job_type=JobType.RUN)
 
-    return [Run.from_job(job) for job in active_runs]
+    active_runs = [Run.from_job(job) for job in active_runs]
+
+    if not agent_ids:
+        return active_runs
+
+    return [run for run in active_runs if "agent_id" in run.metadata and run.metadata["agent_id"] in agent_ids]
 
 
 @router.get("/{run_id}", response_model=Run, operation_id="retrieve_run")

letta/server/rest_api/utils.py

@@ -18,7 +18,7 @@ from letta.errors import ContextWindowExceededError, RateLimitExceededError
 from letta.helpers.datetime_helpers import get_utc_time
 from letta.log import get_logger
 from letta.schemas.enums import MessageRole
-from letta.schemas.letta_message_content import TextContent
+from letta.schemas.letta_message_content import OmittedReasoningContent, ReasoningContent, RedactedReasoningContent, TextContent
 from letta.schemas.message import Message
 from letta.schemas.usage import LettaUsageStatistics
 from letta.schemas.user import User
@@ -167,7 +167,7 @@ def create_user_message(input_message: dict, agent_id: str, actor: User) -> Mess
     return user_message
 
 
-def create_tool_call_messages_from_openai_response(
+def create_letta_messages_from_llm_response(
     agent_id: str,
     model: str,
     function_name: str,
@@ -177,6 +177,9 @@ def create_tool_call_messages_from_openai_response(
     function_response: Optional[str],
     actor: User,
     add_heartbeat_request_system_message: bool = False,
+    reasoning_content: Optional[List[Union[TextContent, ReasoningContent, RedactedReasoningContent, OmittedReasoningContent]]] = None,
+    pre_computed_assistant_message_id: Optional[str] = None,
+    pre_computed_tool_message_id: Optional[str] = None,
 ) -> List[Message]:
     messages = []
 
@@ -190,9 +193,11 @@ def create_tool_call_messages_from_openai_response(
         ),
         type="function",
     )
+    # TODO: Use ToolCallContent instead of tool_calls
+    # TODO: This helps preserve ordering
     assistant_message = Message(
         role=MessageRole.assistant,
-        content=[],
+        content=reasoning_content if reasoning_content else [],
         organization_id=actor.organization_id,
         agent_id=agent_id,
         model=model,
@@ -200,8 +205,12 @@ def create_tool_call_messages_from_openai_response(
         tool_call_id=tool_call_id,
         created_at=get_utc_time(),
     )
+    if pre_computed_assistant_message_id:
+        assistant_message.id = pre_computed_assistant_message_id
     messages.append(assistant_message)
 
+    # TODO: Use ToolReturnContent instead of TextContent
+    # TODO: This helps preserve ordering
     tool_message = Message(
         role=MessageRole.tool,
         content=[TextContent(text=package_function_response(function_call_success, function_response))],
@@ -212,6 +221,8 @@ def create_tool_call_messages_from_openai_response(
         tool_call_id=tool_call_id,
         created_at=get_utc_time(),
     )
+    if pre_computed_tool_message_id:
+        tool_message.id = pre_computed_tool_message_id
     messages.append(tool_message)
 
     if add_heartbeat_request_system_message:
@@ -243,7 +254,7 @@ def create_assistant_messages_from_openai_response(
     """
     tool_call_id = str(uuid.uuid4())
 
-    return create_tool_call_messages_from_openai_response(
+    return create_letta_messages_from_llm_response(
         agent_id=agent_id,
         model=model,
         function_name=DEFAULT_MESSAGE_TOOL,

letta/server/server.py

@@ -19,11 +19,11 @@ import letta.system as system
 from letta.agent import Agent, save_agent
 from letta.config import LettaConfig
 from letta.data_sources.connectors import DataConnector, load_data
-from letta.dynamic_multi_agent import DynamicMultiAgent
 from letta.functions.mcp_client.base_client import BaseMCPClient
 from letta.functions.mcp_client.sse_client import MCP_CONFIG_TOPLEVEL_KEY, SSEMCPClient
 from letta.functions.mcp_client.stdio_client import StdioMCPClient
 from letta.functions.mcp_client.types import MCPServerType, MCPTool, SSEServerConfig, StdioServerConfig
+from letta.groups.helpers import load_multi_agent
 from letta.helpers.datetime_helpers import get_utc_time
 from letta.helpers.json_helpers import json_dumps, json_loads
 from letta.helpers.message_helper import prepare_input_message_create
@@ -32,17 +32,15 @@ from letta.helpers.message_helper import prepare_input_message_create
 from letta.interface import AgentInterface  # abstract
 from letta.interface import CLIInterface  # for printing to terminal
 from letta.log import get_logger
-from letta.offline_memory_agent import OfflineMemoryAgent
 from letta.orm.errors import NoResultFound
-from letta.round_robin_multi_agent import RoundRobinMultiAgent
 from letta.schemas.agent import AgentState, AgentType, CreateAgent, UpdateAgent
-from letta.schemas.block import BlockUpdate
+from letta.schemas.block import BlockUpdate, CreateBlock
 from letta.schemas.embedding_config import EmbeddingConfig
 
 # openai schemas
 from letta.schemas.enums import JobStatus, MessageStreamStatus
 from letta.schemas.environment_variables import SandboxEnvironmentVariableCreate
-from letta.schemas.group import Group, ManagerType
+from letta.schemas.group import GroupCreate, SleeptimeManager
 from letta.schemas.job import Job, JobUpdate
 from letta.schemas.letta_message import LegacyLettaMessage, LettaMessage, ToolReturnMessage
 from letta.schemas.letta_message_content import TextContent
@@ -83,6 +81,7 @@ from letta.services.block_manager import BlockManager
 from letta.services.group_manager import GroupManager
 from letta.services.identity_manager import IdentityManager
 from letta.services.job_manager import JobManager
+from letta.services.llm_batch_manager import LLMBatchManager
 from letta.services.message_manager import MessageManager
 from letta.services.organization_manager import OrganizationManager
 from letta.services.passage_manager import PassageManager
@@ -94,9 +93,9 @@ from letta.services.tool_executor.tool_execution_sandbox import ToolExecutionSan
 from letta.services.tool_manager import ToolManager
 from letta.services.user_manager import UserManager
 from letta.settings import model_settings, settings, tool_settings
-from letta.supervisor_multi_agent import SupervisorMultiAgent
+from letta.sleeptime_agent import SleeptimeAgent
 from letta.tracing import trace_method
-from letta.utils import get_friendly_error_msg
+from letta.utils import get_friendly_error_msg, make_key
 
 config = LettaConfig.load()
 logger = get_logger(__name__)
@@ -209,6 +208,7 @@ class SyncServer(Server):
         self.step_manager = StepManager()
         self.identity_manager = IdentityManager()
         self.group_manager = GroupManager()
+        self.batch_manager = LLMBatchManager()
 
         # Make default user and org
         if init_with_default_org_and_user:
@@ -348,65 +348,28 @@ class SyncServer(Server):
             logger.info(f"MCP tools connected: {', '.join([t.name for t in mcp_tools])}")
             logger.debug(f"MCP tools: {', '.join([str(t) for t in mcp_tools])}")
 
+        # TODO: Remove these in memory caches
+        self._llm_config_cache = {}
+        self._embedding_config_cache = {}
+
     def load_agent(self, agent_id: str, actor: User, interface: Union[AgentInterface, None] = None) -> Agent:
         """Updated method to load agents from persisted storage"""
         agent_state = self.agent_manager.get_agent_by_id(agent_id=agent_id, actor=actor)
         if agent_state.multi_agent_group:
-            return self.load_multi_agent(agent_state.multi_agent_group, actor, interface, agent_state)
+            return load_multi_agent(
+                group=agent_state.multi_agent_group, agent_state=agent_state, actor=actor, interface=interface, mcp_clients=self.mcp_clients
+            )
 
         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, mcp_clients=self.mcp_clients)
-        elif agent_state.agent_type == AgentType.offline_memory_agent:
-            agent = OfflineMemoryAgent(agent_state=agent_state, interface=interface, user=actor)
+        elif agent_state.agent_type == AgentType.sleeptime_agent:
+            agent = SleeptimeAgent(agent_state=agent_state, interface=interface, user=actor)
         else:
             raise ValueError(f"Invalid agent type {agent_state.agent_type}")
 
         return agent
 
-    def load_multi_agent(
-        self, group: Group, actor: User, interface: Union[AgentInterface, None] = None, agent_state: Optional[AgentState] = None
-    ) -> Agent:
-        if len(group.agent_ids) == 0:
-            raise ValueError("Empty group: group must have at least one agent")
-
-        match group.manager_type:
-            case ManagerType.round_robin:
-                agent_state = agent_state or self.agent_manager.get_agent_by_id(agent_id=group.agent_ids[0], actor=actor)
-                return RoundRobinMultiAgent(
-                    agent_state=agent_state,
-                    interface=interface,
-                    user=actor,
-                    group_id=group.id,
-                    agent_ids=group.agent_ids,
-                    description=group.description,
-                    max_turns=group.max_turns,
-                )
-            case ManagerType.dynamic:
-                agent_state = agent_state or self.agent_manager.get_agent_by_id(agent_id=group.manager_agent_id, actor=actor)
-                return DynamicMultiAgent(
-                    agent_state=agent_state,
-                    interface=interface,
-                    user=actor,
-                    group_id=group.id,
-                    agent_ids=group.agent_ids,
-                    description=group.description,
-                    max_turns=group.max_turns,
-                    termination_token=group.termination_token,
-                )
-            case ManagerType.supervisor:
-                agent_state = agent_state or self.agent_manager.get_agent_by_id(agent_id=group.manager_agent_id, actor=actor)
-                return SupervisorMultiAgent(
-                    agent_state=agent_state,
-                    interface=interface,
-                    user=actor,
-                    group_id=group.id,
-                    agent_ids=group.agent_ids,
-                    description=group.description,
-                )
-            case _:
-                raise ValueError(f"Type {group.manager_type} is not supported.")
-
     def _step(
         self,
         actor: User,
@@ -739,6 +702,18 @@ class SyncServer(Server):
                 command = command[1:]  # strip the prefix
         return self._command(user_id=user_id, agent_id=agent_id, command=command)
 
+    def get_cached_llm_config(self, **kwargs):
+        key = make_key(**kwargs)
+        if key not in self._llm_config_cache:
+            self._llm_config_cache[key] = self.get_llm_config_from_handle(**kwargs)
+        return self._llm_config_cache[key]
+
+    def get_cached_embedding_config(self, **kwargs):
+        key = make_key(**kwargs)
+        if key not in self._embedding_config_cache:
+            self._embedding_config_cache[key] = self.get_embedding_config_from_handle(**kwargs)
+        return self._embedding_config_cache[key]
+
     def create_agent(
         self,
         request: CreateAgent,
@@ -749,7 +724,7 @@ class SyncServer(Server):
         if request.llm_config is None:
             if request.model is None:
                 raise ValueError("Must specify either model or llm_config in request")
-            request.llm_config = self.get_llm_config_from_handle(
+            request.llm_config = self.get_cached_llm_config(
                 handle=request.model,
                 context_window_limit=request.context_window_limit,
                 max_tokens=request.max_tokens,
@@ -760,17 +735,21 @@ class SyncServer(Server):
         if request.embedding_config is None:
             if request.embedding is None:
                 raise ValueError("Must specify either embedding or embedding_config in request")
-            request.embedding_config = self.get_embedding_config_from_handle(
-                handle=request.embedding, embedding_chunk_size=request.embedding_chunk_size or constants.DEFAULT_EMBEDDING_CHUNK_SIZE
+            request.embedding_config = self.get_cached_embedding_config(
+                handle=request.embedding,
+                embedding_chunk_size=request.embedding_chunk_size or constants.DEFAULT_EMBEDDING_CHUNK_SIZE,
             )
 
-        """Create a new agent using a config"""
-        # Invoke manager
-        return self.agent_manager.create_agent(
+        main_agent = self.agent_manager.create_agent(
             agent_create=request,
             actor=actor,
         )
 
+        if request.enable_sleeptime:
+            main_agent = self.create_sleeptime_agent(main_agent=main_agent, actor=actor)
+
+        return main_agent
+
     def update_agent(
         self,
         agent_id: str,
@@ -783,13 +762,54 @@ class SyncServer(Server):
         if request.embedding is not None:
             request.embedding_config = self.get_embedding_config_from_handle(handle=request.embedding)
 
-        # Invoke manager
+        if request.enable_sleeptime:
+            agent = self.agent_manager.get_agent_by_id(agent_id=agent_id, actor=actor)
+            if agent.multi_agent_group is None:
+                self.create_sleeptime_agent(main_agent=agent, actor=actor)
+
         return self.agent_manager.update_agent(
             agent_id=agent_id,
             agent_update=request,
             actor=actor,
         )
 
+    def create_sleeptime_agent(self, main_agent: AgentState, actor: User) -> AgentState:
+        request = CreateAgent(
+            name=main_agent.name,
+            agent_type=AgentType.sleeptime_agent,
+            block_ids=[block.id for block in main_agent.memory.blocks],
+            memory_blocks=[
+                CreateBlock(
+                    label="memory_persona",
+                    value=(
+                        "I am an expert conversation memory manager. "
+                        "I manage the memory blocks such that they "
+                        "contain everything that is important about "
+                        "the conversation."
+                    ),
+                ),
+            ],
+            llm_config=main_agent.llm_config,
+            embedding_config=main_agent.embedding_config,
+            project_id=main_agent.project_id,
+        )
+        sleeptime_agent = self.agent_manager.create_agent(
+            agent_create=request,
+            actor=actor,
+        )
+        self.group_manager.create_group(
+            group=GroupCreate(
+                description="",
+                agent_ids=[sleeptime_agent.id],
+                manager_config=SleeptimeManager(
+                    manager_agent_id=main_agent.id,
+                    sleeptime_agent_frequency=5,
+                ),
+            ),
+            actor=actor,
+        )
+        return self.agent_manager.get_agent_by_id(agent_id=main_agent.id, actor=actor)
+
     # convert name->id
 
     # TODO: These can be moved to agent_manager
@@ -892,6 +912,7 @@ class SyncServer(Server):
                 use_assistant_message=use_assistant_message,
                 assistant_message_tool_name=assistant_message_tool_name,
                 assistant_message_tool_kwarg=assistant_message_tool_kwarg,
+                reverse=reverse,
             )
 
         if reverse:
@@ -1102,6 +1123,8 @@ class SyncServer(Server):
                 raise ValueError(f"LLM model {model_name} is not supported by {provider_name}")
         except ValueError as e:
             llm_configs = [config for config in self.get_local_llm_configs() if config.handle == handle]
+            if not llm_configs:
+                llm_configs = [config for config in self.get_local_llm_configs() if config.model == model_name]
             if not llm_configs:
                 raise e
 
@@ -1133,20 +1156,25 @@ class SyncServer(Server):
     def get_embedding_config_from_handle(
         self, handle: str, embedding_chunk_size: int = constants.DEFAULT_EMBEDDING_CHUNK_SIZE
     ) -> EmbeddingConfig:
-        provider_name, model_name = handle.split("/", 1)
-        provider = self.get_provider_from_name(provider_name)
+        try:
+            provider_name, model_name = handle.split("/", 1)
+            provider = self.get_provider_from_name(provider_name)
+
+            embedding_configs = [config for config in provider.list_embedding_models() if config.handle == handle]
+            if not embedding_configs:
+                raise ValueError(f"Embedding model {model_name} is not supported by {provider_name}")
+        except ValueError as e:
+            # search local configs
+            embedding_configs = [config for config in self.get_local_embedding_configs() if config.handle == handle]
+            if not embedding_configs:
+                raise e
 
-        embedding_configs = [config for config in provider.list_embedding_models() if config.handle == handle]
         if len(embedding_configs) == 1:
             embedding_config = embedding_configs[0]
+        elif len(embedding_configs) > 1:
+            raise ValueError(f"Multiple embedding models with name {model_name} supported by {provider_name}")
         else:
-            embedding_configs = [config for config in provider.list_embedding_models() if config.embedding_model == model_name]
-            if not embedding_configs:
-                raise ValueError(f"Embedding model {model_name} is not supported by {provider_name}")
-            elif len(embedding_configs) > 1:
-                raise ValueError(f"Multiple embedding models with name {model_name} supported by {provider_name}")
-            else:
-                embedding_config = embedding_configs[0]
+            embedding_config = embedding_configs[0]
 
         if embedding_chunk_size:
             embedding_config.embedding_chunk_size = embedding_chunk_size
@@ -1183,6 +1211,25 @@ class SyncServer(Server):
             warnings.warn(f"Error reading LLM configs directory: {e}")
         return llm_models
 
+    def get_local_embedding_configs(self):
+        embedding_models = []
+        try:
+            embedding_configs_dir = os.path.expanduser("~/.letta/embedding_configs")
+            if os.path.exists(embedding_configs_dir):
+                for filename in os.listdir(embedding_configs_dir):
+                    if filename.endswith(".json"):
+                        filepath = os.path.join(embedding_configs_dir, filename)
+                        try:
+                            with open(filepath, "r") as f:
+                                config_data = json.load(f)
+                                embedding_config = EmbeddingConfig(**config_data)
+                                embedding_models.append(embedding_config)
+                        except (json.JSONDecodeError, ValueError) as e:
+                            warnings.warn(f"Error parsing embedding config file {filename}: {e}")
+        except Exception as e:
+            warnings.warn(f"Error reading embedding configs directory: {e}")
+        return embedding_models
+
     def add_llm_model(self, request: LLMConfig) -> LLMConfig:
         """Add a new LLM model"""
 
@@ -1599,7 +1646,9 @@ class SyncServer(Server):
             raise ValueError("stream_steps must be 'true' if stream_tokens is 'true'")
 
         group = self.group_manager.retrieve_group(group_id=group_id, actor=actor)
-        letta_multi_agent = self.load_multi_agent(group=group, actor=actor)
+        agent_state_id = group.manager_agent_id or (group.agent_ids[0] if len(group.agent_ids) > 0 else None)
+        agent_state = self.agent_manager.get_agent_by_id(agent_id=agent_state_id, actor=actor) if agent_state_id else None
+        letta_multi_agent = load_multi_agent(group=group, agent_state=agent_state, actor=actor)
 
         llm_config = letta_multi_agent.agent_state.llm_config
         supports_token_streaming = ["openai", "anthropic", "deepseek"]

letta/services/agent_manager.py

@@ -4,13 +4,22 @@ from typing import Dict, List, Optional
 import numpy as np
 from sqlalchemy import Select, and_, func, literal, or_, select, union_all
 
-from letta.constants import BASE_MEMORY_TOOLS, BASE_TOOLS, DATA_SOURCE_ATTACH_ALERT, MAX_EMBEDDING_DIM, MULTI_AGENT_TOOLS
+from letta.constants import (
+    BASE_MEMORY_TOOLS,
+    BASE_SLEEPTIME_CHAT_TOOLS,
+    BASE_SLEEPTIME_TOOLS,
+    BASE_TOOLS,
+    DATA_SOURCE_ATTACH_ALERT,
+    MAX_EMBEDDING_DIM,
+    MULTI_AGENT_TOOLS,
+)
 from letta.embeddings import embedding_model
 from letta.helpers.datetime_helpers import get_utc_time
 from letta.log import get_logger
 from letta.orm import Agent as AgentModel
 from letta.orm import AgentPassage, AgentsTags
 from letta.orm import Block as BlockModel
+from letta.orm import Group as GroupModel
 from letta.orm import Identity as IdentityModel
 from letta.orm import Source as SourceModel
 from letta.orm import SourcePassage, SourcesAgents
@@ -25,6 +34,7 @@ from letta.schemas.agent import AgentType, CreateAgent, UpdateAgent
 from letta.schemas.block import Block as PydanticBlock
 from letta.schemas.block import BlockUpdate
 from letta.schemas.embedding_config import EmbeddingConfig
+from letta.schemas.group import ManagerType
 from letta.schemas.llm_config import LLMConfig
 from letta.schemas.memory import Memory
 from letta.schemas.message import Message as PydanticMessage
@@ -32,6 +42,7 @@ from letta.schemas.message import MessageCreate
 from letta.schemas.passage import Passage as PydanticPassage
 from letta.schemas.source import Source as PydanticSource
 from letta.schemas.tool import Tool as PydanticTool
+from letta.schemas.tool_rule import ChildToolRule as PydanticChildToolRule
 from letta.schemas.tool_rule import ContinueToolRule as PydanticContinueToolRule
 from letta.schemas.tool_rule import TerminalToolRule as PydanticTerminalToolRule
 from letta.schemas.tool_rule import ToolRule as PydanticToolRule
@@ -88,7 +99,11 @@ class AgentManager:
         agent_create: CreateAgent,
         actor: PydanticUser,
     ) -> PydanticAgentState:
-        system = derive_system_message(agent_type=agent_create.agent_type, system=agent_create.system)
+        system = derive_system_message(
+            agent_type=agent_create.agent_type,
+            enable_sleeptime=agent_create.enable_sleeptime,
+            system=agent_create.system,
+        )
 
         if not agent_create.llm_config or not agent_create.embedding_config:
             raise ValueError("llm_config and embedding_config are required")
@@ -104,7 +119,13 @@ class AgentManager:
         # create passed in `tools`
         tool_names = []
         if agent_create.include_base_tools:
-            tool_names.extend(BASE_TOOLS + BASE_MEMORY_TOOLS)
+            if agent_create.agent_type == AgentType.sleeptime_agent:
+                tool_names.extend(BASE_SLEEPTIME_TOOLS)
+            else:
+                if agent_create.enable_sleeptime:
+                    tool_names.extend(BASE_SLEEPTIME_CHAT_TOOLS)
+                else:
+                    tool_names.extend(BASE_TOOLS + BASE_MEMORY_TOOLS)
         if agent_create.include_multi_agent_tools:
             tool_names.extend(MULTI_AGENT_TOOLS)
         if agent_create.tools:
@@ -121,10 +142,14 @@ class AgentManager:
 
             # apply default tool rules
             for tool_name in tool_names:
-                if tool_name == "send_message" or tool_name == "send_message_to_agent_async":
+                if tool_name == "send_message" or tool_name == "send_message_to_agent_async" or tool_name == "finish_rethinking_memory":
                     tool_rules.append(PydanticTerminalToolRule(tool_name=tool_name))
                 elif tool_name in BASE_TOOLS:
                     tool_rules.append(PydanticContinueToolRule(tool_name=tool_name))
+
+            if agent_create.agent_type == AgentType.sleeptime_agent:
+                tool_rules.append(PydanticChildToolRule(tool_name="view_core_memory_with_line_numbers", children=["core_memory_insert"]))
+
         else:
             tool_rules = agent_create.tool_rules
         # Check tool rules are valid
@@ -159,6 +184,7 @@ class AgentManager:
             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,
         )
 
         # If there are provided environment variables, add them in
@@ -223,6 +249,7 @@ class AgentManager:
         template_id: Optional[str] = None,
         base_template_id: Optional[str] = None,
         message_buffer_autoclear: bool = False,
+        enable_sleeptime: Optional[bool] = None,
     ) -> PydanticAgentState:
         """Create a new agent."""
         with self.session_maker() as session:
@@ -241,6 +268,7 @@ class AgentManager:
                 "template_id": template_id,
                 "base_template_id": base_template_id,
                 "message_buffer_autoclear": message_buffer_autoclear,
+                "enable_sleeptime": enable_sleeptime,
             }
 
             # Create the new agent using SqlalchemyBase.create
@@ -269,6 +297,12 @@ class AgentManager:
             )
 
         # Rebuild the system prompt if it's different
+        if agent_update.enable_sleeptime and agent_update.system is None:
+            agent_update.system = derive_system_message(
+                agent_type=agent_state.agent_type,
+                enable_sleeptime=agent_update.enable_sleeptime,
+                system=agent_update.system,
+            )
         if agent_update.system and agent_update.system != agent_state.system:
             agent_state = self.rebuild_system_prompt(agent_id=agent_state.id, actor=actor, force=True, update_timestamp=False)
 
@@ -305,6 +339,7 @@ class AgentManager:
                 "template_id",
                 "base_template_id",
                 "message_buffer_autoclear",
+                "enable_sleeptime",
             }
             for field in scalar_fields:
                 value = getattr(agent_update, field, None)
@@ -461,9 +496,33 @@ class AgentManager:
         """
         with self.session_maker() 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)
-            # TODO check if it is managing a group
-            agent.hard_delete(session)
+            agents_to_delete = [agent]
+            sleeptime_group_to_delete = None
+
+            # Delete sleeptime agent and group
+            if agent.multi_agent_group:
+                participant_agent_ids = agent.multi_agent_group.agent_ids
+                if agent.multi_agent_group.manager_type == ManagerType.sleeptime and len(participant_agent_ids) == 1:
+                    sleeptime_agent = AgentModel.read(db_session=session, identifier=participant_agent_ids[0], actor=actor)
+                    if sleeptime_agent.agent_type == AgentType.sleeptime_agent:
+                        sleeptime_agent_group = GroupModel.read(db_session=session, identifier=agent.multi_agent_group.id, actor=actor)
+                        sleeptime_group_to_delete = sleeptime_agent_group
+                        agents_to_delete.append(sleeptime_agent)
+            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
     def serialize(self, agent_id: str, actor: PydanticUser) -> AgentSchema:
@@ -482,6 +541,7 @@ class AgentManager:
         append_copy_suffix: bool = True,
         override_existing_tools: bool = True,
         project_id: Optional[str] = None,
+        strip_messages: Optional[bool] = False,
     ) -> PydanticAgentState:
         serialized_agent = serialized_agent.model_dump()
         tool_data_list = serialized_agent.pop("tools", [])
@@ -493,6 +553,10 @@ class AgentManager:
                 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]]
             agent = agent.create(session, actor=actor)
             pydantic_agent = agent.to_pydantic()