letta-nightly 0.6.4.dev20241213193437__py3-none-any.whl → 0.6.4.dev20241215104129__py3-none-any.whl

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

@@ -17,7 +17,8 @@ from fastapi.responses import JSONResponse, StreamingResponse
 from pydantic import Field
 
 from letta.constants import DEFAULT_MESSAGE_TOOL, DEFAULT_MESSAGE_TOOL_KWARG
-from letta.schemas.agent import AgentState, CreateAgent, UpdateAgentState
+from letta.orm.errors import NoResultFound
+from letta.schemas.agent import AgentState, CreateAgent, UpdateAgent
 from letta.schemas.block import (  # , BlockLabelUpdate, BlockLimitUpdate
     Block,
     BlockUpdate,
@@ -54,23 +55,38 @@ from letta.server.server import SyncServer
 router = APIRouter(prefix="/agents", tags=["agents"])
 
 
+# TODO: This should be paginated
 @router.get("/", response_model=List[AgentState], operation_id="list_agents")
 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(
+        False,
+        description="If True, only returns agents that match ALL given tags. Otherwise, return agents that have ANY of the passed in tags.",
+    ),
     server: "SyncServer" = Depends(get_letta_server),
-    user_id: Optional[str] = Header(None, alias="user_id"),  # Extract user_id from header, default to None if not present
+    user_id: Optional[str] = Header(None, alias="user_id"),
+    # Extract user_id from header, default to None if not present
 ):
     """
     List all agents associated with a given user.
     This endpoint retrieves a list of all agents and their configurations associated with the specified user ID.
     """
-    actor = server.get_user_or_default(user_id=user_id)
-
-    agents = server.list_agents(user_id=actor.id, tags=tags)
-    # TODO: move this logic to the ORM
-    if name:
-        agents = [a for a in agents if a.name == name]
+    actor = server.user_manager.get_user_or_default(user_id=user_id)
+
+    # Use dictionary comprehension to build kwargs dynamically
+    kwargs = {
+        key: value
+        for key, value in {
+            "tags": tags,
+            "match_all_tags": match_all_tags,
+            "name": name,
+        }.items()
+        if value is not None
+    }
+
+    # Call list_agents with the dynamic kwargs
+    agents = server.agent_manager.list_agents(actor=actor, **kwargs)
     return agents
 
 
