letta-nightly 0.6.12.dev20250121104040__tar.gz → 0.6.13.dev20250122185528__tar.gz

{letta_nightly-0.6.12.dev20250121104040 → letta_nightly-0.6.13.dev20250122185528}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: letta-nightly
-Version: 0.6.12.dev20250121104040
+Version: 0.6.13.dev20250122185528
 Summary: Create LLM agents with long-term memory and custom tools
 License: Apache License
 Author: Letta Team

{letta_nightly-0.6.12.dev20250121104040 → letta_nightly-0.6.13.dev20250122185528}/letta/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "0.6.12"
+__version__ = "0.6.13"
 
 
 # import clients

{letta_nightly-0.6.12.dev20250121104040 → letta_nightly-0.6.13.dev20250122185528}/letta/client/client.py

@@ -776,7 +776,7 @@ class RESTClient(AbstractClient):
         Returns:
             memory (Memory): In-context memory of the agent
         """
-        response = requests.get(f"{self.base_url}/{self.api_prefix}/agents/{agent_id}/memory", headers=self.headers)
+        response = requests.get(f"{self.base_url}/{self.api_prefix}/agents/{agent_id}/core_memory", headers=self.headers)
         if response.status_code != 200:
             raise ValueError(f"Failed to get in-context memory: {response.text}")
         return Memory(**response.json())
@@ -797,7 +797,7 @@ class RESTClient(AbstractClient):
         """
         memory_update_dict = {section: value}
         response = requests.patch(
-            f"{self.base_url}/{self.api_prefix}/agents/{agent_id}/memory", json=memory_update_dict, headers=self.headers
+            f"{self.base_url}/{self.api_prefix}/agents/{agent_id}/core_memory", json=memory_update_dict, headers=self.headers
         )
         if response.status_code != 200:
             raise ValueError(f"Failed to update in-context memory: {response.text}")
@@ -814,10 +814,10 @@ class RESTClient(AbstractClient):
             summary (ArchivalMemorySummary): Summary of the archival memory
 
         """
-        response = requests.get(f"{self.base_url}/{self.api_prefix}/agents/{agent_id}/memory/archival", headers=self.headers)
+        response = requests.get(f"{self.base_url}/{self.api_prefix}/agents/{agent_id}/context", headers=self.headers)
         if response.status_code != 200:
             raise ValueError(f"Failed to get archival memory summary: {response.text}")
-        return ArchivalMemorySummary(**response.json())
+        return ArchivalMemorySummary(size=response.json().get("num_archival_memory", 0))
 
     def get_recall_memory_summary(self, agent_id: str) -> RecallMemorySummary:
         """
@@ -829,10 +829,10 @@ class RESTClient(AbstractClient):
         Returns:
             summary (RecallMemorySummary): Summary of the recall memory
         """
-        response = requests.get(f"{self.base_url}/{self.api_prefix}/agents/{agent_id}/memory/recall", headers=self.headers)
+        response = requests.get(f"{self.base_url}/{self.api_prefix}/agents/{agent_id}/context", headers=self.headers)
         if response.status_code != 200:
             raise ValueError(f"Failed to get recall memory summary: {response.text}")
-        return RecallMemorySummary(**response.json())
+        return RecallMemorySummary(size=response.json().get("num_recall_memory", 0))
 
     def get_in_context_messages(self, agent_id: str) -> List[Message]:
         """
