letta-nightly 0.7.15.dev20250514104255__py3-none-any.whl → 0.7.16.dev20250515205957__py3-none-any.whl

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(
@@ -86,7 +86,7 @@ def list_agents(
     actor = server.user_manager.get_user_or_default(user_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,
@@ -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
@@ -234,14 +234,14 @@ def create_agent(
     """
     try:
         actor = server.user_manager.get_user_or_default(user_id=actor_id)
-        return server.create_agent(agent, actor=actor)
+        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),
@@ -249,7 +249,7 @@ def modify_agent(
 ):
     """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)
+    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")
@@ -632,8 +632,8 @@ async def send_message(
     # TODO: This is redundant, remove soon
     agent = server.agent_manager.get_agent_by_id(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,
@@ -690,11 +690,11 @@ async def send_message_streaming(
     # TODO: This is redundant, remove soon
     agent = server.agent_manager.get_agent_by_id(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
-    model_compatible = agent.llm_config.model_endpoint_type in ["anthropic", "openai"]
+    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 == "anthropic"
 
-    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,

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

@@ -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
 
@@ -103,7 +103,7 @@ async def retrieve_batch_run(
     actor = server.user_manager.get_user_or_default(user_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")
@@ -154,7 +154,7 @@ async def list_batch_messages(
 
     # 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")
@@ -180,8 +180,8 @@ async def cancel_batch_run(
     actor = server.user_manager.get_user_or_default(user_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/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,
@@ -89,9 +89,9 @@ def list_tools(
     try:
         actor = server.user_manager.get_user_or_default(user_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/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",