letta-nightly 0.6.13.dev20250122185528__py3-none-any.whl → 0.6.14.dev20250123041709__py3-none-any.whl

letta/schemas/tool.py

@@ -9,11 +9,14 @@ from letta.constants import (
     LETTA_MULTI_AGENT_TOOL_MODULE_NAME,
 )
 from letta.functions.functions import derive_openai_json_schema, get_json_schema_from_module
-from letta.functions.helpers import generate_composio_tool_wrapper, generate_langchain_tool_wrapper
-from letta.functions.schema_generator import generate_schema_from_args_schema_v2
+from letta.functions.helpers import generate_composio_action_from_func_name, generate_composio_tool_wrapper, generate_langchain_tool_wrapper
+from letta.functions.schema_generator import generate_schema_from_args_schema_v2, generate_tool_schema_for_composio
+from letta.log import get_logger
 from letta.orm.enums import ToolType
 from letta.schemas.letta_base import LettaBase
 
+logger = get_logger(__name__)
+
 
 class BaseTool(LettaBase):
     __id_prefix__ = "tool"
@@ -52,14 +55,16 @@ class Tool(BaseTool):
     last_updated_by_id: Optional[str] = Field(None, description="The id of the user that made this Tool.")
 
     @model_validator(mode="after")
-    def populate_missing_fields(self):
+    def refresh_source_code_and_json_schema(self):
         """
-        Populate missing fields: name, description, and json_schema.
+        Refresh name, description, source_code, and json_schema.
         """
         if self.tool_type == ToolType.CUSTOM:
             # If it's a custom tool, we need to ensure source_code is present
             if not self.source_code:
-                raise ValueError(f"Custom tool with id={self.id} is missing source_code field.")
+                error_msg = f"Custom tool with id={self.id} is missing source_code field."
+                logger.error(error_msg)
+                raise ValueError(error_msg)
 
             # Always derive json_schema for freshest possible json_schema
             # TODO: Instead of checking the tag, we should having `COMPOSIO` as a specific ToolType
@@ -72,6 +77,24 @@ class Tool(BaseTool):
         elif self.tool_type in {ToolType.LETTA_MULTI_AGENT_CORE}:
             # If it's letta multi-agent tool, we also generate the json_schema on the fly here
             self.json_schema = get_json_schema_from_module(module_name=LETTA_MULTI_AGENT_TOOL_MODULE_NAME, function_name=self.name)
+        elif self.tool_type == ToolType.EXTERNAL_COMPOSIO:
+            # If it is a composio tool, we generate both the source code and json schema on the fly here
+            # TODO: This is brittle, need to think long term about how to improve this
+            try:
+                composio_action = generate_composio_action_from_func_name(self.name)
+                tool_create = ToolCreate.from_composio(composio_action)
+                self.source_code = tool_create.source_code
+                self.json_schema = tool_create.json_schema
+                self.description = tool_create.description
+                self.tags = tool_create.tags
+            except Exception as e:
+                logger.error(f"Encountered exception while attempting to refresh source_code and json_schema for composio_tool: {e}")
+
+        # At this point, we need to validate that at least json_schema is populated
+        if not self.json_schema:
+            error_msg = f"Tool with id={self.id} name={self.name} tool_type={self.tool_type} is missing a json_schema."
+            logger.error(error_msg)
+            raise ValueError(error_msg)
 
         # Derive name from the JSON schema if not provided
         if not self.name:
@@ -100,7 +123,7 @@ class ToolCreate(LettaBase):
     return_char_limit: int = Field(FUNCTION_RETURN_CHAR_LIMIT, description="The maximum number of characters in the response.")
 
     @classmethod
