letta-nightly 0.7.15.dev20250515104317__py3-none-any.whl → 0.7.17.dev20250516090339__py3-none-any.whl

letta/schemas/agent.py

@@ -312,9 +312,17 @@ def get_prompt_template_for_agent_type(agent_type: Optional[AgentType] = None):
         )
     return (
         "{% for block in blocks %}"
-        '<{{ block.label }} characters="{{ block.value|length }}/{{ block.limit }}">\n'
+        "<{{ block.label }}>\n"
+        "<description>\n"
+        "{{ block.description }}\n"
+        "</description>\n"
+        "<metadata>\n"
+        '{% if block.read_only %}read_only="true" {% endif %}chars_current="{{ block.value|length }}" chars_limit="{{ block.limit }}"\n'
+        "</metadata>\n"
+        "<value>\n"
         "{{ block.value }}\n"
-        "</{{ block.label }}>"
+        "</value>\n"
+        "</{{ block.label }}>\n"
         "{% if not loop.last %}\n{% endif %}"
         "{% endfor %}"
     )

letta/schemas/block.py

@@ -25,6 +25,9 @@ class BaseBlock(LettaBase, validate_assignment=True):
     # context window label
     label: Optional[str] = Field(None, description="Label of the block (e.g. 'human', 'persona') in the context window.")
 
+    # permissions of the agent
+    read_only: bool = Field(False, description="Whether the agent has read-only access to the block.")
+
     # metadata
     description: Optional[str] = Field(None, description="Description of the block.")
     metadata: Optional[dict] = Field({}, description="Metadata of the block.")

letta/schemas/memory.py