@@ -844,10 +844,10 @@ class RESTClient(AbstractClient):
         Returns:
             messages (List[Message]): List of in-context messages
         """
-        response = requests.get(f"{self.base_url}/{self.api_prefix}/agents/{agent_id}/memory/messages", headers=self.headers)
+        response = requests.get(f"{self.base_url}/{self.api_prefix}/agents/{agent_id}/context", headers=self.headers)
         if response.status_code != 200:
-            raise ValueError(f"Failed to get in-context messages: {response.text}")
-        return [Message(**message) for message in response.json()]
+            raise ValueError(f"Failed to get recall memory summary: {response.text}")
+        return [Message(**message) for message in response.json().get("messages", "")]
 
     # agent interactions
 
@@ -889,7 +889,9 @@ class RESTClient(AbstractClient):
             params["before"] = str(before)
         if after:
             params["after"] = str(after)
-        response = requests.get(f"{self.base_url}/{self.api_prefix}/agents/{str(agent_id)}/archival", params=params, headers=self.headers)
+        response = requests.get(
+            f"{self.base_url}/{self.api_prefix}/agents/{str(agent_id)}/archival_memory", params=params, headers=self.headers
+        )
         assert response.status_code == 200, f"Failed to get archival memory: {response.text}"
         return [Passage(**passage) for passage in response.json()]
 
@@ -906,7 +908,7 @@ class RESTClient(AbstractClient):
         """
         request = CreateArchivalMemory(text=memory)
         response = requests.post(
-            f"{self.base_url}/{self.api_prefix}/agents/{agent_id}/archival", headers=self.headers, json=request.model_dump()
+            f"{self.base_url}/{self.api_prefix}/agents/{agent_id}/archival_memory", headers=self.headers, json=request.model_dump()
         )
         if response.status_code != 200:
             raise ValueError(f"Failed to insert archival memory: {response.text}")
@@ -920,7 +922,7 @@ class RESTClient(AbstractClient):
             agent_id (str): ID of the agent
             memory_id (str): ID of the memory
         """
-        response = requests.delete(f"{self.base_url}/{self.api_prefix}/agents/{agent_id}/archival/{memory_id}", headers=self.headers)
+        response = requests.delete(f"{self.base_url}/{self.api_prefix}/agents/{agent_id}/archival_memory/{memory_id}", headers=self.headers)
         assert response.status_code == 200, f"Failed to delete archival memory: {response.text}"
 
     # messages (recall memory)
@@ -1463,12 +1465,14 @@ class RESTClient(AbstractClient):
         Returns:
             id (str): ID of the tool (`None` if not found)
         """
-        response = requests.get(f"{self.base_url}/{self.api_prefix}/tools/name/{tool_name}", headers=self.headers)
-        if response.status_code == 404:
-            return None
-        elif response.status_code != 200:
+        response = requests.get(f"{self.base_url}/{self.api_prefix}/tools", headers=self.headers)
+        if response.status_code != 200:
             raise ValueError(f"Failed to get tool: {response.text}")
-        return response.json()
+
+        tools = [tool for tool in [Tool(**tool) for tool in response.json()] if tool.name == tool_name]
+        if not tools:
+            return None
+        return tools[0].id
 
     def upsert_base_tools(self) -> List[Tool]:
         response = requests.post(f"{self.base_url}/{self.api_prefix}/tools/add-base-tools/", headers=self.headers)
@@ -1852,7 +1856,7 @@ class RESTClient(AbstractClient):
             memory (Memory): The updated memory
         """
         response = requests.post(
-            f"{self.base_url}/{self.api_prefix}/agents/{agent_id}/memory/block",
+            f"{self.base_url}/{self.api_prefix}/agents/{agent_id}/core_memory/blocks",
             headers=self.headers,
             json=create_block.model_dump(),
         )
@@ -1893,14 +1897,14 @@ class RESTClient(AbstractClient):
             memory (Memory): The updated memory
         """
         response = requests.delete(
-            f"{self.base_url}/{self.api_prefix}/agents/{agent_id}/memory/block/{block_label}",
+            f"{self.base_url}/{self.api_prefix}/agents/{agent_id}/core_memory/blocks/{block_label}",
             headers=self.headers,
         )
         if response.status_code != 200:
             raise ValueError(f"Failed to remove agent memory block: {response.text}")
         return Memory(**response.json())
 