@@ -83,7 +99,7 @@ def get_agent_context_window(
     """
     Retrieve the context window of a specific agent.
     """
-    actor = server.get_user_or_default(user_id=user_id)
+    actor = server.user_manager.get_user_or_default(user_id=user_id)
 
     return server.get_agent_context_window(user_id=actor.id, agent_id=agent_id)
 
@@ -106,20 +122,20 @@ def create_agent(
     """
     Create a new agent with the specified configuration.
     """
-    actor = server.get_user_or_default(user_id=user_id)
+    actor = server.user_manager.get_user_or_default(user_id=user_id)
     return server.create_agent(agent, actor=actor)
 
 
 @router.patch("/{agent_id}", response_model=AgentState, operation_id="update_agent")
 def update_agent(
     agent_id: str,
-    update_agent: UpdateAgentState = Body(...),
+    update_agent: UpdateAgent = Body(...),
     server: "SyncServer" = Depends(get_letta_server),
     user_id: Optional[str] = Header(None, alias="user_id"),  # Extract user_id from header, default to None if not present
 ):
     """Update an exsiting agent"""
-    actor = server.get_user_or_default(user_id=user_id)
-    return server.update_agent(update_agent, actor=actor)
+    actor = server.user_manager.get_user_or_default(user_id=user_id)
+    return server.update_agent(agent_id, update_agent, actor=actor)
 
 
 @router.get("/{agent_id}/tools", response_model=List[Tool], operation_id="get_tools_from_agent")
@@ -129,7 +145,7 @@ def get_tools_from_agent(
     user_id: Optional[str] = Header(None, alias="user_id"),  # Extract user_id from header, default to None if not present
 ):
     """Get tools from an existing agent"""
-    actor = server.get_user_or_default(user_id=user_id)
+    actor = server.user_manager.get_user_or_default(user_id=user_id)
     return server.get_tools_from_agent(agent_id=agent_id, user_id=actor.id)
 
 
@@ -141,7 +157,7 @@ def add_tool_to_agent(
     user_id: Optional[str] = Header(None, alias="user_id"),  # Extract user_id from header, default to None if not present
 ):
     """Add tools to an existing agent"""
-    actor = server.get_user_or_default(user_id=user_id)
+    actor = server.user_manager.get_user_or_default(user_id=user_id)
     return server.add_tool_to_agent(agent_id=agent_id, tool_id=tool_id, user_id=actor.id)
 
 
@@ -153,7 +169,7 @@ def remove_tool_from_agent(
     user_id: Optional[str] = Header(None, alias="user_id"),  # Extract user_id from header, default to None if not present
 ):
     """Add tools to an existing agent"""
-    actor = server.get_user_or_default(user_id=user_id)
+    actor = server.user_manager.get_user_or_default(user_id=user_id)
     return server.remove_tool_from_agent(agent_id=agent_id, tool_id=tool_id, user_id=actor.id)
 
 
@@ -166,13 +182,12 @@ def get_agent_state(
     """
     Get the state of the agent.
     """
-    actor = server.get_user_or_default(user_id=user_id)
+    actor = server.user_manager.get_user_or_default(user_id=user_id)
 
-    if not server.ms.get_agent(user_id=actor.id, agent_id=agent_id):
-        # agent does not exist
-        raise HTTPException(status_code=404, detail=f"Agent agent_id={agent_id} not found.")
-
-    return server.get_agent_state(user_id=actor.id, agent_id=agent_id)
+    try:
+        return server.agent_manager.get_agent_by_id(agent_id=agent_id, actor=actor)
+    except NoResultFound as e:
+        raise HTTPException(status_code=404, detail=str(e))
 
 
 @router.delete("/{agent_id}", response_model=AgentState, operation_id="delete_agent")
@@ -184,38 +199,37 @@ def delete_agent(
     """
     Delete an agent.
     """
-    actor = server.get_user_or_default(user_id=user_id)
-
-    agent = server.get_agent(agent_id)
-    if not agent:
-        raise HTTPException(status_code=404, detail=f"Agent agent_id={agent_id} not found.")
-
-    server.delete_agent(user_id=actor.id, agent_id=agent_id)
-    return agent
+    actor = server.user_manager.get_user_or_default(user_id=user_id)
+    try:
+        return server.agent_manager.delete_agent(agent_id=agent_id, actor=actor)
+    except NoResultFound:
+        raise HTTPException(status_code=404, detail=f"Agent agent_id={agent_id} not found for user_id={actor.id}.")
 
 
 @router.get("/{agent_id}/sources", response_model=List[Source], operation_id="get_agent_sources")
 def get_agent_sources(
     agent_id: str,
     server: "SyncServer" = Depends(get_letta_server),
+    user_id: Optional[str] = Header(None, alias="user_id"),  # Extract user_id from header, default to None if not present
 ):
     """
     Get the sources associated with an agent.
     """
-
-    return server.list_attached_sources(agent_id)
+    actor = server.user_manager.get_user_or_default(user_id=user_id)
+    return server.agent_manager.list_attached_sources(agent_id=agent_id, actor=actor)
 
 
 @router.get("/{agent_id}/memory/messages", response_model=List[Message], operation_id="list_agent_in_context_messages")
 def get_agent_in_context_messages(
     agent_id: str,
     server: "SyncServer" = Depends(get_letta_server),
+    user_id: Optional[str] = Header(None, alias="user_id"),  # Extract user_id from header, default to None if not present
 ):
     """
     Retrieve the messages in the context of a specific agent.
     """
-
-    return server.get_in_context_messages(agent_id=agent_id)
+    actor = server.user_manager.get_user_or_default(user_id=user_id)
+    return server.get_in_context_messages(agent_id=agent_id, actor=actor)
 
 
 # TODO: remove? can also get with agent blocks
@@ -223,13 +237,15 @@ def get_agent_in_context_messages(
 def get_agent_memory(
     agent_id: str,
     server: "SyncServer" = Depends(get_letta_server),
+    user_id: Optional[str] = Header(None, alias="user_id"),  # Extract user_id from header, default to None if not present
 ):
     """
     Retrieve the memory state of a specific agent.
     This endpoint fetches the current memory state of the agent identified by the user ID and agent ID.
     """
+    actor = server.user_manager.get_user_or_default(user_id=user_id)
 
-    return server.get_agent_memory(agent_id=agent_id)
+    return server.get_agent_memory(agent_id=agent_id, actor=actor)
 
 
 @router.get("/{agent_id}/memory/block/{block_label}", response_model=Block, operation_id="get_agent_memory_block")
@@ -242,10 +258,12 @@ def get_agent_memory_block(
     """
     Retrieve a memory block from an agent.
     """
-    actor = server.get_user_or_default(user_id=user_id)
+    actor = server.user_manager.get_user_or_default(user_id=user_id)
 
-    block_id = server.blocks_agents_manager.get_block_id_for_label(agent_id=agent_id, block_label=block_label)
-    return server.block_manager.get_block_by_id(block_id, actor=actor)
+    try:
+        return server.agent_manager.get_block_with_label(agent_id=agent_id, block_label=block_label, actor=actor)
+    except NoResultFound as e:
+        raise HTTPException(status_code=404, detail=str(e))
 
 
 @router.get("/{agent_id}/memory/block", response_model=List[Block], operation_id="get_agent_memory_blocks")
@@ -257,9 +275,12 @@ def get_agent_memory_blocks(
     """
     Retrieve the memory blocks of a specific agent.
     """
-    actor = server.get_user_or_default(user_id=user_id)
-    block_ids = server.blocks_agents_manager.list_block_ids_for_agent(agent_id=agent_id)
-    return [server.block_manager.get_block_by_id(block_id, actor=actor) for block_id in block_ids]
+    actor = server.user_manager.get_user_or_default(user_id=user_id)
+    try:
+        agent = server.agent_manager.get_agent_by_id(agent_id, actor=actor)
+        return agent.memory.blocks
+    except NoResultFound as e:
+        raise HTTPException(status_code=404, detail=str(e))
 
 
 @router.post("/{agent_id}/memory/block", response_model=Memory, operation_id="add_agent_memory_block")
@@ -272,16 +293,17 @@ def add_agent_memory_block(
     """
     Creates a memory block and links it to the agent.
     """
-    actor = server.get_user_or_default(user_id=user_id)
+    actor = server.user_manager.get_user_or_default(user_id=user_id)
 
     # Copied from POST /blocks
+    # TODO: Should have block_manager accept only CreateBlock
+    # TODO: This will be possible once we move ID creation to the ORM
     block_req = Block(**create_block.model_dump())
     block = server.block_manager.create_or_update_block(actor=actor, block=block_req)
 
     # Link the block to the agent
-    updated_memory = server.link_block_to_agent_memory(user_id=actor.id, agent_id=agent_id, block_id=block.id)
-
-    return updated_memory
+    agent = server.agent_manager.attach_block(agent_id=agent_id, block_id=block.id, actor=actor)
+    return agent.memory
 
 
 @router.delete("/{agent_id}/memory/block/{block_label}", response_model=Memory, operation_id="remove_agent_memory_block_by_label")
@@ -296,56 +318,56 @@ def remove_agent_memory_block(
     """
     Removes a memory block from an agent by unlnking it. If the block is not linked to any other agent, it is deleted.
     """
-    actor = server.get_user_or_default(user_id=user_id)
+    actor = server.user_manager.get_user_or_default(user_id=user_id)
 
     # Unlink the block from the agent
-    updated_memory = server.unlink_block_from_agent_memory(user_id=actor.id, agent_id=agent_id, block_label=block_label)
+    agent = server.agent_manager.detach_block_with_label(agent_id=agent_id, block_label=block_label, actor=actor)
 
-    return updated_memory
+    return agent.memory
 
 
 @router.patch("/{agent_id}/memory/block/{block_label}", response_model=Block, operation_id="update_agent_memory_block_by_label")
 def update_agent_memory_block(
     agent_id: str,
     block_label: str,
-    update_block: BlockUpdate = Body(...),
+    block_update: BlockUpdate = Body(...),
     server: "SyncServer" = Depends(get_letta_server),
     user_id: Optional[str] = Header(None, alias="user_id"),  # Extract user_id from header, default to None if not present
 ):
     """
     Removes a memory block from an agent by unlnking it. If the block is not linked to any other agent, it is deleted.
     """
-    actor = server.get_user_or_default(user_id=user_id)
-
-    # get the block_id from the label
-    block_id = server.blocks_agents_manager.get_block_id_for_label(agent_id=agent_id, block_label=block_label)
+    actor = server.user_manager.get_user_or_default(user_id=user_id)
 
-    # update the block
-    return server.block_manager.update_block(block_id=block_id, block_update=update_block, actor=actor)
+    block = server.agent_manager.get_block_with_label(agent_id=agent_id, block_label=block_label, actor=actor)
+    return server.block_manager.update_block(block.id, block_update=block_update, actor=actor)
 
 
 @router.get("/{agent_id}/memory/recall", response_model=RecallMemorySummary, operation_id="get_agent_recall_memory_summary")
 def get_agent_recall_memory_summary(
     agent_id: str,
     server: "SyncServer" = Depends(get_letta_server),
+    user_id: Optional[str] = Header(None, alias="user_id"),  # Extract user_id from header, default to None if not present
 ):
     """
     Retrieve the summary of the recall memory of a specific agent.
     """
+    actor = server.user_manager.get_user_or_default(user_id=user_id)
 
-    return server.get_recall_memory_summary(agent_id=agent_id)
+    return server.get_recall_memory_summary(agent_id=agent_id, actor=actor)
 
 
 @router.get("/{agent_id}/memory/archival", response_model=ArchivalMemorySummary, operation_id="get_agent_archival_memory_summary")
 def get_agent_archival_memory_summary(
     agent_id: str,
     server: "SyncServer" = Depends(get_letta_server),
+    user_id: Optional[str] = Header(None, alias="user_id"),  # Extract user_id from header, default to None if not present
 ):
     """
     Retrieve the summary of the archival memory of a specific agent.
     """
-
-    return server.get_archival_memory_summary(agent_id=agent_id)
+    actor = server.user_manager.get_user_or_default(user_id=user_id)
+    return server.get_archival_memory_summary(agent_id=agent_id, actor=actor)
 
 
 @router.get("/{agent_id}/archival", response_model=List[Passage], operation_id="list_agent_archival_memory")
@@ -360,7 +382,7 @@ def get_agent_archival_memory(
     """
     Retrieve the memories in an agent's archival memory store (paginated query).
     """
-    actor = server.get_user_or_default(user_id=user_id)
+    actor = server.user_manager.get_user_or_default(user_id=user_id)
 
     # TODO need to add support for non-postgres here
     # chroma will throw:
@@ -369,7 +391,7 @@ def get_agent_archival_memory(
     return server.get_agent_archival_cursor(
         user_id=actor.id,
         agent_id=agent_id,
-        cursor=after, # TODO: deleting before, after. is this expected?
+        cursor=after,  # TODO: deleting before, after. is this expected?
         limit=limit,
     )
 
@@ -384,9 +406,9 @@ def insert_agent_archival_memory(
     """
     Insert a memory into an agent's archival memory store.
     """
-    actor = server.get_user_or_default(user_id=user_id)
+    actor = server.user_manager.get_user_or_default(user_id=user_id)
 
-    return server.insert_archival_memory(user_id=actor.id, agent_id=agent_id, memory_contents=request.text)
+    return server.insert_archival_memory(agent_id=agent_id, memory_contents=request.text, actor=actor)
 
 
 # TODO(ethan): query or path parameter for memory_id?
@@ -402,9 +424,9 @@ def delete_agent_archival_memory(
     """
     Delete a memory from an agent's archival memory store.
     """
-    actor = server.get_user_or_default(user_id=user_id)
+    actor = server.user_manager.get_user_or_default(user_id=user_id)
 
-    server.delete_archival_memory(user_id=actor.id, agent_id=agent_id, memory_id=memory_id)
+    server.delete_archival_memory(agent_id=agent_id, memory_id=memory_id, actor=actor)
     return JSONResponse(status_code=status.HTTP_200_OK, content={"message": f"Memory id={memory_id} successfully deleted"})
 
 
@@ -429,7 +451,7 @@ def get_agent_messages(
     """
     Retrieve message history for an agent.
     """
-    actor = server.get_user_or_default(user_id=user_id)
+    actor = server.user_manager.get_user_or_default(user_id=user_id)
 
     return server.get_agent_recall_cursor(
         user_id=actor.id,
@@ -449,11 +471,13 @@ def update_message(
     message_id: str,
     request: MessageUpdate = Body(...),
     server: "SyncServer" = Depends(get_letta_server),
+    user_id: Optional[str] = Header(None, alias="user_id"),  # Extract user_id from header, default to None if not present
 ):
     """
     Update the details of a message associated with an agent.
     """
-    return server.update_agent_message(agent_id=agent_id, message_id=message_id, request=request)
+    actor = server.user_manager.get_user_or_default(user_id=user_id)
+    return server.update_agent_message(agent_id=agent_id, message_id=message_id, request=request, actor=actor)
 
 
 @router.post(
@@ -471,11 +495,11 @@ 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.get_user_or_default(user_id=user_id)
+    actor = server.user_manager.get_user_or_default(user_id=user_id)
     result = await send_message_to_agent(
         server=server,
         agent_id=agent_id,
-        user_id=actor.id,
+        actor=actor,
         messages=request.messages,
         stream_steps=False,
         stream_tokens=False,
@@ -511,11 +535,11 @@ 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.
     """
 
-    actor = server.get_user_or_default(user_id=user_id)
+    actor = server.user_manager.get_user_or_default(user_id=user_id)
     result = await send_message_to_agent(
         server=server,
         agent_id=agent_id,
-        user_id=actor.id,
+        actor=actor,
         messages=request.messages,
         stream_steps=True,
         stream_tokens=request.stream_tokens,
@@ -531,7 +555,6 @@ async def process_message_background(
     server: SyncServer,
     actor: User,
     agent_id: str,
-    user_id: str,
     messages: list,
     assistant_message_tool_name: str,
     assistant_message_tool_kwarg: str,
@@ -542,7 +565,7 @@ async def process_message_background(
         result = await send_message_to_agent(
             server=server,
             agent_id=agent_id,
-            user_id=user_id,
+            actor=actor,
             messages=messages,
             stream_steps=False,  # NOTE(matt)
             stream_tokens=False,
@@ -585,7 +608,7 @@ async def send_message_async(
     Asynchronously process a user message and return a job ID.
     The actual processing happens in the background, and the status can be checked using the job ID.
     """
-    actor = server.get_user_or_default(user_id=user_id)
+    actor = server.user_manager.get_user_or_default(user_id=user_id)
 
     # Create a new job
     job = Job(
@@ -605,7 +628,6 @@ async def send_message_async(
         server=server,
         actor=actor,
         agent_id=agent_id,
-        user_id=actor.id,
         messages=request.messages,
         assistant_message_tool_name=request.assistant_message_tool_name,
         assistant_message_tool_kwarg=request.assistant_message_tool_kwarg,
@@ -618,7 +640,7 @@ async def send_message_async(
 async def send_message_to_agent(
     server: SyncServer,
     agent_id: str,
-    user_id: str,
+    actor: User,
     # role: MessageRole,
     messages: Union[List[Message], List[MessageCreate]],
     stream_steps: bool,
@@ -645,8 +667,7 @@ async def send_message_to_agent(
 
         # Get the generator object off of the agent's streaming interface
         # This will be attached to the POST SSE request used under-the-hood
-        # letta_agent = server.load_agent(agent_id=agent_id)
-        letta_agent = server.load_agent(agent_id=agent_id)
+        letta_agent = server.load_agent(agent_id=agent_id, actor=actor)
 
         # Disable token streaming if not OpenAI
         # TODO: cleanup this logic
@@ -685,7 +706,7 @@ async def send_message_to_agent(
         task = asyncio.create_task(
             asyncio.to_thread(
                 server.send_messages,
-                user_id=user_id,
+                actor=actor,
                 agent_id=agent_id,
                 messages=messages,
                 interface=streaming_interface,

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

@@ -1,10 +1,9 @@
 from typing import TYPE_CHECKING, List, Optional
 
-from fastapi import APIRouter, Body, Depends, Header, HTTPException, Query
+from fastapi import APIRouter, Body, Depends, Header, HTTPException, Query, Response
 
 from letta.orm.errors import NoResultFound
 from letta.schemas.block import Block, BlockUpdate, CreateBlock
-from letta.schemas.memory import Memory
 from letta.server.rest_api.utils import get_letta_server
 from letta.server.server import SyncServer
 
@@ -23,7 +22,7 @@ def list_blocks(
     server: SyncServer = Depends(get_letta_server),
     user_id: Optional[str] = Header(None, alias="user_id"),  # Extract user_id from header, default to None if not present
 ):
-    actor = server.get_user_or_default(user_id=user_id)
+    actor = server.user_manager.get_user_or_default(user_id=user_id)
     return server.block_manager.get_blocks(actor=actor, label=label, is_template=templates_only, template_name=name)
 
 
@@ -33,7 +32,7 @@ def create_block(
     server: SyncServer = Depends(get_letta_server),
     user_id: Optional[str] = Header(None, alias="user_id"),  # Extract user_id from header, default to None if not present
 ):
-    actor = server.get_user_or_default(user_id=user_id)
+    actor = server.user_manager.get_user_or_default(user_id=user_id)
     block = Block(**create_block.model_dump())
     return server.block_manager.create_or_update_block(actor=actor, block=block)
 
@@ -41,12 +40,12 @@ def create_block(
 @router.patch("/{block_id}", response_model=Block, operation_id="update_memory_block")
 def update_block(
     block_id: str,
-    update_block: BlockUpdate = Body(...),
+    block_update: BlockUpdate = Body(...),
     server: SyncServer = Depends(get_letta_server),
     user_id: Optional[str] = Header(None, alias="user_id"),
 ):
-    actor = server.get_user_or_default(user_id=user_id)
-    return server.block_manager.update_block(block_id=block_id, block_update=update_block, actor=actor)
+    actor = server.user_manager.get_user_or_default(user_id=user_id)
+    return server.block_manager.update_block(block_id=block_id, block_update=block_update, actor=actor)
 
 
 @router.delete("/{block_id}", response_model=Block, operation_id="delete_memory_block")
@@ -55,7 +54,7 @@ def delete_block(
     server: SyncServer = Depends(get_letta_server),
     user_id: Optional[str] = Header(None, alias="user_id"),
 ):
-    actor = server.get_user_or_default(user_id=user_id)
+    actor = server.user_manager.get_user_or_default(user_id=user_id)
     return server.block_manager.delete_block(block_id=block_id, actor=actor)
 
 
@@ -66,7 +65,7 @@ def get_block(
     user_id: Optional[str] = Header(None, alias="user_id"),
 ):
     print("call get block", block_id)
-    actor = server.get_user_or_default(user_id=user_id)
+    actor = server.user_manager.get_user_or_default(user_id=user_id)
     try:
         block = server.block_manager.get_block_by_id(block_id=block_id, actor=actor)
         if block is None:
@@ -76,7 +75,7 @@ def get_block(
         raise HTTPException(status_code=404, detail="Block not found")
 
 
-@router.patch("/{block_id}/attach", response_model=Block, operation_id="link_agent_memory_block")
+@router.patch("/{block_id}/attach", response_model=None, status_code=204, operation_id="link_agent_memory_block")
 def link_agent_memory_block(
     block_id: str,
     agent_id: str = Query(..., description="The unique identifier of the agent to attach the source to."),
@@ -86,17 +85,16 @@ def link_agent_memory_block(
     """
     Link a memory block to an agent.
     """
-    actor = server.get_user_or_default(user_id=user_id)
+    actor = server.user_manager.get_user_or_default(user_id=user_id)
 
-    block = server.block_manager.get_block_by_id(block_id=block_id, actor=actor)
-    if block is None:
-        raise HTTPException(status_code=404, detail="Block not found")
-
-    server.blocks_agents_manager.add_block_to_agent(agent_id=agent_id, block_id=block_id, block_label=block.label)
-    return block
+    try:
+        server.agent_manager.attach_block(agent_id=agent_id, block_id=block_id, actor=actor)
+        return Response(status_code=204)
+    except NoResultFound as e:
+        raise HTTPException(status_code=404, detail=str(e))
 
 
-@router.patch("/{block_id}/detach", response_model=Memory, operation_id="unlink_agent_memory_block")
+@router.patch("/{block_id}/detach", response_model=None, status_code=204, operation_id="unlink_agent_memory_block")
 def unlink_agent_memory_block(
     block_id: str,
     agent_id: str = Query(..., description="The unique identifier of the agent to attach the source to."),
@@ -106,11 +104,10 @@ def unlink_agent_memory_block(
     """
     Unlink a memory block from an agent
     """
-    actor = server.get_user_or_default(user_id=user_id)
+    actor = server.user_manager.get_user_or_default(user_id=user_id)
 
-    block = server.block_manager.get_block_by_id(block_id=block_id, actor=actor)
-    if block is None:
-        raise HTTPException(status_code=404, detail="Block not found")
-    # Link the block to the agent
-    server.blocks_agents_manager.remove_block_with_id_from_agent(agent_id=agent_id, block_id=block_id)
-    return block
+    try:
+        server.agent_manager.detach_block(agent_id=agent_id, block_id=block_id, actor=actor)
+        return Response(status_code=204)
+    except NoResultFound as e:
+        raise HTTPException(status_code=404, detail=str(e))

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

@@ -20,7 +20,7 @@ def list_jobs(
     """
     List all jobs.
     """
-    actor = server.get_user_or_default(user_id=user_id)
+    actor = server.user_manager.get_user_or_default(user_id=user_id)
 
     # TODO: add filtering by status
     jobs = server.job_manager.list_jobs(actor=actor)
@@ -40,7 +40,7 @@ def list_active_jobs(
     """
     List all active jobs.
     """
-    actor = server.get_user_or_default(user_id=user_id)
+    actor = server.user_manager.get_user_or_default(user_id=user_id)
 
     return server.job_manager.list_jobs(actor=actor, statuses=[JobStatus.created, JobStatus.running])
 
@@ -54,7 +54,7 @@ def get_job(
     """
     Get the status of a job.
     """
-    actor = server.get_user_or_default(user_id=user_id)
+    actor = server.user_manager.get_user_or_default(user_id=user_id)
 
     try:
         return server.job_manager.get_job_by_id(job_id=job_id, actor=actor)
@@ -71,7 +71,7 @@ def delete_job(
     """
     Delete a job by its job_id.
     """
-    actor = server.get_user_or_default(user_id=user_id)
+    actor = server.user_manager.get_user_or_default(user_id=user_id)
 
     try:
         job = server.job_manager.delete_job_by_id(job_id=job_id, actor=actor)