@@ -69,9 +69,14 @@ class Memory(BaseModel, validate_assignment=True):
     # Memory.template is a Jinja2 template for compiling memory module into a prompt string.
     prompt_template: str = Field(
         default="{% for block in blocks %}"
-        '<{{ block.label }} characters="{{ block.value|length }}/{{ block.limit }}">\n'
+        "<{{ block.label }}>\n"
+        "<metadata>"
+        'read_only="{{ block.read_only}}" chars_current="{{ block.value|length }}" chars_limit="{{ block.limit }}"'
+        "</metadata>"
+        "<value>"
         "{{ block.value }}\n"
-        "</{{ block.label }}>"
+        "</value>"
+        "</{{ block.label }}>\n"
         "{% if not loop.last %}\n{% endif %}"
         "{% endfor %}",
         description="Jinja2 template for compiling memory blocks into a prompt string",

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

@@ -44,7 +44,7 @@ logger = get_logger(__name__)
 
 
 @router.get("/", response_model=List[AgentState], operation_id="list_agents")
-def list_agents(
+async def list_agents(
     name: Optional[str] = Query(None, description="Name of the agent"),
     tags: Optional[List[str]] = Query(None, description="List of tags to filter agents by"),
     match_all_tags: bool = Query(
@@ -83,10 +83,10 @@ def list_agents(
     """
 
     # Retrieve the actor (user) details
-    actor = server.user_manager.get_user_or_default(user_id=actor_id)
+    actor = await server.user_manager.get_actor_or_default_async(actor_id=actor_id)
 
     # Call list_agents directly without unnecessary dict handling
-    return server.agent_manager.list_agents(
+    return await server.agent_manager.list_agents_async(
         actor=actor,
         name=name,
         before=before,
@@ -163,7 +163,7 @@ async def import_agent_serialized(
     """
     Import a serialized agent file and recreate the agent in the system.
     """
-    actor = server.user_manager.get_user_or_default(user_id=actor_id)
+    actor = await server.user_manager.get_actor_or_default_async(actor_id=actor_id)
 
     try:
         serialized_data = await file.read()
@@ -223,7 +223,7 @@ class CreateAgentRequest(CreateAgent):
 
 
 @router.post("/", response_model=AgentState, operation_id="create_agent")
-def create_agent(
+async def create_agent(
     agent: CreateAgentRequest = Body(...),
     server: "SyncServer" = Depends(get_letta_server),
     actor_id: Optional[str] = Header(None, alias="user_id"),  # Extract user_id from header, default to None if not present
@@ -233,23 +233,23 @@ def create_agent(
     Create a new agent with the specified configuration.
     """
     try:
-        actor = server.user_manager.get_user_or_default(user_id=actor_id)
-        return server.create_agent(agent, actor=actor)
+        actor = await server.user_manager.get_actor_or_default_async(actor_id=actor_id)
+        return await server.create_agent_async(agent, actor=actor)
     except Exception as e:
         traceback.print_exc()
         raise HTTPException(status_code=500, detail=str(e))
 
 
 @router.patch("/{agent_id}", response_model=AgentState, operation_id="modify_agent")
-def modify_agent(
+async def modify_agent(
     agent_id: str,
     update_agent: UpdateAgent = Body(...),
     server: "SyncServer" = Depends(get_letta_server),
     actor_id: Optional[str] = Header(None, alias="user_id"),  # Extract user_id from header, default to None if not present
 ):
     """Update an existing agent"""
-    actor = server.user_manager.get_user_or_default(user_id=actor_id)
-    return server.update_agent(agent_id=agent_id, request=update_agent, actor=actor)
+    actor = await server.user_manager.get_actor_or_default_async(actor_id=actor_id)
+    return await server.update_agent_async(agent_id=agent_id, request=update_agent, actor=actor)
 
 
 @router.get("/{agent_id}/tools", response_model=List[Tool], operation_id="list_agent_tools")
@@ -333,7 +333,7 @@ def detach_source(
 
 
 @router.get("/{agent_id}", response_model=AgentState, operation_id="retrieve_agent")
-def retrieve_agent(
+async def retrieve_agent(
     agent_id: str,
     server: "SyncServer" = Depends(get_letta_server),
     actor_id: Optional[str] = Header(None, alias="user_id"),  # Extract user_id from header, default to None if not present
@@ -344,7 +344,7 @@ def retrieve_agent(
     actor = server.user_manager.get_user_or_default(user_id=actor_id)
 
     try:
-        return server.agent_manager.get_agent_by_id(agent_id=agent_id, actor=actor)
+        return await server.agent_manager.get_agent_by_id_async(agent_id=agent_id, actor=actor)
     except NoResultFound as e:
         raise HTTPException(status_code=404, detail=str(e))
 
@@ -414,7 +414,7 @@ def retrieve_block(
 
 
 @router.get("/{agent_id}/core-memory/blocks", response_model=List[Block], operation_id="list_core_memory_blocks")
-def list_blocks(
+async def list_blocks(
     agent_id: str,
     server: "SyncServer" = Depends(get_letta_server),
     actor_id: Optional[str] = Header(None, alias="user_id"),  # Extract user_id from header, default to None if not present
@@ -424,7 +424,7 @@ def list_blocks(
     """
     actor = server.user_manager.get_user_or_default(user_id=actor_id)
     try:
-        agent = server.agent_manager.get_agent_by_id(agent_id, actor)
+        agent = await server.agent_manager.get_agent_by_id_async(agent_id, actor)
         return agent.memory.blocks
     except NoResultFound as e:
         raise HTTPException(status_code=404, detail=str(e))
@@ -628,12 +628,12 @@ async def send_message(
     Process a user message and return the agent's response.
     This endpoint accepts a message from a user and processes it through the agent.
     """
-    actor = server.user_manager.get_user_or_default(user_id=actor_id)
+    actor = await server.user_manager.get_actor_or_default_async(actor_id=actor_id)
     # TODO: This is redundant, remove soon
-    agent = server.agent_manager.get_agent_by_id(agent_id, actor)
+    agent = await server.agent_manager.get_agent_by_id_async(agent_id, actor)
     agent_eligible = not agent.enable_sleeptime and not agent.multi_agent_group and agent.agent_type != AgentType.sleeptime_agent
-    experimental_header = request_obj.headers.get("x-experimental")
-    feature_enabled = settings.use_experimental or experimental_header
+    experimental_header = request_obj.headers.get("X-EXPERIMENTAL") or "false"
+    feature_enabled = settings.use_experimental or experimental_header.lower() == "true"
     model_compatible = agent.llm_config.model_endpoint_type in ["anthropic", "openai", "google_vertex", "google_ai"]
 
     if agent_eligible and feature_enabled and model_compatible:
@@ -646,7 +646,7 @@ async def send_message(
             actor=actor,
         )
 
-        result = await experimental_agent.step(request.messages, max_steps=10)
+        result = await experimental_agent.step(request.messages, max_steps=10, use_assistant_message=request.use_assistant_message)
     else:
         result = await server.send_message_to_agent(
             agent_id=agent_id,
@@ -686,15 +686,15 @@ async def send_message_streaming(
     It will stream the steps of the response always, and stream the tokens if 'stream_tokens' is set to True.
     """
     request_start_timestamp_ns = get_utc_timestamp_ns()
-    actor = server.user_manager.get_user_or_default(user_id=actor_id)
+    actor = await server.user_manager.get_actor_or_default_async(actor_id=actor_id)
     # TODO: This is redundant, remove soon
-    agent = server.agent_manager.get_agent_by_id(agent_id, actor)
+    agent = await server.agent_manager.get_agent_by_id_async(agent_id, actor)
     agent_eligible = not agent.enable_sleeptime and not agent.multi_agent_group and agent.agent_type != AgentType.sleeptime_agent
-    experimental_header = request_obj.headers.get("x-experimental")
-    feature_enabled = settings.use_experimental or experimental_header
+    experimental_header = request_obj.headers.get("X-EXPERIMENTAL") or "false"
+    feature_enabled = settings.use_experimental or experimental_header.lower() == "true"
     model_compatible = agent.llm_config.model_endpoint_type in ["anthropic", "openai"]
 
-    if agent_eligible and feature_enabled and model_compatible:
+    if agent_eligible and feature_enabled and model_compatible and request.stream_tokens:
         experimental_agent = LettaAgent(
             agent_id=agent_id,
             message_manager=server.message_manager,
@@ -705,7 +705,9 @@ async def send_message_streaming(
         )
 
         result = StreamingResponse(
-            experimental_agent.step_stream(request.messages, max_steps=10, use_assistant_message=request.use_assistant_message),
+            experimental_agent.step_stream(
+                request.messages, max_steps=10, use_assistant_message=request.use_assistant_message, stream_tokens=request.stream_tokens
+            ),
             media_type="text/event-stream",
         )
     else:
@@ -784,7 +786,7 @@ async def send_message_async(
     Asynchronously process a user message and return a run object.
     The actual processing happens in the background, and the status can be checked using the run ID.
     """
-    actor = server.user_manager.get_user_or_default(user_id=actor_id)
+    actor = await server.user_manager.get_actor_or_default_async(actor_id=actor_id)
 
     # Create a new job
     run = Run(
@@ -838,6 +840,6 @@ async def list_agent_groups(
     actor_id: Optional[str] = Header(None, alias="user_id"),  # Extract user_id from header, default to None if not present
 ):
     """Lists the groups for an agent"""
-    actor = server.user_manager.get_user_or_default(user_id=actor_id)
+    actor = await server.user_manager.get_actor_or_default_async(actor_id=actor_id)
     print("in list agents with manager_type", manager_type)
     return server.agent_manager.list_groups(agent_id=agent_id, manager_type=manager_type, actor=actor)

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

@@ -26,7 +26,7 @@ async def list_blocks(
     server: SyncServer = Depends(get_letta_server),
     actor_id: Optional[str] = Header(None, alias="user_id"),  # Extract user_id from header, default to None if not present
 ):
-    actor = server.user_manager.get_user_or_default(user_id=actor_id)
+    actor = await server.user_manager.get_actor_or_default_async(actor_id=actor_id)
     return await server.block_manager.get_blocks_async(
         actor=actor,
         label=label,

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

@@ -135,7 +135,7 @@ async def send_group_message(
     Process a user message and return the group's response.
     This endpoint accepts a message from a user and processes it through through agents in the group based on the specified pattern
     """
-    actor = server.user_manager.get_user_or_default(user_id=actor_id)
+    actor = await server.user_manager.get_actor_or_default_async(actor_id=actor_id)
     result = await server.send_group_message_to_agent(
         group_id=group_id,
         actor=actor,
@@ -174,7 +174,7 @@ async def send_group_message_streaming(
     This endpoint accepts a message from a user and processes it through agents in the group based on the specified pattern.
     It will stream the steps of the response always, and stream the tokens if 'stream_tokens' is set to True.
     """
-    actor = server.user_manager.get_user_or_default(user_id=actor_id)
+    actor = await server.user_manager.get_actor_or_default_async(actor_id=actor_id)
     result = await server.send_group_message_to_agent(
         group_id=group_id,
         actor=actor,

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

@@ -52,7 +52,7 @@ async def create_messages_batch(
             detail=f"Server misconfiguration: LETTA_ENABLE_BATCH_JOB_POLLING is set to False.",
         )
 
-    actor = server.user_manager.get_user_or_default(user_id=actor_id)
+    actor = await server.user_manager.get_actor_or_default_async(actor_id=actor_id)
     batch_job = BatchJob(
         user_id=actor.id,
         status=JobStatus.running,
@@ -63,7 +63,7 @@ async def create_messages_batch(
     )
 
     try:
-        batch_job = server.job_manager.create_job(pydantic_job=batch_job, actor=actor)
+        batch_job = await server.job_manager.create_job_async(pydantic_job=batch_job, actor=actor)
 
         # create the batch runner
         batch_runner = LettaAgentBatch(
@@ -86,7 +86,7 @@ async def create_messages_batch(
         traceback.print_exc()
 
         # mark job as failed
-        server.job_manager.update_job_by_id(job_id=batch_job.id, job=BatchJob(status=JobStatus.failed), actor=actor)
+        await server.job_manager.update_job_by_id_async(job_id=batch_job.id, job_update=JobUpdate(status=JobStatus.failed), actor=actor)
         raise
     return batch_job
 
@@ -100,10 +100,10 @@ async def retrieve_batch_run(
     """
     Get the status of a batch run.
     """
-    actor = server.user_manager.get_user_or_default(user_id=actor_id)
+    actor = await server.user_manager.get_actor_or_default_async(actor_id=actor_id)
 
     try:
-        job = server.job_manager.get_job_by_id(job_id=batch_id, actor=actor)
+        job = await server.job_manager.get_job_by_id_async(job_id=batch_id, actor=actor)
         return BatchJob.from_job(job)
     except NoResultFound:
         raise HTTPException(status_code=404, detail="Batch not found")
@@ -118,7 +118,7 @@ async def list_batch_runs(
     List all batch runs.
     """
     # TODO: filter
-    actor = server.user_manager.get_user_or_default(user_id=actor_id)
+    actor = await server.user_manager.get_actor_or_default_async(actor_id=actor_id)
 
     jobs = server.job_manager.list_jobs(actor=actor, statuses=[JobStatus.created, JobStatus.running], job_type=JobType.BATCH)
     return [BatchJob.from_job(job) for job in jobs]
@@ -150,11 +150,11 @@ async def list_batch_messages(
     - For subsequent pages, use the ID of the last message from the previous response as the cursor
     - Results will include messages before/after the cursor based on sort_descending
     """
-    actor = server.user_manager.get_user_or_default(user_id=actor_id)
+    actor = await server.user_manager.get_actor_or_default_async(actor_id=actor_id)
 
     # First, verify the batch job exists and the user has access to it
     try:
-        job = server.job_manager.get_job_by_id(job_id=batch_id, actor=actor)
+        job = await server.job_manager.get_job_by_id_async(job_id=batch_id, actor=actor)
         BatchJob.from_job(job)
     except NoResultFound:
         raise HTTPException(status_code=404, detail="Batch not found")
@@ -177,11 +177,11 @@ async def cancel_batch_run(
     """
     Cancel a batch run.
     """
-    actor = server.user_manager.get_user_or_default(user_id=actor_id)
+    actor = await server.user_manager.get_actor_or_default_async(actor_id=actor_id)
 
     try:
-        job = server.job_manager.get_job_by_id(job_id=batch_id, actor=actor)
-        job = server.job_manager.update_job_by_id(job_id=job.id, job_update=JobUpdate(status=JobStatus.cancelled), actor=actor)
+        job = await server.job_manager.get_job_by_id_async(job_id=batch_id, actor=actor)
+        job = await server.job_manager.update_job_by_id_async(job_id=job.id, job_update=JobUpdate(status=JobStatus.cancelled), actor=actor)
 
         # Get related llm batch jobs
         llm_batch_jobs = server.batch_manager.list_llm_batch_jobs(letta_batch_id=job.id, actor=actor)

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

@@ -115,7 +115,7 @@ async def list_run_messages(
     if order not in ["asc", "desc"]:
         raise HTTPException(status_code=400, detail="Order must be 'asc' or 'desc'")
 
-    actor = server.user_manager.get_user_or_default(user_id=actor_id)
+    actor = await server.user_manager.get_actor_or_default_async(actor_id=actor_id)
 
     try:
         messages = server.job_manager.get_run_messages(
@@ -182,7 +182,7 @@ async def list_run_steps(
     if order not in ["asc", "desc"]:
         raise HTTPException(status_code=400, detail="Order must be 'asc' or 'desc'")
 
-    actor = server.user_manager.get_user_or_default(user_id=actor_id)
+    actor = await server.user_manager.get_actor_or_default_async(actor_id=actor_id)
 
     try:
         steps = server.job_manager.get_job_steps(

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

@@ -76,7 +76,7 @@ def retrieve_tool(
 
 
 @router.get("/", response_model=List[Tool], operation_id="list_tools")
-def list_tools(
+async def list_tools(
     after: Optional[str] = None,
     limit: Optional[int] = 50,
     name: Optional[str] = None,
@@ -87,11 +87,11 @@ def list_tools(
     Get a list of all tools available to agents belonging to the org of the user
     """
     try:
-        actor = server.user_manager.get_user_or_default(user_id=actor_id)
+        actor = await server.user_manager.get_actor_or_default_async(actor_id=actor_id)
         if name is not None:
-            tool = server.tool_manager.get_tool_by_name(tool_name=name, actor=actor)
+            tool = await server.tool_manager.get_tool_by_name_async(tool_name=name, actor=actor)
             return [tool] if tool else []
-        return server.tool_manager.list_tools(actor=actor, after=after, limit=limit)
+        return await server.tool_manager.list_tools_async(actor=actor, after=after, limit=limit)
     except Exception as e:
         # Log or print the full exception here for debugging
         print(f"Error occurred: {e}")

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

@@ -14,7 +14,7 @@ router = APIRouter(prefix="/users", tags=["users", "admin"])
 
 
 @router.get("/", tags=["admin"], response_model=List[User], operation_id="list_users")
-def list_users(
+async def list_users(
     after: Optional[str] = Query(None),
     limit: Optional[int] = Query(50),
     server: "SyncServer" = Depends(get_letta_server),
@@ -23,7 +23,7 @@ def list_users(
     Get a list of all users in the database
     """
     try:
-        users = server.user_manager.list_users(after=after, limit=limit)
+        users = await server.user_manager.list_actors_async(after=after, limit=limit)
     except HTTPException:
         raise
     except Exception as e:
@@ -32,7 +32,7 @@ def list_users(
 
 
 @router.post("/", tags=["admin"], response_model=User, operation_id="create_user")
-def create_user(
+async def create_user(
     request: UserCreate = Body(...),
     server: "SyncServer" = Depends(get_letta_server),
 ):
@@ -40,33 +40,33 @@ def create_user(
     Create a new user in the database
     """
     user = User(**request.model_dump())
-    user = server.user_manager.create_user(user)
+    user = await server.user_manager.create_actor_async(user)
     return user
 
 
 @router.put("/", tags=["admin"], response_model=User, operation_id="update_user")
-def update_user(
+async def update_user(
     user: UserUpdate = Body(...),
     server: "SyncServer" = Depends(get_letta_server),
 ):
     """
     Update a user in the database
     """
-    user = server.user_manager.update_user(user)
+    user = await server.user_manager.update_actor_async(user)
     return user
 
 
 @router.delete("/", tags=["admin"], response_model=User, operation_id="delete_user")
-def delete_user(
+async def delete_user(
     user_id: str = Query(..., description="The user_id key to be deleted."),
     server: "SyncServer" = Depends(get_letta_server),
 ):
     # TODO make a soft deletion, instead of a hard deletion
     try:
-        user = server.user_manager.get_user_by_id(user_id=user_id)
+        user = await server.user_manager.get_actor_by_id_async(actor_id=user_id)
         if user is None:
             raise HTTPException(status_code=404, detail=f"User does not exist")
-        server.user_manager.delete_user_by_id(user_id=user_id)
+        await server.user_manager.delete_actor_by_id_async(user_id=user_id)
     except HTTPException:
         raise
     except Exception as e:

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

@@ -36,7 +36,7 @@ async def create_voice_chat_completions(
     server: "SyncServer" = Depends(get_letta_server),
     user_id: Optional[str] = Header(None, alias="user_id"),
 ):
-    actor = server.user_manager.get_user_or_default(user_id=user_id)
+    actor = await server.user_manager.get_actor_or_default_async(actor_id=user_id)
 
     # Create OpenAI async client
     client = openai.AsyncClient(

letta/server/server.py

@@ -794,6 +794,54 @@ class SyncServer(Server):
 
         return main_agent
 
+    @trace_method
+    async def create_agent_async(
+        self,
+        request: CreateAgent,
+        actor: User,
+        # interface
+        interface: Union[AgentInterface, None] = None,
+    ) -> AgentState:
+        if request.llm_config is None:
+            if request.model is None:
+                raise ValueError("Must specify either model or llm_config in request")
+            config_params = {
+                "handle": request.model,
+                "context_window_limit": request.context_window_limit,
+                "max_tokens": request.max_tokens,
+                "max_reasoning_tokens": request.max_reasoning_tokens,
+                "enable_reasoner": request.enable_reasoner,
+            }
+            log_event(name="start get_cached_llm_config", attributes=config_params)
+            request.llm_config = self.get_cached_llm_config(actor=actor, **config_params)
+            log_event(name="end get_cached_llm_config", attributes=config_params)
+
+        if request.embedding_config is None:
+            if request.embedding is None:
+                raise ValueError("Must specify either embedding or embedding_config in request")
+            embedding_config_params = {
+                "handle": request.embedding,
+                "embedding_chunk_size": request.embedding_chunk_size or constants.DEFAULT_EMBEDDING_CHUNK_SIZE,
+            }
+            log_event(name="start get_cached_embedding_config", attributes=embedding_config_params)
+            request.embedding_config = self.get_cached_embedding_config(actor=actor, **embedding_config_params)
+            log_event(name="end get_cached_embedding_config", attributes=embedding_config_params)
+
+        log_event(name="start create_agent db")
+        main_agent = await self.agent_manager.create_agent_async(
+            agent_create=request,
+            actor=actor,
+        )
+        log_event(name="end create_agent db")
+
+        if request.enable_sleeptime:
+            if request.agent_type == AgentType.voice_convo_agent:
+                main_agent = self.create_voice_sleeptime_agent(main_agent=main_agent, actor=actor)
+            else:
+                main_agent = self.create_sleeptime_agent(main_agent=main_agent, actor=actor)
+
+        return main_agent
+
     def update_agent(
         self,
         agent_id: str,
@@ -820,6 +868,32 @@ class SyncServer(Server):
             actor=actor,
         )
 
+    async def update_agent_async(
+        self,
+        agent_id: str,
+        request: UpdateAgent,
+        actor: User,
+    ) -> AgentState:
+        if request.model is not None:
+            request.llm_config = self.get_llm_config_from_handle(handle=request.model, actor=actor)
+
+        if request.embedding is not None:
+            request.embedding_config = self.get_embedding_config_from_handle(handle=request.embedding, actor=actor)
+
+        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:
+                if agent.agent_type == AgentType.voice_convo_agent:
+                    self.create_voice_sleeptime_agent(main_agent=agent, actor=actor)
+                else:
+                    self.create_sleeptime_agent(main_agent=agent, actor=actor)
+
+        return await self.agent_manager.update_agent_async(
+            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 + "-sleeptime",