-    def from_composio(cls, action_name: str, api_key: Optional[str] = None) -> "ToolCreate":
+    def from_composio(cls, action_name: str) -> "ToolCreate":
         """
         Class method to create an instance of Letta-compatible Composio Tool.
         Check https://docs.composio.dev/introduction/intro/overview to look at options for from_composio
@@ -115,24 +138,21 @@ class ToolCreate(LettaBase):
         from composio import LogLevel
         from composio_langchain import ComposioToolSet
 
-        if api_key:
-            # Pass in an external API key
-            composio_toolset = ComposioToolSet(logging_level=LogLevel.ERROR, api_key=api_key)
-        else:
-            # Use environmental variable
-            composio_toolset = ComposioToolSet(logging_level=LogLevel.ERROR)
-        composio_tools = composio_toolset.get_tools(actions=[action_name])
+        composio_toolset = ComposioToolSet(logging_level=LogLevel.ERROR)
+        composio_action_schemas = composio_toolset.get_action_schemas(actions=[action_name], check_connected_accounts=False)
 
-        assert len(composio_tools) > 0, "User supplied parameters do not match any Composio tools"
-        assert len(composio_tools) == 1, f"User supplied parameters match too many Composio tools; {len(composio_tools)} > 1"
+        assert len(composio_action_schemas) > 0, "User supplied parameters do not match any Composio tools"
+        assert (
+            len(composio_action_schemas) == 1
+        ), f"User supplied parameters match too many Composio tools; {len(composio_action_schemas)} > 1"
 
-        composio_tool = composio_tools[0]
+        composio_action_schema = composio_action_schemas[0]
 
-        description = composio_tool.description
+        description = composio_action_schema.description
         source_type = "python"
         tags = [COMPOSIO_TOOL_TAG_NAME]
         wrapper_func_name, wrapper_function_str = generate_composio_tool_wrapper(action_name)
-        json_schema = generate_schema_from_args_schema_v2(composio_tool.args_schema, name=wrapper_func_name, description=description)
+        json_schema = generate_tool_schema_for_composio(composio_action_schema.parameters, name=wrapper_func_name, description=description)
 
         return cls(
             name=wrapper_func_name,
@@ -175,31 +195,6 @@ class ToolCreate(LettaBase):
             json_schema=json_schema,
         )
 
-    @classmethod
-    def load_default_langchain_tools(cls) -> List["ToolCreate"]:
-        # For now, we only support wikipedia tool
-        from langchain_community.tools import WikipediaQueryRun
-        from langchain_community.utilities import WikipediaAPIWrapper
-
-        wikipedia_tool = ToolCreate.from_langchain(
-            WikipediaQueryRun(api_wrapper=WikipediaAPIWrapper()), {"langchain_community.utilities": "WikipediaAPIWrapper"}
-        )
-
-        return [wikipedia_tool]
-
-    @classmethod
-    def load_default_composio_tools(cls) -> List["ToolCreate"]:
-        pass
-
-        # TODO: Disable composio tools for now
-        # TODO: Naming is causing issues
-        # calculator = ToolCreate.from_composio(action_name=Action.MATHEMATICAL_CALCULATOR.name)
-        # serp_news = ToolCreate.from_composio(action_name=Action.SERPAPI_NEWS_SEARCH.name)
-        # serp_google_search = ToolCreate.from_composio(action_name=Action.SERPAPI_SEARCH.name)
-        # serp_google_maps = ToolCreate.from_composio(action_name=Action.SERPAPI_GOOGLE_MAPS_SEARCH.name)
-
-        return []
-
 
 class ToolUpdate(LettaBase):
     description: Optional[str] = Field(None, description="The description of the tool.")

letta/server/rest_api/app.py

@@ -22,8 +22,6 @@ from letta.server.constants import REST_DEFAULT_PORT
 # NOTE(charles): these are extra routes that are not part of v1 but we still need to mount to pass tests
 from letta.server.rest_api.auth.index import setup_auth_router  # TODO: probably remove right?
 from letta.server.rest_api.interface import StreamingServerInterface
-from letta.server.rest_api.routers.openai.assistants.assistants import router as openai_assistants_router
-from letta.server.rest_api.routers.openai.chat_completions.chat_completions import router as openai_chat_completions_router
 
 # from letta.orm.utilities import get_db_session  # TODO(ethan) reenable once we merge ORM
 from letta.server.rest_api.routers.v1 import ROUTERS as v1_routes
@@ -62,20 +60,11 @@ def generate_openapi_schema(app: FastAPI):
     if not app.openapi_schema:
         app.openapi_schema = app.openapi()
 
-    openai_docs, letta_docs = [app.openapi_schema.copy() for _ in range(2)]
-
-    openai_docs["paths"] = {k: v for k, v in openai_docs["paths"].items() if k.startswith("/openai")}
-    openai_docs["info"]["title"] = "OpenAI Assistants API"
+    letta_docs = app.openapi_schema.copy()
     letta_docs["paths"] = {k: v for k, v in letta_docs["paths"].items() if not k.startswith("/openai")}
     letta_docs["info"]["title"] = "Letta API"
     letta_docs["components"]["schemas"]["LettaMessageUnion"] = create_letta_message_union_schema()
-
-    # Split the API docs into Letta API, and OpenAI Assistants compatible API
     for name, docs in [
-        (
-            "openai",
-            openai_docs,
-        ),
         (
             "letta",
             letta_docs,
@@ -249,10 +238,6 @@ def create_application() -> "FastAPI":
     app.include_router(users_router, prefix=ADMIN_PREFIX)
     app.include_router(organizations_router, prefix=ADMIN_PREFIX)
 
-    # openai
-    app.include_router(openai_assistants_router, prefix=OPENAI_API_PREFIX)
-    app.include_router(openai_chat_completions_router, prefix=OPENAI_API_PREFIX)
-
     # /api/auth endpoints
     app.include_router(setup_auth_router(server, interface, password), prefix=API_PREFIX)
 

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

@@ -70,8 +70,8 @@ def list_agents(
     return agents
 
 
-@router.get("/{agent_id}/context", response_model=ContextWindowOverview, operation_id="get_agent_context_window")
-def get_agent_context_window(
+@router.get("/{agent_id}/context", response_model=ContextWindowOverview, operation_id="retrieve_agent_context_window")
+def retrieve_agent_context_window(
     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
@@ -106,8 +106,8 @@ def create_agent(
     return server.create_agent(agent, actor=actor)
 
 
-@router.patch("/{agent_id}", response_model=AgentState, operation_id="update_agent")
-def update_agent(
+@router.patch("/{agent_id}", response_model=AgentState, operation_id="modify_agent")
+def modify_agent(
     agent_id: str,
     update_agent: UpdateAgent = Body(...),
     server: "SyncServer" = Depends(get_letta_server),
@@ -118,55 +118,75 @@ def update_agent(
     return server.agent_manager.update_agent(agent_id=agent_id, agent_update=update_agent, actor=actor)
 
 
-@router.get("/{agent_id}/tools", response_model=List[Tool], operation_id="get_tools_from_agent")
-def get_tools_from_agent(
+@router.get("/{agent_id}/tools", response_model=List[Tool], operation_id="list_agent_tools")
+def list_agent_tools(
     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 tools from an existing agent"""
     actor = server.user_manager.get_user_or_default(user_id=user_id)