-    def get_agent_memory_blocks(self, agent_id: str) -> List[Block]:
+    def list_agent_memory_blocks(self, agent_id: str) -> List[Block]:
         """
         Get all the blocks in the agent's core memory
 
@@ -1910,7 +1914,7 @@ class RESTClient(AbstractClient):
         Returns:
             blocks (List[Block]): The blocks in the agent's core memory
         """
-        response = requests.get(f"{self.base_url}/{self.api_prefix}/agents/{agent_id}/memory/block", headers=self.headers)
+        response = requests.get(f"{self.base_url}/{self.api_prefix}/agents/{agent_id}/core_memory/blocks", headers=self.headers)
         if response.status_code != 200:
             raise ValueError(f"Failed to get agent memory blocks: {response.text}")
         return [Block(**block) for block in response.json()]
@@ -1927,7 +1931,7 @@ class RESTClient(AbstractClient):
             block (Block): The block corresponding to the label
         """
         response = requests.get(
-            f"{self.base_url}/{self.api_prefix}/agents/{agent_id}/memory/block/{label}",
+            f"{self.base_url}/{self.api_prefix}/agents/{agent_id}/core_memory/blocks/{label}",
             headers=self.headers,
         )
         if response.status_code != 200:
@@ -1960,7 +1964,7 @@ class RESTClient(AbstractClient):
         if limit:
             data["limit"] = limit
         response = requests.patch(
-            f"{self.base_url}/{self.api_prefix}/agents/{agent_id}/memory/block/{label}",
+            f"{self.base_url}/{self.api_prefix}/agents/{agent_id}/core_memory/blocks/{label}",
             headers=self.headers,
             json=data,
         )
@@ -3523,7 +3527,7 @@ class LocalClient(AbstractClient):
         """
         return self.server.agent_manager.detach_block_with_label(agent_id=agent_id, block_label=block_label, actor=self.user)
 
-    def get_agent_memory_blocks(self, agent_id: str) -> List[Block]:
+    def list_agent_memory_blocks(self, agent_id: str) -> List[Block]:
         """
         Get all the blocks in the agent's core memory
 

{letta_nightly-0.6.12.dev20250121104040 → letta_nightly-0.6.13.dev20250122185528}/letta/schemas/agent.py

@@ -123,7 +123,7 @@ class CreateAgent(BaseModel, validate_assignment=True):  #
     )
     description: Optional[str] = Field(None, description="The description of the agent.")
     metadata_: Optional[Dict] = Field(None, description="The metadata of the agent.", alias="metadata_")
-    llm: Optional[str] = Field(
+    model: Optional[str] = Field(
         None,
         description="The LLM configuration handle used by the agent, specified in the format "
         "provider/model-name, as an alternative to specifying llm_config.",
@@ -139,7 +139,7 @@ class CreateAgent(BaseModel, validate_assignment=True):  #
     tool_exec_environment_variables: Optional[Dict[str, str]] = Field(
         None, description="The environment variables for tool execution specific to this agent."
     )
-    variables: Optional[Dict[str, str]] = Field(None, description="The variables that should be set for the agent.")
+    memory_variables: Optional[Dict[str, str]] = Field(None, description="The variables that should be set for the agent.")
 
     @field_validator("name")
     @classmethod
@@ -166,17 +166,17 @@ class CreateAgent(BaseModel, validate_assignment=True):  #
 
         return name
 
-    @field_validator("llm")
+    @field_validator("model")
     @classmethod
-    def validate_llm(cls, llm: Optional[str]) -> Optional[str]:
-        if not llm:
-            return llm
+    def validate_model(cls, model: Optional[str]) -> Optional[str]:
+        if not model:
+            return model
 
-        provider_name, model_name = llm.split("/", 1)
+        provider_name, model_name = model.split("/", 1)
         if not provider_name or not model_name:
             raise ValueError("The llm config handle should be in the format provider/model-name")
 
-        return llm
+        return model
 
     @field_validator("embedding")
     @classmethod
@@ -184,8 +184,8 @@ class CreateAgent(BaseModel, validate_assignment=True):  #
         if not embedding:
             return embedding
 
-        provider_name, model_name = embedding.split("/", 1)
-        if not provider_name or not model_name:
+        provider_name, embedding_name = embedding.split("/", 1)
+        if not provider_name or not embedding_name:
             raise ValueError("The embedding config handle should be in the format provider/model-name")
 
         return embedding

{letta_nightly-0.6.12.dev20250121104040 → letta_nightly-0.6.13.dev20250122185528}/letta/server/rest_api/routers/v1/agents.py

@@ -14,7 +14,7 @@ from letta.schemas.job import JobStatus, JobUpdate
 from letta.schemas.letta_message import LettaMessageUnion
 from letta.schemas.letta_request import LettaRequest, LettaStreamingRequest
 from letta.schemas.letta_response import LettaResponse
-from letta.schemas.memory import ArchivalMemorySummary, ContextWindowOverview, CreateArchivalMemory, Memory, RecallMemorySummary
+from letta.schemas.memory import ContextWindowOverview, CreateArchivalMemory, Memory
 from letta.schemas.message import Message, MessageUpdate
 from letta.schemas.passage import Passage
 from letta.schemas.run import Run
@@ -113,7 +113,7 @@ def update_agent(
     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"""