-    return server.agent_manager.get_agent_by_id(agent_id=agent_id, actor=actor).tools
+    return server.agent_manager.list_attached_tools(agent_id=agent_id, actor=actor)
 
 
-@router.patch("/{agent_id}/add-tool/{tool_id}", response_model=AgentState, operation_id="add_tool_to_agent")
-def add_tool_to_agent(
+@router.patch("/{agent_id}/tools/attach/{tool_id}", response_model=AgentState, operation_id="attach_tool")
+def attach_tool(
     agent_id: str,
     tool_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
+    user_id: Optional[str] = Header(None, alias="user_id"),
 ):
-    """Add tools to an existing agent"""
+    """
+    Attach a tool to an agent.
+    """
     actor = server.user_manager.get_user_or_default(user_id=user_id)
     return server.agent_manager.attach_tool(agent_id=agent_id, tool_id=tool_id, actor=actor)
 
 
-@router.patch("/{agent_id}/remove-tool/{tool_id}", response_model=AgentState, operation_id="remove_tool_from_agent")
-def remove_tool_from_agent(
+@router.patch("/{agent_id}/tools/detach/{tool_id}", response_model=AgentState, operation_id="detach_tool")
+def detach_tool(
     agent_id: str,
     tool_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
+    user_id: Optional[str] = Header(None, alias="user_id"),
 ):
-    """Add tools to an existing agent"""
+    """
+    Detach a tool from an agent.
+    """
     actor = server.user_manager.get_user_or_default(user_id=user_id)
     return server.agent_manager.detach_tool(agent_id=agent_id, tool_id=tool_id, actor=actor)
 
 
-@router.patch("/{agent_id}/reset-messages", response_model=AgentState, operation_id="reset_messages")
-def reset_messages(
+@router.patch("/{agent_id}/sources/attach/{source_id}", response_model=AgentState, operation_id="attach_source_to_agent")
+def attach_source(
     agent_id: str,
-    add_default_initial_messages: bool = Query(default=False, description="If true, adds the default initial messages after resetting."),
+    source_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
+    user_id: Optional[str] = Header(None, alias="user_id"),
 ):
-    """Resets the messages for an agent"""
+    """
+    Attach a source to an agent.
+    """
     actor = server.user_manager.get_user_or_default(user_id=user_id)
-    return server.agent_manager.reset_messages(agent_id=agent_id, actor=actor, add_default_initial_messages=add_default_initial_messages)
+    return server.agent_manager.attach_source(agent_id=agent_id, source_id=source_id, actor=actor)
+
+
+@router.patch("/{agent_id}/sources/detach/{source_id}", response_model=AgentState, operation_id="detach_source_from_agent")
+def detach_source(
+    agent_id: str,
+    source_id: str,
+    server: "SyncServer" = Depends(get_letta_server),
+    user_id: Optional[str] = Header(None, alias="user_id"),
+):
+    """
+    Detach a source from an agent.
+    """
+    actor = server.user_manager.get_user_or_default(user_id=user_id)
+    return server.agent_manager.detach_source(agent_id=agent_id, source_id=source_id, actor=actor)
 
 
-@router.get("/{agent_id}", response_model=AgentState, operation_id="get_agent")
-def get_agent_state(
+@router.get("/{agent_id}", response_model=AgentState, operation_id="retrieve_agent")
+def retrieve_agent(
     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
@@ -199,8 +219,8 @@ def delete_agent(
         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(
+@router.get("/{agent_id}/sources", response_model=List[Source], operation_id="list_agent_sources")
+def list_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
@@ -213,8 +233,8 @@ def get_agent_sources(
 
 
 # TODO: remove? can also get with agent blocks
-@router.get("/{agent_id}/core_memory", response_model=Memory, operation_id="get_agent_memory")
-def get_agent_memory(
+@router.get("/{agent_id}/core-memory", response_model=Memory, operation_id="retrieve_agent_memory")
+def retrieve_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
@@ -228,8 +248,8 @@ def get_agent_memory(
     return server.get_agent_memory(agent_id=agent_id, actor=actor)
 
 
-@router.get("/{agent_id}/core_memory/blocks/{block_label}", response_model=Block, operation_id="get_agent_memory_block")
-def get_agent_memory_block(
+@router.get("/{agent_id}/core-memory/blocks/{block_label}", response_model=Block, operation_id="retrieve_core_memory_block")
+def retrieve_core_memory_block(
     agent_id: str,
     block_label: str,
     server: "SyncServer" = Depends(get_letta_server),
@@ -246,8 +266,8 @@ def get_agent_memory_block(
         raise HTTPException(status_code=404, detail=str(e))
 
 
-@router.get("/{agent_id}/core_memory/blocks", response_model=List[Block], operation_id="list_agent_memory_blocks")
-def list_agent_memory_blocks(
+@router.get("/{agent_id}/core-memory/blocks", response_model=List[Block], operation_id="list_core_memory_blocks")
+def list_core_memory_blocks(
     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
@@ -263,73 +283,58 @@ def list_agent_memory_blocks(
         raise HTTPException(status_code=404, detail=str(e))
 
 
-@router.post("/{agent_id}/core_memory/blocks", response_model=Memory, operation_id="add_agent_memory_block")
-def add_agent_memory_block(
+@router.patch("/{agent_id}/core-memory/blocks/{block_label}", response_model=Block, operation_id="modify_core_memory_block")
+def modify_core_memory_block(
     agent_id: str,
-    create_block: CreateBlock = Body(...),
+    block_label: str,
+    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
 ):
     """
-    Creates a memory block and links it to the agent.
+    Updates a memory block of an agent.
     """
     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)
+    block = server.agent_manager.get_block_with_label(agent_id=agent_id, block_label=block_label, actor=actor)
+    block = server.block_manager.update_block(block.id, block_update=block_update, actor=actor)
 
-    # Link the block to the agent
-    agent = server.agent_manager.attach_block(agent_id=agent_id, block_id=block.id, actor=actor)
-    return agent.memory
+    # This should also trigger a system prompt change in the agent
+    server.agent_manager.rebuild_system_prompt(agent_id=agent_id, actor=actor, force=True, update_timestamp=False)
+
+    return block
 
 
-@router.delete("/{agent_id}/core_memory/blocks/{block_label}", response_model=Memory, operation_id="remove_agent_memory_block_by_label")
-def remove_agent_memory_block(
+@router.patch("/{agent_id}/core-memory/blocks/attach/{block_id}", response_model=AgentState, operation_id="attach_core_memory_block")
+def attach_core_memory_block(
     agent_id: str,
-    # TODO should this be block_id, or the label?
-    # I think label is OK since it's user-friendly + guaranteed to be unique within a Memory object
-    block_label: str,
+    block_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
+    user_id: Optional[str] = Header(None, alias="user_id"),
 ):
     """
-    Removes a memory block from an agent by unlnking it. If the block is not linked to any other agent, it is deleted.
+    Attach a block to an agent.
     """
     actor = server.user_manager.get_user_or_default(user_id=user_id)
+    return server.agent_manager.attach_block(agent_id=agent_id, block_id=block_id, actor=actor)
 
-    # Unlink the block from the agent
-    agent = server.agent_manager.detach_block_with_label(agent_id=agent_id, block_label=block_label, actor=actor)
-
-    return agent.memory
 
-
-@router.patch("/{agent_id}/core_memory/blocks/{block_label}", response_model=Block, operation_id="update_agent_memory_block_by_label")
-def update_agent_memory_block(
+@router.patch("/{agent_id}/core-memory/blocks/detach/{block_id}", response_model=AgentState, operation_id="detach_core_memory_block")
+def detach_core_memory_block(
     agent_id: str,
-    block_label: str,
-    block_update: BlockUpdate = Body(...),
+    block_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
+    user_id: Optional[str] = Header(None, alias="user_id"),
 ):
     """
-    Removes a memory block from an agent by unlnking it. If the block is not linked to any other agent, it is deleted.
+    Detach a block from an agent.
     """
     actor = server.user_manager.get_user_or_default(user_id=user_id)
+    return server.agent_manager.detach_block(agent_id=agent_id, block_id=block_id, actor=actor)
 
-    block = server.agent_manager.get_block_with_label(agent_id=agent_id, block_label=block_label, actor=actor)
-    block = server.block_manager.update_block(block.id, block_update=block_update, actor=actor)
-
-    # This should also trigger a system prompt change in the agent
-    server.agent_manager.rebuild_system_prompt(agent_id=agent_id, actor=actor, force=True, update_timestamp=False)
 
-    return block
-
-
-@router.get("/{agent_id}/archival_memory", response_model=List[Passage], operation_id="list_agent_archival_memory")
-def get_agent_archival_memory(
+@router.get("/{agent_id}/archival-memory", response_model=List[Passage], operation_id="list_archival_memory")
+def list_archival_memory(
     agent_id: str,
     server: "SyncServer" = Depends(get_letta_server),
     after: Optional[int] = Query(None, description="Unique ID of the memory to start the query range at."),
@@ -354,8 +359,8 @@ def get_agent_archival_memory(
     )
 
 
-@router.post("/{agent_id}/archival_memory", response_model=List[Passage], operation_id="create_agent_archival_memory")
-def insert_agent_archival_memory(
+@router.post("/{agent_id}/archival-memory", response_model=List[Passage], operation_id="create_archival_memory")
+def create_archival_memory(
     agent_id: str,
     request: CreateArchivalMemory = Body(...),
     server: "SyncServer" = Depends(get_letta_server),
@@ -371,8 +376,8 @@ def insert_agent_archival_memory(
 
 # TODO(ethan): query or path parameter for memory_id?
 # @router.delete("/{agent_id}/archival")
-@router.delete("/{agent_id}/archival_memory/{memory_id}", response_model=None, operation_id="delete_agent_archival_memory")
-def delete_agent_archival_memory(
+@router.delete("/{agent_id}/archival-memory/{memory_id}", response_model=None, operation_id="delete_archival_memory")
+def delete_archival_memory(
     agent_id: str,
     memory_id: str,
     # memory_id: str = Query(..., description="Unique ID of the memory to be deleted."),
@@ -393,7 +398,7 @@ AgentMessagesResponse = Annotated[
     Field(
         json_schema_extra={
             "anyOf": [
-                {"type": "array", "items": {"$ref": "#/components/schemas/letta__schemas__message__Message"}},
+                {"type": "array", "items": {"$ref": "#/components/schemas/Message"}},
                 {"type": "array", "items": {"$ref": "#/components/schemas/LettaMessageUnion"}},
             ]
         }
@@ -401,8 +406,8 @@ AgentMessagesResponse = Annotated[
 ]
 
 
-@router.get("/{agent_id}/messages", response_model=AgentMessagesResponse, operation_id="list_agent_messages")
-def get_agent_messages(
+@router.get("/{agent_id}/messages", response_model=AgentMessagesResponse, operation_id="list_messages")
+def list_messages(
     agent_id: str,
     server: "SyncServer" = Depends(get_letta_server),
     before: Optional[str] = Query(None, description="Message before which to retrieve the returned messages."),
@@ -436,8 +441,8 @@ def get_agent_messages(
     )
 
 
-@router.patch("/{agent_id}/messages/{message_id}", response_model=Message, operation_id="update_agent_message")
-def update_message(
+@router.patch("/{agent_id}/messages/{message_id}", response_model=Message, operation_id="modify_message")
+def modify_message(
     agent_id: str,
     message_id: str,
     request: MessageUpdate = Body(...),
@@ -455,7 +460,7 @@ def update_message(
 @router.post(
     "/{agent_id}/messages",
     response_model=LettaResponse,
-    operation_id="create_agent_message",
+    operation_id="send_message",
 )
 async def send_message(
     agent_id: str,
@@ -551,7 +556,7 @@ async def process_message_background(
         job_update = JobUpdate(
             status=JobStatus.completed,
             completed_at=datetime.utcnow(),
-            metadata_={"result": result.model_dump()},  # Store the result in metadata
+            metadata={"result": result.model_dump()},  # Store the result in metadata
         )
         server.job_manager.update_job_by_id(job_id=job_id, job_update=job_update, actor=actor)
 
@@ -563,7 +568,7 @@ async def process_message_background(
         job_update = JobUpdate(
             status=JobStatus.failed,
             completed_at=datetime.utcnow(),
-            metadata_={"error": str(e)},
+            metadata={"error": str(e)},
         )
         server.job_manager.update_job_by_id(job_id=job_id, job_update=job_update, actor=actor)
         raise
@@ -591,7 +596,7 @@ async def send_message_async(
     run = Run(
         user_id=actor.id,
         status=JobStatus.created,
-        metadata_={
+        metadata={
             "job_type": "send_message_async",
             "agent_id": agent_id,
         },
@@ -613,3 +618,15 @@ async def send_message_async(
     )
 
     return run
+
+
+@router.patch("/{agent_id}/reset-messages", response_model=AgentState, operation_id="reset_messages")
+def reset_messages(
+    agent_id: str,
+    add_default_initial_messages: bool = Query(default=False, description="If true, adds the default initial messages after resetting."),
+    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
+):
+    """Resets the messages for an agent"""
+    actor = server.user_manager.get_user_or_default(user_id=user_id)
+    return server.agent_manager.reset_messages(agent_id=agent_id, actor=actor, add_default_initial_messages=add_default_initial_messages)

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

@@ -1,6 +1,6 @@
 from typing import TYPE_CHECKING, List, Optional
 
-from fastapi import APIRouter, Body, Depends, Header, HTTPException, Query, Response
+from fastapi import APIRouter, Body, Depends, Header, HTTPException, Query
 
 from letta.orm.errors import NoResultFound
 from letta.schemas.block import Block, BlockUpdate, CreateBlock
@@ -13,7 +13,7 @@ if TYPE_CHECKING:
 router = APIRouter(prefix="/blocks", tags=["blocks"])
 
 
-@router.get("/", response_model=List[Block], operation_id="list_memory_blocks")
+@router.get("/", response_model=List[Block], operation_id="list_blocks")
 def list_blocks(
     # query parameters
     label: Optional[str] = Query(None, description="Labels to include (e.g. human, persona)"),
@@ -26,7 +26,7 @@ def list_blocks(
     return server.block_manager.get_blocks(actor=actor, label=label, is_template=templates_only, template_name=name)
 
 
-@router.post("/", response_model=Block, operation_id="create_memory_block")
+@router.post("/", response_model=Block, operation_id="create_block")
 def create_block(
     create_block: CreateBlock = Body(...),
     server: SyncServer = Depends(get_letta_server),
@@ -37,8 +37,8 @@ def create_block(
     return server.block_manager.create_or_update_block(actor=actor, block=block)
 
 
-@router.patch("/{block_id}", response_model=Block, operation_id="update_memory_block")
-def update_block(
+@router.patch("/{block_id}", response_model=Block, operation_id="modify_block")
+def modify_block(
     block_id: str,
     block_update: BlockUpdate = Body(...),
     server: SyncServer = Depends(get_letta_server),
@@ -48,7 +48,7 @@ def update_block(
     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")
+@router.delete("/{block_id}", response_model=Block, operation_id="delete_block")
 def delete_block(
     block_id: str,
     server: SyncServer = Depends(get_letta_server),
@@ -58,8 +58,8 @@ def delete_block(
     return server.block_manager.delete_block(block_id=block_id, actor=actor)
 
 
-@router.get("/{block_id}", response_model=Block, operation_id="get_memory_block")
-def get_block(
+@router.get("/{block_id}", response_model=Block, operation_id="retrieve_block")
+def retrieve_block(
     block_id: str,
     server: SyncServer = Depends(get_letta_server),
     user_id: Optional[str] = Header(None, alias="user_id"),
@@ -73,41 +73,3 @@ def get_block(
         return block
     except NoResultFound:
         raise HTTPException(status_code=404, detail="Block not found")
-
-
-@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."),
-    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
-):
-    """
-    Link a memory block to an agent.
-    """
-    actor = server.user_manager.get_user_or_default(user_id=user_id)
-
-    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=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."),
-    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
-):
-    """
-    Unlink a memory block from an agent
-    """
-    actor = server.user_manager.get_user_or_default(user_id=user_id)
-
-    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

@@ -26,9 +26,9 @@ def list_jobs(
     jobs = server.job_manager.list_jobs(actor=actor)
 
     if source_id:
-        # can't be in the ORM since we have source_id stored in the metadata_
+        # can't be in the ORM since we have source_id stored in the metadata
         # TODO: Probably change this
-        jobs = [job for job in jobs if job.metadata_.get("source_id") == source_id]
+        jobs = [job for job in jobs if job.metadata.get("source_id") == source_id]
     return jobs
 
 
@@ -45,8 +45,8 @@ def list_active_jobs(
     return server.job_manager.list_jobs(actor=actor, statuses=[JobStatus.created, JobStatus.running])
 
 
-@router.get("/{job_id}", response_model=Job, operation_id="get_job")
-def get_job(
+@router.get("/{job_id}", response_model=Job, operation_id="retrieve_job")
+def retrieve_job(
     job_id: str,
     user_id: Optional[str] = Header(None, alias="user_id"),
     server: "SyncServer" = Depends(get_letta_server),