+    """Update an existing agent"""
     actor = server.user_manager.get_user_or_default(user_id=user_id)
     return server.agent_manager.update_agent(agent_id=agent_id, agent_update=update_agent, actor=actor)
 
@@ -212,21 +212,8 @@ def get_agent_sources(
     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.
-    """
-    actor = server.user_manager.get_user_or_default(user_id=user_id)
-    return server.agent_manager.get_in_context_messages(agent_id=agent_id, actor=actor)
-
-
 # TODO: remove? can also get with agent blocks
-@router.get("/{agent_id}/memory", response_model=Memory, operation_id="get_agent_memory")
+@router.get("/{agent_id}/core_memory", response_model=Memory, operation_id="get_agent_memory")
 def get_agent_memory(
     agent_id: str,
     server: "SyncServer" = Depends(get_letta_server),
@@ -241,7 +228,7 @@ def get_agent_memory(
     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")
+@router.get("/{agent_id}/core_memory/blocks/{block_label}", response_model=Block, operation_id="get_agent_memory_block")
 def get_agent_memory_block(
     agent_id: str,
     block_label: str,
@@ -259,8 +246,8 @@ def get_agent_memory_block(
         raise HTTPException(status_code=404, detail=str(e))
 
 
-@router.get("/{agent_id}/memory/block", response_model=List[Block], operation_id="get_agent_memory_blocks")
-def get_agent_memory_blocks(
+@router.get("/{agent_id}/core_memory/blocks", response_model=List[Block], operation_id="list_agent_memory_blocks")
+def list_agent_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
@@ -276,7 +263,7 @@ def get_agent_memory_blocks(
         raise HTTPException(status_code=404, detail=str(e))
 
 
-@router.post("/{agent_id}/memory/block", response_model=Memory, operation_id="add_agent_memory_block")
+@router.post("/{agent_id}/core_memory/blocks", response_model=Memory, operation_id="add_agent_memory_block")
 def add_agent_memory_block(
     agent_id: str,
     create_block: CreateBlock = Body(...),
@@ -299,7 +286,7 @@ def add_agent_memory_block(
     return agent.memory
 
 
-@router.delete("/{agent_id}/memory/block/{block_label}", response_model=Memory, operation_id="remove_agent_memory_block_by_label")
+@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(
     agent_id: str,
     # TODO should this be block_id, or the label?
@@ -319,7 +306,7 @@ def remove_agent_memory_block(
     return agent.memory
 
 
-@router.patch("/{agent_id}/memory/block/{block_label}", response_model=Block, operation_id="update_agent_memory_block_by_label")
+@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(
     agent_id: str,
     block_label: str,
@@ -341,34 +328,7 @@ def update_agent_memory_block(
     return block
 
 
-@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, 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.
-    """
-    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")
+@router.get("/{agent_id}/archival_memory", response_model=List[Passage], operation_id="list_agent_archival_memory")
 def get_agent_archival_memory(
     agent_id: str,
     server: "SyncServer" = Depends(get_letta_server),
@@ -394,7 +354,7 @@ def get_agent_archival_memory(
     )
 
 
-@router.post("/{agent_id}/archival", response_model=List[Passage], operation_id="create_agent_archival_memory")
+@router.post("/{agent_id}/archival_memory", response_model=List[Passage], operation_id="create_agent_archival_memory")
 def insert_agent_archival_memory(
     agent_id: str,
     request: CreateArchivalMemory = Body(...),
@@ -411,7 +371,7 @@ 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_id}", response_model=None, operation_id="delete_agent_archival_memory")
+@router.delete("/{agent_id}/archival_memory/{memory_id}", response_model=None, operation_id="delete_agent_archival_memory")
 def delete_agent_archival_memory(
     agent_id: str,
     memory_id: str,

{letta_nightly-0.6.12.dev20250121104040 → letta_nightly-0.6.13.dev20250122185528}/letta/server/rest_api/routers/v1/providers.py

@@ -45,7 +45,7 @@ def create_provider(
     return provider
 
 
-@router.put("/", tags=["providers"], response_model=Provider, operation_id="update_provider")
+@router.patch("/", tags=["providers"], response_model=Provider, operation_id="update_provider")
 def update_provider(
     request: ProviderUpdate = Body(...),
     server: "SyncServer" = Depends(get_letta_server),

{letta_nightly-0.6.12.dev20250121104040 → letta_nightly-0.6.13.dev20250122185528}/letta/server/rest_api/routers/v1/tools.py

@@ -48,23 +48,6 @@ def get_tool(
     return tool
 
 
-@router.get("/name/{tool_name}", response_model=str, operation_id="get_tool_id_by_name")
-def get_tool_id(
-    tool_name: 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 a tool ID by name
-    """
-    actor = server.user_manager.get_user_or_default(user_id=user_id)
-    tool = server.tool_manager.get_tool_by_name(tool_name=tool_name, actor=actor)
-    if tool:
-        return tool.id
-    else:
-        raise HTTPException(status_code=404, detail=f"Tool with name {tool_name} and organization id {actor.organization_id} not found.")
-
-
 @router.get("/", response_model=List[Tool], operation_id="list_tools")
 def list_tools(
     cursor: Optional[str] = None,

{letta_nightly-0.6.12.dev20250121104040 → letta_nightly-0.6.13.dev20250122185528}/letta/server/server.py

@@ -773,9 +773,9 @@ class SyncServer(Server):
         interface: Union[AgentInterface, None] = None,
     ) -> AgentState:
         if request.llm_config is None:
-            if request.llm is None:
-                raise ValueError("Must specify either llm or llm_config in request")
-            request.llm_config = self.get_llm_config_from_handle(handle=request.llm, context_window_limit=request.context_window_limit)
+            if request.model is None:
+                raise ValueError("Must specify either model or llm_config in request")
+            request.llm_config = self.get_llm_config_from_handle(handle=request.model, context_window_limit=request.context_window_limit)
 
         if request.embedding_config is None:
             if request.embedding is None:

{letta_nightly-0.6.12.dev20250121104040 → letta_nightly-0.6.13.dev20250122185528}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "letta-nightly"
-version = "0.6.12.dev20250121104040"
+version = "0.6.13.dev20250122185528"
 packages = [
     {include = "letta"},
 ]