letta-nightly 0.5.3.dev20241121022151__py3-none-any.whl → 0.5.4.dev20241122104229__py3-none-any.whl

letta/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "0.5.3"
+__version__ = "0.5.4"
 
 # import clients
 from letta.client.client import LocalClient, RESTClient, create_client

letta/agent.py

@@ -1208,6 +1208,30 @@ class Agent(BaseAgent):
         new_messages = [new_system_message_obj] + self._messages[1:]  # swap index 0 (system)
         self._messages = new_messages
 
+    def update_memory_blocks_from_db(self):
+        for block in self.memory.to_dict()["memory"].values():
+            if block.get("templates", False):
+                # we don't expect to update shared memory blocks that
+                # are templates. this is something we could update in the
+                # future if we expect templates to change often.
+                continue
+            block_id = block.get("id")
+
+            # TODO: This is really hacky and we should probably figure out how to
+            db_block = BlockManager().get_block_by_id(block_id=block_id, actor=self.user)
+            if db_block is None:
+                # this case covers if someone has deleted a shared block by interacting
+                # with some other agent.
+                # in that case we should remove this shared block from the agent currently being
+                # evaluated.
+                printd(f"removing block: {block_id=}")
+                continue
+            if not isinstance(db_block.value, str):
+                printd(f"skipping block update, unexpected value: {block_id=}")
+                continue
+            # TODO: we may want to update which columns we're updating from shared memory e.g. the limit
+            self.memory.update_block_value(label=block.get("label", ""), value=db_block.value)
+
     def rebuild_memory(self, force=False, update_timestamp=True, ms: Optional[MetadataStore] = None):
         """Rebuilds the system message with the latest memory object and any shared memory block updates"""
         curr_system_message = self.messages[0]  # this is the system + memory bank, not just the system prompt
@@ -1219,28 +1243,7 @@ class Agent(BaseAgent):
             return
 
         if ms:
-            for block in self.memory.to_dict()["memory"].values():
-                if block.get("templates", False):
-                    # we don't expect to update shared memory blocks that
-                    # are templates. this is something we could update in the
-                    # future if we expect templates to change often.
-                    continue
-                block_id = block.get("id")
-
-                # TODO: This is really hacky and we should probably figure out how to
-                db_block = BlockManager().get_block_by_id(block_id=block_id, actor=self.user)
-                if db_block is None:
-                    # this case covers if someone has deleted a shared block by interacting
-                    # with some other agent.
-                    # in that case we should remove this shared block from the agent currently being
-                    # evaluated.
-                    printd(f"removing block: {block_id=}")
-                    continue
-                if not isinstance(db_block.value, str):
-                    printd(f"skipping block update, unexpected value: {block_id=}")
-                    continue
-                # TODO: we may want to update which columns we're updating from shared memory e.g. the limit
-                self.memory.update_block_value(label=block.get("label", ""), value=db_block.value)
+            self.update_memory_blocks_from_db()
 
         # If the memory didn't update, we probably don't want to update the timestamp inside
         # For example, if we're doing a system prompt swap, this should probably be False

letta/client/client.py

@@ -190,9 +190,6 @@ class AbstractClient(object):
     def load_langchain_tool(self, langchain_tool: "LangChainBaseTool", additional_imports_module_attr_map: dict[str, str] = None) -> Tool:
         raise NotImplementedError
 
-    def load_crewai_tool(self, crewai_tool: "CrewAIBaseTool", additional_imports_module_attr_map: dict[str, str] = None) -> Tool:
-        raise NotImplementedError
-
     def load_composio_tool(self, action: "ActionType") -> Tool:
         raise NotImplementedError
 
@@ -899,8 +896,8 @@ class RESTClient(AbstractClient):
         else:
             return Block(**response.json())
 
-    def update_block(self, block_id: str, name: Optional[str] = None, text: Optional[str] = None) -> Block:
-        request = BlockUpdate(id=block_id, template_name=name, value=text)
+    def update_block(self, block_id: str, name: Optional[str] = None, text: Optional[str] = None, limit: Optional[int] = None) -> Block:
+        request = BlockUpdate(id=block_id, template_name=name, value=text, limit=limit if limit else self.get_block(block_id).limit)
         response = requests.post(f"{self.base_url}/{self.api_prefix}/blocks/{block_id}", json=request.model_dump(), headers=self.headers)
         if response.status_code != 200:
             raise ValueError(f"Failed to update block: {response.text}")
@@ -1568,6 +1565,53 @@ class RESTClient(AbstractClient):
         # Parse and return the deleted organization
         return Organization(**response.json())
 
+    def update_agent_memory_label(self, agent_id: str, current_label: str, new_label: str) -> Memory:
+
+        # @router.patch("/{agent_id}/memory/label", response_model=Memory, operation_id="update_agent_memory_label")
+        response = requests.patch(
+            f"{self.base_url}/{self.api_prefix}/agents/{agent_id}/memory/label",
+            headers=self.headers,
+            json={"current_label": current_label, "new_label": new_label},
+        )
+        if response.status_code != 200:
+            raise ValueError(f"Failed to update agent memory label: {response.text}")
+        return Memory(**response.json())
+
+    def add_agent_memory_block(self, agent_id: str, create_block: BlockCreate) -> Memory:
+
+        # @router.post("/{agent_id}/memory/block", response_model=Memory, operation_id="add_agent_memory_block")
+        response = requests.post(
+            f"{self.base_url}/{self.api_prefix}/agents/{agent_id}/memory/block",
+            headers=self.headers,
+            json=create_block.model_dump(),
+        )
+        if response.status_code != 200:
+            raise ValueError(f"Failed to add agent memory block: {response.text}")
+        return Memory(**response.json())
+
+    def remove_agent_memory_block(self, agent_id: str, block_label: str) -> Memory:
+
+        # @router.delete("/{agent_id}/memory/block/{block_label}", response_model=Memory, operation_id="remove_agent_memory_block")
+        response = requests.delete(
+            f"{self.base_url}/{self.api_prefix}/agents/{agent_id}/memory/block/{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 update_agent_memory_limit(self, agent_id: str, block_label: str, limit: int) -> Memory:
+
+        # @router.patch("/{agent_id}/memory/limit", response_model=Memory, operation_id="update_agent_memory_limit")
+        response = requests.patch(
+            f"{self.base_url}/{self.api_prefix}/agents/{agent_id}/memory/limit",
+            headers=self.headers,
+            json={"label": block_label, "limit": limit},
+        )
+        if response.status_code != 200:
+            raise ValueError(f"Failed to update agent memory limit: {response.text}")
+        return Memory(**response.json())
+
 
 class LocalClient(AbstractClient):
     """
@@ -2690,7 +2734,7 @@ class LocalClient(AbstractClient):
             Block(label=label, template_name=template_name, value=value, is_template=is_template), actor=self.user
         )
 
-    def update_block(self, block_id: str, name: Optional[str] = None, text: Optional[str] = None) -> Block:
+    def update_block(self, block_id: str, name: Optional[str] = None, text: Optional[str] = None, limit: Optional[int] = None) -> Block:
         """
         Update a block
 
@@ -2703,7 +2747,9 @@ class LocalClient(AbstractClient):
             block (Block): Updated block
         """
         return self.server.block_manager.update_block(
-            block_id=block_id, block_update=BlockUpdate(template_name=name, value=text), actor=self.user
+            block_id=block_id,
+            block_update=BlockUpdate(template_name=name, value=text, limit=limit if limit else self.get_block(block_id).limit),
+            actor=self.user,
         )
 
     def get_block(self, block_id: str) -> Block:
@@ -2774,3 +2820,21 @@ class LocalClient(AbstractClient):
 
     def delete_org(self, org_id: str) -> Organization:
         return self.server.organization_manager.delete_organization_by_id(org_id=org_id)
+
+    def update_agent_memory_label(self, agent_id: str, current_label: str, new_label: str) -> Memory:
+        return self.server.update_agent_memory_label(
+            user_id=self.user_id, agent_id=agent_id, current_block_label=current_label, new_block_label=new_label
+        )
+
+    def add_agent_memory_block(self, agent_id: str, create_block: BlockCreate) -> Memory:
+        block_req = Block(**create_block.model_dump())
+        block = self.server.block_manager.create_or_update_block(actor=self.user, block=block_req)
+        # Link the block to the agent
+        updated_memory = self.server.link_block_to_agent_memory(user_id=self.user_id, agent_id=agent_id, block_id=block.id)
+        return updated_memory
+
+    def remove_agent_memory_block(self, agent_id: str, block_label: str) -> Memory:
+        return self.server.unlink_block_from_agent_memory(user_id=self.user_id, agent_id=agent_id, block_label=block_label)
+
+    def update_agent_memory_limit(self, agent_id: str, block_label: str, limit: int) -> Memory:
+        return self.server.update_agent_memory_limit(user_id=self.user_id, agent_id=agent_id, block_label=block_label, limit=limit)

letta/functions/helpers.py

@@ -61,36 +61,6 @@ def {func_name}(**kwargs):
     return func_name, wrapper_function_str
 
 
-def generate_crewai_tool_wrapper(tool: "CrewAIBaseTool", additional_imports_module_attr_map: dict[str, str] = None) -> tuple[str, str]:
-    tool_name = tool.__class__.__name__
-    import_statement = f"from crewai_tools import {tool_name}"
-    extra_module_imports = generate_import_code(additional_imports_module_attr_map)
-
-    # Safety check that user has passed in all required imports:
-    assert_all_classes_are_imported(tool, additional_imports_module_attr_map)
-
-    tool_instantiation = f"tool = {generate_imported_tool_instantiation_call_str(tool)}"
-    run_call = f"return tool._run(**kwargs)"
-    func_name = humps.decamelize(tool_name)
-
-    # Combine all parts into the wrapper function
-    wrapper_function_str = f"""
-def {func_name}(**kwargs):
-    if 'self' in kwargs:
-        del kwargs['self']
-    import importlib
-    {import_statement}
-    {extra_module_imports}
-    {tool_instantiation}
-    {run_call}
-"""
-
-    # Compile safety check
-    assert_code_gen_compilable(wrapper_function_str)
-
-    return func_name, wrapper_function_str
-
-
 def assert_code_gen_compilable(code_str):
     try:
         compile(code_str, "<string>", "exec")
@@ -98,9 +68,7 @@ def assert_code_gen_compilable(code_str):
         print(f"Syntax error in code: {e}")
 
 
-def assert_all_classes_are_imported(
-    tool: Union["LangChainBaseTool", "CrewAIBaseTool"], additional_imports_module_attr_map: dict[str, str]
-) -> None:
+def assert_all_classes_are_imported(tool: Union["LangChainBaseTool"], additional_imports_module_attr_map: dict[str, str]) -> None:
     # Safety check that user has passed in all required imports:
     tool_name = tool.__class__.__name__
     current_class_imports = {tool_name}
@@ -114,7 +82,7 @@ def assert_all_classes_are_imported(
         raise RuntimeError(err_msg)
 
 
-def find_required_class_names_for_import(obj: Union["LangChainBaseTool", "CrewAIBaseTool", BaseModel]) -> list[str]:
+def find_required_class_names_for_import(obj: Union["LangChainBaseTool", BaseModel]) -> list[str]:
     """
     Finds all the class names for required imports when instantiating the `obj`.
     NOTE: This does not return the full import path, only the class name.
@@ -202,10 +170,10 @@ def generate_imported_tool_instantiation_call_str(obj: Any) -> Optional[str]:
     else:
         # Otherwise, if it is none of the above, that usually means it is a custom Python class that is NOT a BaseModel
         # Thus, we cannot get enough information about it to stringify it
-        # This may cause issues, but we are making the assumption that any of these custom Python types are handled correctly by the parent library, such as LangChain or CrewAI
+        # This may cause issues, but we are making the assumption that any of these custom Python types are handled correctly by the parent library, such as LangChain
         # An example would be that WikipediaAPIWrapper has an argument that is a wikipedia (pip install wikipedia) object
         # We cannot stringify this easily, but WikipediaAPIWrapper handles the setting of this parameter internally
-        # This assumption seems fair to me, since usually they are external imports, and LangChain and CrewAI should be bundling those as module-level imports within the tool
+        # This assumption seems fair to me, since usually they are external imports, and LangChain should be bundling those as module-level imports within the tool
         # We throw a warning here anyway and provide the class name
         print(
             f"[WARNING] Skipping parsing unknown class {obj.__class__.__name__} (does not inherit from the Pydantic BaseModel and is not a basic Python type)"
@@ -219,10 +187,9 @@ def generate_imported_tool_instantiation_call_str(obj: Any) -> Optional[str]:
 
 
 def is_base_model(obj: Any):
-    from crewai_tools.tools.base_tool import BaseModel as CrewAiBaseModel
     from langchain_core.pydantic_v1 import BaseModel as LangChainBaseModel
 
-    return isinstance(obj, BaseModel) or isinstance(obj, LangChainBaseModel) or isinstance(obj, CrewAiBaseModel)
+    return isinstance(obj, BaseModel) or isinstance(obj, LangChainBaseModel)
 
 
 def generate_import_code(module_attr_map: Optional[dict]):

letta/metadata.py

@@ -2,6 +2,7 @@
 
 import os
 import secrets
+import warnings
 from typing import List, Optional
 
 from sqlalchemy import JSON, Column, DateTime, Index, String, TypeDecorator
@@ -353,8 +354,14 @@ class MetadataStore:
                 raise ValueError(f"Agent with name {agent.name} already exists")
             fields = vars(agent)
             fields["memory"] = agent.memory.to_dict()
-            del fields["_internal_memory"]
-            del fields["tags"]
+            if "_internal_memory" in fields:
+                del fields["_internal_memory"]
+            else:
+                warnings.warn(f"Agent {agent.id} has no _internal_memory field")
+            if "tags" in fields:
+                del fields["tags"]
+            else:
+                warnings.warn(f"Agent {agent.id} has no tags field")
             session.add(AgentModel(**fields))
             session.commit()
 
@@ -364,8 +371,14 @@ class MetadataStore:
             fields = vars(agent)
             if isinstance(agent.memory, Memory):  # TODO: this is nasty but this whole class will soon be removed so whatever
                 fields["memory"] = agent.memory.to_dict()
-            del fields["_internal_memory"]
-            del fields["tags"]
+            if "_internal_memory" in fields:
+                del fields["_internal_memory"]
+            else:
+                warnings.warn(f"Agent {agent.id} has no _internal_memory field")
+            if "tags" in fields:
+                del fields["tags"]
+            else:
+                warnings.warn(f"Agent {agent.id} has no tags field")
             session.query(AgentModel).filter(AgentModel.id == agent.id).update(fields)
             session.commit()
 

letta/schemas/block.py

@@ -1,6 +1,6 @@
 from typing import Optional
 
-from pydantic import Field, model_validator
+from pydantic import BaseModel, Field, model_validator
 from typing_extensions import Self
 
 from letta.schemas.letta_base import LettaBase
@@ -95,6 +95,13 @@ class BlockCreate(BaseBlock):
     label: str = Field(..., description="Label of the block.")
 
 
+class BlockLabelUpdate(BaseModel):
+    """Update the label of a block"""
+
+    current_label: str = Field(..., description="Current label of the block.")
+    new_label: str = Field(..., description="New label of the block.")
+
+
 class CreatePersona(BlockCreate):
     """Create a persona block"""
 
@@ -117,6 +124,13 @@ class BlockUpdate(BaseBlock):
         extra = "ignore"  # Ignores extra fields
 
 
+class BlockLimitUpdate(BaseModel):
+    """Update the limit of a block"""
+
+    label: str = Field(..., description="Label of the block.")
+    limit: int = Field(..., description="New limit of the block.")
+
+
 class UpdatePersona(BlockUpdate):
     """Update a persona block"""
 

letta/schemas/memory.py

@@ -158,6 +158,13 @@ class Memory(BaseModel, validate_assignment=True):
 
         self.memory[block.label] = block
 
+    def unlink_block(self, block_label: str) -> Block:
+        """Unlink a block from the memory object"""
+        if block_label not in self.memory:
+            raise ValueError(f"Block with label {block_label} does not exist")
+
+        return self.memory.pop(block_label)
+
     def update_block_value(self, label: str, value: str):
         """Update the value of a block"""
         if label not in self.memory:
@@ -167,6 +174,32 @@ class Memory(BaseModel, validate_assignment=True):
 
         self.memory[label].value = value
 
+    def update_block_label(self, current_label: str, new_label: str):
+        """Update the label of a block"""
+        if current_label not in self.memory:
+            raise ValueError(f"Block with label {current_label} does not exist")
+        if not isinstance(new_label, str):
+            raise ValueError(f"Provided new label must be a string")
+
+        # First change the label of the block
+        self.memory[current_label].label = new_label
+
+        # Then swap the block to the new label
+        self.memory[new_label] = self.memory.pop(current_label)
+
+    def update_block_limit(self, label: str, limit: int):
+        """Update the limit of a block"""
+        if label not in self.memory:
+            raise ValueError(f"Block with label {label} does not exist")
+        if not isinstance(limit, int):
+            raise ValueError(f"Provided limit must be an integer")
+
+        # Check to make sure the new limit is greater than the current length of the block
+        if len(self.memory[label].value) > limit:
+            raise ValueError(f"New limit {limit} is less than the current length of the block {len(self.memory[label].value)}")
+
+        self.memory[label].limit = limit
+
 
 # TODO: ideally this is refactored into ChatMemory and the subclasses are given more specific names.
 class BasicBlockMemory(Memory):

letta/schemas/tool.py

@@ -4,13 +4,9 @@ from pydantic import Field
 
 from letta.functions.helpers import (
     generate_composio_tool_wrapper,
-    generate_crewai_tool_wrapper,
     generate_langchain_tool_wrapper,
 )
-from letta.functions.schema_generator import (
-    generate_schema_from_args_schema_v1,
-    generate_schema_from_args_schema_v2,
-)
+from letta.functions.schema_generator import generate_schema_from_args_schema_v2
 from letta.schemas.letta_base import LettaBase
 from letta.schemas.openai.chat_completions import ToolCall
 
@@ -132,37 +128,7 @@ class ToolCreate(LettaBase):
         tags = ["langchain"]
         # NOTE: langchain tools may come from different packages
         wrapper_func_name, wrapper_function_str = generate_langchain_tool_wrapper(langchain_tool, additional_imports_module_attr_map)
-        json_schema = generate_schema_from_args_schema_v1(langchain_tool.args_schema, name=wrapper_func_name, description=description)
-
-        return cls(
-            name=wrapper_func_name,
-            description=description,
-            source_type=source_type,
-            tags=tags,
-            source_code=wrapper_function_str,
-            json_schema=json_schema,
-        )
-
-    @classmethod
-    def from_crewai(
-        cls,
-        crewai_tool: "CrewAIBaseTool",
-        additional_imports_module_attr_map: dict[str, str] = None,
-    ) -> "ToolCreate":
-        """
-        Class method to create an instance of Tool from a crewAI BaseTool object.
-
-        Args:
-            crewai_tool (CrewAIBaseTool): An instance of a crewAI BaseTool (BaseTool from crewai)
-
-        Returns:
-            Tool: A Letta Tool initialized with attributes derived from the provided crewAI BaseTool object.
-        """
-        description = crewai_tool.description
-        source_type = "python"
-        tags = ["crew-ai"]
-        wrapper_func_name, wrapper_function_str = generate_crewai_tool_wrapper(crewai_tool, additional_imports_module_attr_map)
-        json_schema = generate_schema_from_args_schema_v1(crewai_tool.args_schema, name=wrapper_func_name, description=description)
+        json_schema = generate_schema_from_args_schema_v2(langchain_tool.args_schema, name=wrapper_func_name, description=description)
 
         return cls(
             name=wrapper_func_name,
@@ -185,15 +151,6 @@ class ToolCreate(LettaBase):
 
         return [wikipedia_tool]
 
-    @classmethod
-    def load_default_crewai_tools(cls) -> List["ToolCreate"]:
-        # For now, we only support scrape website tool
-        from crewai_tools import ScrapeWebsiteTool
-
-        web_scrape_tool = ToolCreate.from_crewai(ScrapeWebsiteTool())
-
-        return [web_scrape_tool]
-
     @classmethod
     def load_default_composio_tools(cls) -> List["ToolCreate"]:
         from composio_langchain import Action

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

@@ -7,6 +7,7 @@ from fastapi.responses import JSONResponse, StreamingResponse
 
 from letta.constants import DEFAULT_MESSAGE_TOOL, DEFAULT_MESSAGE_TOOL_KWARG
 from letta.schemas.agent import AgentState, CreateAgent, UpdateAgentState
+from letta.schemas.block import Block, BlockCreate, BlockLabelUpdate, BlockLimitUpdate
 from letta.schemas.enums import MessageStreamStatus
 from letta.schemas.letta_message import (
     LegacyLettaMessage,
@@ -217,7 +218,9 @@ def update_agent_memory(
 ):
     """
     Update the core memory of a specific agent.
-    This endpoint accepts new memory contents (human and persona) and updates the core memory of the agent identified by the user ID and agent ID.
+        This endpoint accepts new memory contents (labels as keys, and values as values) and updates the core memory of the agent identified by the user ID and agent ID.
+    This endpoint accepts new memory contents to update the core memory of the agent.
+    This endpoint only supports modifying existing blocks; it does not support deleting/unlinking or creating/linking blocks.
     """
     actor = server.get_user_or_default(user_id=user_id)
 
@@ -225,6 +228,87 @@ def update_agent_memory(
     return memory
 
 
+@router.patch("/{agent_id}/memory/label", response_model=Memory, operation_id="update_agent_memory_label")
+def update_agent_memory_label(
+    agent_id: str,
+    update_label: BlockLabelUpdate = 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 label of a block in an agent's memory.
+    """
+    actor = server.get_user_or_default(user_id=user_id)
+
+    memory = server.update_agent_memory_label(
+        user_id=actor.id, agent_id=agent_id, current_block_label=update_label.current_label, new_block_label=update_label.new_label
+    )
+    return memory
+
+
+@router.post("/{agent_id}/memory/block", response_model=Memory, operation_id="add_agent_memory_block")
+def add_agent_memory_block(
+    agent_id: str,
+    create_block: BlockCreate = 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.
+    """
+    actor = server.get_user_or_default(user_id=user_id)
+
+    # Copied from POST /blocks
+    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
+
+
+@router.delete("/{agent_id}/memory/block/{block_label}", response_model=Memory, operation_id="remove_agent_memory_block")
+def remove_agent_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,
+    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)
+
+    # 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)
+
+    return updated_memory
+
+
+@router.patch("/{agent_id}/memory/limit", response_model=Memory, operation_id="update_agent_memory_limit")
+def update_agent_memory_limit(
+    agent_id: str,
+    update_label: BlockLimitUpdate = 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 limit of a block in an agent's memory.
+    """
+    actor = server.get_user_or_default(user_id=user_id)
+
+    memory = server.update_agent_memory_limit(
+        user_id=actor.id,
+        agent_id=agent_id,
+        block_label=update_label.label,
+        limit=update_label.limit,
+    )
+    return memory
+
+
 @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,

letta/server/server.py

@@ -328,6 +328,15 @@ class SyncServer(Server):
                 )
             )
 
+    def save_agents(self):
+        """Saves all the agents that are in the in-memory object store"""
+        for agent_d in self.active_agents:
+            try:
+                save_agent(agent_d["agent"], self.ms)
+                logger.info(f"Saved agent {agent_d['agent_id']}")
+            except Exception as e:
+                logger.exception(f"Error occurred while trying to save agent {agent_d['agent_id']}:\n{e}")
+
     def _get_agent(self, user_id: str, agent_id: str) -> Union[Agent, None]:
         """Get the agent object from the in-memory object store"""
         for d in self.active_agents:
@@ -400,8 +409,10 @@ class SyncServer(Server):
             logger.exception(f"Error occurred while trying to get agent {agent_id}:\n{e}")
             raise
 
-    def _get_or_load_agent(self, agent_id: str) -> Agent:
+    def _get_or_load_agent(self, agent_id: str, caching: bool = True) -> Agent:
         """Check if the agent is in-memory, then load"""
+
+        # Gets the agent state
         agent_state = self.ms.get_agent(agent_id=agent_id)
         if not agent_state:
             raise ValueError(f"Agent does not exist")
@@ -409,11 +420,24 @@ class SyncServer(Server):
         actor = self.user_manager.get_user_by_id(user_id)
 
         logger.debug(f"Checking for agent user_id={user_id} agent_id={agent_id}")
-        # TODO: consider disabling loading cached agents due to potential concurrency issues
-        letta_agent = self._get_agent(user_id=user_id, agent_id=agent_id)
-        if not letta_agent:
-            logger.debug(f"Agent not loaded, loading agent user_id={user_id} agent_id={agent_id}")
+        if caching:
+            # TODO: consider disabling loading cached agents due to potential concurrency issues
+            letta_agent = self._get_agent(user_id=user_id, agent_id=agent_id)
+            if not letta_agent:
+                logger.debug(f"Agent not loaded, loading agent user_id={user_id} agent_id={agent_id}")
+                letta_agent = self._load_agent(agent_id=agent_id, actor=actor)
+        else:
+            # This breaks unit tests in test_local_client.py
             letta_agent = self._load_agent(agent_id=agent_id, actor=actor)
+
+        # letta_agent = self._get_agent(user_id=user_id, agent_id=agent_id)
+        # if not letta_agent:
+        # logger.debug(f"Agent not loaded, loading agent user_id={user_id} agent_id={agent_id}")
+
+        # NOTE: no longer caching, always forcing a lot from the database
+        # Loads the agent objects
+        # letta_agent = self._load_agent(agent_id=agent_id, actor=actor)
+
         return letta_agent
 
     def _step(
@@ -1376,8 +1400,9 @@ class SyncServer(Server):
         # Get the agent object (loaded in memory)
         letta_agent = self._get_or_load_agent(agent_id=agent_id)
         assert isinstance(letta_agent.memory, Memory)
-        agent_state = letta_agent.agent_state.model_copy(deep=True)
 
+        letta_agent.update_memory_blocks_from_db()
+        agent_state = letta_agent.agent_state.model_copy(deep=True)
         # Load the tags in for the agent_state
         agent_state.tags = self.agents_tags_manager.get_tags_for_agent(agent_id=agent_id, actor=user)
         return agent_state
@@ -1431,6 +1456,7 @@ class SyncServer(Server):
         # If we modified the memory contents, we need to rebuild the memory block inside the system message
         if modified:
             letta_agent.rebuild_memory()
+            # letta_agent.rebuild_memory(force=True, ms=self.ms)  # This breaks unit tests in test_local_client.py
             # save agent
             save_agent(letta_agent, self.ms)
 
@@ -1723,7 +1749,7 @@ class SyncServer(Server):
     def add_default_external_tools(self, actor: User) -> bool:
         """Add default langchain tools. Return true if successful, false otherwise."""
         success = True
-        tool_creates = ToolCreate.load_default_langchain_tools() + ToolCreate.load_default_crewai_tools()
+        tool_creates = ToolCreate.load_default_langchain_tools()
         if tool_settings.composio_api_key:
             tool_creates += ToolCreate.load_default_composio_tools()
         for tool_create in tool_creates:
@@ -1817,3 +1843,119 @@ class SyncServer(Server):
         # Get the current message
         letta_agent = self._get_or_load_agent(agent_id=agent_id)
         return letta_agent.get_context_window()
+
+    def update_agent_memory_label(self, user_id: str, agent_id: str, current_block_label: str, new_block_label: str) -> Memory:
+        """Update the label of a block in an agent's memory"""
+
+        # Get the user
+        user = self.user_manager.get_user_by_id(user_id=user_id)
+
+        # Link a block to an agent's memory
+        letta_agent = self._get_or_load_agent(agent_id=agent_id)
+        letta_agent.memory.update_block_label(current_label=current_block_label, new_label=new_block_label)
+        assert new_block_label in letta_agent.memory.list_block_labels()
+        self.block_manager.create_or_update_block(block=letta_agent.memory.get_block(new_block_label), actor=user)
+
+        # check that the block was updated
+        updated_block = self.block_manager.get_block_by_id(block_id=letta_agent.memory.get_block(new_block_label).id, actor=user)
+
+        # Recompile the agent memory
+        letta_agent.rebuild_memory(force=True, ms=self.ms)
+
+        # save agent
+        save_agent(letta_agent, self.ms)
+
+        updated_agent = self.ms.get_agent(agent_id=agent_id)
+        if updated_agent is None:
+            raise ValueError(f"Agent with id {agent_id} not found after linking block")
+        assert new_block_label in updated_agent.memory.list_block_labels()
+        assert current_block_label not in updated_agent.memory.list_block_labels()
+        return updated_agent.memory
+
+    def link_block_to_agent_memory(self, user_id: str, agent_id: str, block_id: str) -> Memory:
+        """Link a block to an agent's memory"""
+
+        # Get the user
+        user = self.user_manager.get_user_by_id(user_id=user_id)
+
+        # Get the block first
+        block = self.block_manager.get_block_by_id(block_id=block_id, actor=user)
+        if block is None:
+            raise ValueError(f"Block with id {block_id} not found")
+
+        # Link a block to an agent's memory
+        letta_agent = self._get_or_load_agent(agent_id=agent_id)
+        letta_agent.memory.link_block(block=block)
+        assert block.label in letta_agent.memory.list_block_labels()
+
+        # Recompile the agent memory
+        letta_agent.rebuild_memory(force=True, ms=self.ms)
+
+        # save agent
+        save_agent(letta_agent, self.ms)
+
+        updated_agent = self.ms.get_agent(agent_id=agent_id)
+        if updated_agent is None:
+            raise ValueError(f"Agent with id {agent_id} not found after linking block")
+        assert block.label in updated_agent.memory.list_block_labels()
+
+        return updated_agent.memory
+
+    def unlink_block_from_agent_memory(self, user_id: str, agent_id: str, block_label: str, delete_if_no_ref: bool = True) -> Memory:
+        """Unlink a block from an agent's memory. If the block is not linked to any agent, delete it."""
+
+        # Get the user
+        user = self.user_manager.get_user_by_id(user_id=user_id)
+
+        # Link a block to an agent's memory
+        letta_agent = self._get_or_load_agent(agent_id=agent_id)
+        unlinked_block = letta_agent.memory.unlink_block(block_label=block_label)
+        assert unlinked_block.label not in letta_agent.memory.list_block_labels()
+
+        # Check if the block is linked to any other agent
+        # TODO needs reference counting GC to handle loose blocks
+        # block = self.block_manager.get_block_by_id(block_id=unlinked_block.id, actor=user)
+        # if block is None:
+        # raise ValueError(f"Block with id {block_id} not found")
+
+        # Recompile the agent memory
+        letta_agent.rebuild_memory(force=True, ms=self.ms)
+
+        # save agent
+        save_agent(letta_agent, self.ms)
+
+        updated_agent = self.ms.get_agent(agent_id=agent_id)
+        if updated_agent is None:
+            raise ValueError(f"Agent with id {agent_id} not found after linking block")
+        assert unlinked_block.label not in updated_agent.memory.list_block_labels()
+        return updated_agent.memory
+
+    def update_agent_memory_limit(self, user_id: str, agent_id: str, block_label: str, limit: int) -> Memory:
+        """Update the limit of a block in an agent's memory"""
+
+        # Get the user
+        user = self.user_manager.get_user_by_id(user_id=user_id)
+
+        # Link a block to an agent's memory
+        letta_agent = self._get_or_load_agent(agent_id=agent_id)
+        letta_agent.memory.update_block_limit(label=block_label, limit=limit)
+        assert block_label in letta_agent.memory.list_block_labels()
+
+        # write out the update the database
+        self.block_manager.create_or_update_block(block=letta_agent.memory.get_block(block_label), actor=user)
+
+        # check that the block was updated
+        updated_block = self.block_manager.get_block_by_id(block_id=letta_agent.memory.get_block(block_label).id, actor=user)
+        assert updated_block and updated_block.limit == limit
+
+        # Recompile the agent memory
+        letta_agent.rebuild_memory(force=True, ms=self.ms)
+
+        # save agent
+        save_agent(letta_agent, self.ms)
+
+        updated_agent = self.ms.get_agent(agent_id=agent_id)
+        if updated_agent is None:
+            raise ValueError(f"Agent with id {agent_id} not found after linking block")
+        assert updated_agent.memory.get_block(label=block_label).limit == limit
+        return updated_agent.memory

letta/services/block_manager.py

@@ -34,7 +34,7 @@ class BlockManager:
             return block.to_pydantic()
 
     @enforce_types
-    def update_block(self, block_id: str, block_update: BlockUpdate, actor: PydanticUser) -> PydanticBlock:
+    def update_block(self, block_id: str, block_update: BlockUpdate, actor: PydanticUser, limit: Optional[int] = None) -> PydanticBlock:
         """Update a block by its ID with the given BlockUpdate object."""
         with self.session_maker() as session:
             block = BlockModel.read(db_session=session, identifier=block_id, actor=actor)

{letta_nightly-0.5.3.dev20241121022151.dist-info → letta_nightly-0.5.4.dev20241122104229.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: letta-nightly
-Version: 0.5.3.dev20241121022151
+Version: 0.5.4.dev20241122104229
 Summary: Create LLM agents with long-term memory and custom tools
 License: Apache License
 Author: Letta Team
@@ -11,6 +11,7 @@ Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
+Provides-Extra: all
 Provides-Extra: autogen
 Provides-Extra: dev
 Provides-Extra: external-tools
@@ -21,48 +22,46 @@ Provides-Extra: qdrant
 Provides-Extra: server
 Provides-Extra: tests
 Requires-Dist: alembic (>=1.13.3,<2.0.0)
-Requires-Dist: autoflake (>=2.3.0,<3.0.0) ; extra == "dev"
-Requires-Dist: black[jupyter] (>=24.2.0,<25.0.0) ; extra == "dev"
+Requires-Dist: autoflake (>=2.3.0,<3.0.0) ; extra == "dev" or extra == "all"
+Requires-Dist: black[jupyter] (>=24.2.0,<25.0.0) ; extra == "dev" or extra == "all"
 Requires-Dist: chromadb (>=0.4.24,<0.5.0)
-Requires-Dist: composio-core (>=0.5.34,<0.6.0) ; extra == "external-tools"
-Requires-Dist: composio-langchain (>=0.5.28,<0.6.0) ; extra == "external-tools"
-Requires-Dist: crewai (>=0.41.1,<0.42.0) ; extra == "external-tools"
-Requires-Dist: crewai-tools (>=0.8.3,<0.9.0) ; extra == "external-tools"
-Requires-Dist: datasets (>=2.14.6,<3.0.0) ; extra == "dev"
+Requires-Dist: composio-core (>=0.5.34,<0.6.0) ; extra == "external-tools" or extra == "all"
+Requires-Dist: composio-langchain (>=0.5.28,<0.6.0) ; extra == "external-tools" or extra == "all"
+Requires-Dist: datasets (>=2.14.6,<3.0.0) ; extra == "dev" or extra == "all"
 Requires-Dist: demjson3 (>=3.0.6,<4.0.0)
-Requires-Dist: docker (>=7.1.0,<8.0.0) ; extra == "external-tools"
+Requires-Dist: docker (>=7.1.0,<8.0.0) ; extra == "external-tools" or extra == "all"
 Requires-Dist: docstring-parser (>=0.16,<0.17)
 Requires-Dist: docx2txt (>=0.8,<0.9)
-Requires-Dist: fastapi (>=0.104.1,<0.105.0) ; extra == "server"
+Requires-Dist: fastapi (>=0.104.1,<0.105.0) ; extra == "server" or extra == "all"
 Requires-Dist: html2text (>=2020.1.16,<2021.0.0)
 Requires-Dist: httpx (>=0.27.2,<0.28.0)
 Requires-Dist: httpx-sse (>=0.4.0,<0.5.0)
-Requires-Dist: isort (>=5.13.2,<6.0.0) ; extra == "dev"
+Requires-Dist: isort (>=5.13.2,<6.0.0) ; extra == "dev" or extra == "all"
 Requires-Dist: jinja2 (>=3.1.4,<4.0.0)
-Requires-Dist: langchain (>=0.2.16,<0.3.0) ; extra == "external-tools"
-Requires-Dist: langchain-community (>=0.2.17,<0.3.0) ; extra == "external-tools"
+Requires-Dist: langchain (>=0.3.7,<0.4.0) ; extra == "external-tools" or extra == "all"
+Requires-Dist: langchain-community (>=0.3.7,<0.4.0) ; extra == "external-tools" or extra == "all"
 Requires-Dist: llama-index (>=0.11.9,<0.12.0)
-Requires-Dist: llama-index-embeddings-ollama (>=0.3.1,<0.4.0) ; extra == "ollama"
+Requires-Dist: llama-index-embeddings-ollama (>=0.3.1,<0.4.0) ; extra == "ollama" or extra == "all"
 Requires-Dist: llama-index-embeddings-openai (>=0.2.5,<0.3.0)
-Requires-Dist: locust (>=2.31.5,<3.0.0)
+Requires-Dist: locust (>=2.31.5,<3.0.0) ; extra == "dev" or extra == "all"
 Requires-Dist: nltk (>=3.8.1,<4.0.0)
 Requires-Dist: numpy (>=1.26.2,<2.0.0)
 Requires-Dist: pathvalidate (>=3.2.1,<4.0.0)
-Requires-Dist: pexpect (>=4.9.0,<5.0.0) ; extra == "dev"
-Requires-Dist: pg8000 (>=1.30.3,<2.0.0) ; extra == "postgres"
-Requires-Dist: pgvector (>=0.2.3,<0.3.0) ; extra == "postgres"
-Requires-Dist: pre-commit (>=3.5.0,<4.0.0) ; extra == "dev"
+Requires-Dist: pexpect (>=4.9.0,<5.0.0) ; extra == "dev" or extra == "all"
+Requires-Dist: pg8000 (>=1.30.3,<2.0.0) ; extra == "postgres" or extra == "all"
+Requires-Dist: pgvector (>=0.2.3,<0.3.0) ; extra == "postgres" or extra == "all"
+Requires-Dist: pre-commit (>=3.5.0,<4.0.0) ; extra == "dev" or extra == "all"
 Requires-Dist: prettytable (>=3.9.0,<4.0.0)
-Requires-Dist: psycopg2 (>=2.9.10,<3.0.0) ; extra == "postgres"
-Requires-Dist: psycopg2-binary (>=2.9.10,<3.0.0) ; extra == "postgres"
+Requires-Dist: psycopg2 (>=2.9.10,<3.0.0) ; extra == "postgres" or extra == "all"
+Requires-Dist: psycopg2-binary (>=2.9.10,<3.0.0) ; extra == "postgres" or extra == "all"
 Requires-Dist: pyautogen (==0.2.22) ; extra == "autogen"
 Requires-Dist: pydantic (>=2.7.4,<2.10.0)
 Requires-Dist: pydantic-settings (>=2.2.1,<3.0.0)
 Requires-Dist: pyhumps (>=3.8.0,<4.0.0)
 Requires-Dist: pymilvus (>=2.4.3,<3.0.0) ; extra == "milvus"
-Requires-Dist: pyright (>=1.1.347,<2.0.0) ; extra == "dev"
-Requires-Dist: pytest-asyncio (>=0.23.2,<0.24.0) ; extra == "dev"
-Requires-Dist: pytest-order (>=1.2.0,<2.0.0) ; extra == "dev"
+Requires-Dist: pyright (>=1.1.347,<2.0.0) ; extra == "dev" or extra == "all"
+Requires-Dist: pytest-asyncio (>=0.23.2,<0.24.0) ; extra == "dev" or extra == "all"
+Requires-Dist: pytest-order (>=1.2.0,<2.0.0) ; extra == "dev" or extra == "all"
 Requires-Dist: python-box (>=7.1.1,<8.0.0)
 Requires-Dist: python-multipart (>=0.0.9,<0.0.10)
 Requires-Dist: pytz (>=2023.3.post1,<2024.0)
@@ -77,9 +76,9 @@ Requires-Dist: sqlmodel (>=0.0.16,<0.0.17)
 Requires-Dist: tiktoken (>=0.7.0,<0.8.0)
 Requires-Dist: tqdm (>=4.66.1,<5.0.0)
 Requires-Dist: typer[all] (>=0.9.0,<0.10.0)
-Requires-Dist: uvicorn (>=0.24.0.post1,<0.25.0) ; extra == "server"
-Requires-Dist: websockets (>=12.0,<13.0) ; extra == "server"
-Requires-Dist: wikipedia (>=1.4.0,<2.0.0) ; extra == "external-tools" or extra == "tests"
+Requires-Dist: uvicorn (>=0.24.0.post1,<0.25.0) ; extra == "server" or extra == "all"
+Requires-Dist: websockets (>=12.0,<13.0) ; extra == "server" or extra == "all"
+Requires-Dist: wikipedia (>=1.4.0,<2.0.0) ; extra == "external-tools" or extra == "tests" or extra == "all"
 Description-Content-Type: text/markdown
 
 <p align="center">

{letta_nightly-0.5.3.dev20241121022151.dist-info → letta_nightly-0.5.4.dev20241122104229.dist-info}/RECORD

@@ -1,6 +1,6 @@
-letta/__init__.py,sha256=xuSk7ZHRYiU9fZ-Evj64LtXe57rZnKi2vEC5j27YF7A,1014
+letta/__init__.py,sha256=lrj66PR9vRWLWUvQAgk4Qi8BebVsYk8J2poTTbuuBFQ,1014
 letta/__main__.py,sha256=6Hs2PV7EYc5Tid4g4OtcLXhqVHiNYTGzSBdoOnW2HXA,29
-letta/agent.py,sha256=Jirt5D89k3s91nsScfjsOTfx3SS_eAOF8iQvZ0I3hjM,77421
+letta/agent.py,sha256=7uc2v0mfAX46RdxPY-HIlfeO15mgBORfnr7bi84Ik4o,77430
 letta/agent_store/chroma.py,sha256=upR5zGnGs6I6btulEYbiZdGG87BgKjxUJOQZ4Y-RQ_M,12492
 letta/agent_store/db.py,sha256=dVBnNwVX57_kVdrD1oHnqze154QOoxWYSElJJUojyMs,23465
 letta/agent_store/lancedb.py,sha256=i63d4VZwj9UIOTNs5f0JZ_r5yZD-jKWz4FAH4RMpXOE,5104
@@ -13,7 +13,7 @@ letta/cli/cli.py,sha256=1dJIZ8DIGM8mg0G0UGLKMTa3fwgHzrN8Hkxd5Uxx7X4,16946
 letta/cli/cli_config.py,sha256=D-CpSZI1cDvdSQr3-zhGuDrJnZo1Ko7bi_wuxcBxxqo,8555
 letta/cli/cli_load.py,sha256=x4L8s15GwIW13xrhKYFWHo_y-IVGtoPDHWWKcHDRP10,4587
 letta/client/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-letta/client/client.py,sha256=1eLqzAUKoO63Ee_p4LjJjrlqmv4phUZc2MPMXhPpEw0,98717
+letta/client/client.py,sha256=GjSCpp7oy2e9SXcxRdFfsvGm0nmuYDO8yNB1yS7MWrE,102261
 letta/client/streaming.py,sha256=Hh5pjlyrdCuO2V75ZCxSSOCPd3BmHdKFGaIUJC6fBp0,4775
 letta/client/utils.py,sha256=OJlAKWrldc4I6M1WpcTWNtPJ4wfxlzlZqWLfCozkFtI,2872
 letta/config.py,sha256=eK-ip06ELHNYriInkgfidDvJxQ2tD1u49I-VLXB87nE,18929
@@ -27,7 +27,7 @@ letta/functions/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 letta/functions/function_sets/base.py,sha256=N4QmOjL6gDEyOg67ocF6zVKM-NquTo-yXG_T8r18buA,6440
 letta/functions/function_sets/extras.py,sha256=Jik3UiDqYTm4Lam1XPTvuVjvgUHwIAhopsnbmVhGMBg,4732
 letta/functions/functions.py,sha256=VyA_7O56KRUj88iuMkLJTRfascaTCj1qFGT0BnDgC6k,4140
-letta/functions/helpers.py,sha256=JU3e5xkkTVx4EevBmtyCRnidf0ncAeASvH2ZT_aBvPc,9905
+letta/functions/helpers.py,sha256=_GcgDLeR7YAGY0HIGxxM_EoXGFgWISZaX-FfS39nLGc,8682
 letta/functions/schema_generator.py,sha256=CoDZQfXsOKBp5VOv-024efcR833wyrchQbQIN7mL11A,8407
 letta/helpers/__init__.py,sha256=p0luQ1Oe3Skc6sH4O58aHHA3Qbkyjifpuq0DZ1GAY0U,59
 letta/helpers/tool_rule_solver.py,sha256=AZiUjW_oDlQx5uMI7oaL50KkI1InTW8qRkFdg6S54RQ,4744
@@ -85,7 +85,7 @@ letta/local_llm/webui/settings.py,sha256=gmLHfiOl1u4JmlAZU2d2O8YKF9lafdakyjwR_ft
 letta/log.py,sha256=Oy5b71AXfrnQShxI_4ULo5U3kmZJG01bXbP_64Nr4Fk,2105
 letta/main.py,sha256=cFnjnbzyrRRM5sZeRAnGVq_rPIgJRHRFyFNCY--sRI4,19163
 letta/memory.py,sha256=YupXOvzVJXH59RW4XWBrd7qMNEYaMbtWXCheKeWZwpU,17873
-letta/metadata.py,sha256=DoLXPfxqgWEWYpwg1B8g19Vae6v6jnljSwUr8wXEF3M,17620
+letta/metadata.py,sha256=jcvkzrCfSlmUbv5puCbeFP6cqM-Ct_U49C5WFLpYJ0s,18180
 letta/o1_agent.py,sha256=qYyAdLnKu7dQw6OxxsFQz32d-lLJLo64MnH165oQm7s,3180
 letta/openai_backcompat/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 letta/openai_backcompat/openai_object.py,sha256=Y1ZS1sATP60qxJiOsjOP3NbwSzuzvkNAvb3DeuhM5Uk,13490
@@ -131,7 +131,7 @@ letta/pytest.ini,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 letta/schemas/agent.py,sha256=f0khTBWIRGZva4_C15Nm_tkmn1cwaVQlWa7_7laRbEE,7866
 letta/schemas/agents_tags.py,sha256=9DGr8fN2DHYdWvZ_qcXmrKI0w7YKCGz2lfEcrX2KAkI,1130
 letta/schemas/api_key.py,sha256=u07yzzMn-hBAHZIIKbWY16KsgiFjSNR8lAghpMUo3_4,682
-letta/schemas/block.py,sha256=drnVWEmsx9NevCgq2STIxdSoCDPrp09Sy0Vq42Xbzz4,4315
+letta/schemas/block.py,sha256=4xYoyfLezvyjA7TN3c5AvPCyRh_Pz0_XVqVCwIaXoTo,4758
 letta/schemas/embedding_config.py,sha256=1kD6NpiXeH4roVumxqDAKk7xt8SpXGWNhZs_XXUSlEU,2855
 letta/schemas/enums.py,sha256=WfRYpLh_pD-VyhEnp3Y6pPfx063zq2o4jky6PulqO8w,629
 letta/schemas/file.py,sha256=ChN2CWzLI2TT9WLItcfElEH0E8b7kzPylF2OQBr6Beg,1550
@@ -142,7 +142,7 @@ letta/schemas/letta_message.py,sha256=RuVVtwFbi85yP3dXQxowofQ6cI2cO_CdGtgpHGQzgH
 letta/schemas/letta_request.py,sha256=_oiDshc_AoFWIfXRk2VX5-AxO5vDlyN-9r-gnyLj_30,1890
 letta/schemas/letta_response.py,sha256=li_j4VUF_WtxdJy7ufRmmmchzvhVmr1idbOxtgFGiy0,6253
 letta/schemas/llm_config.py,sha256=RbgnCaqYd_yl-Xs7t-DEI1NhpKD8WiVWjxcwq5mZd5M,4467
-letta/schemas/memory.py,sha256=fHkJZr8CrGcHhbJlckWgfRYMhLkRliKCU-hRxqr19ks,11725
+letta/schemas/memory.py,sha256=skuTu-aYpEs9Q76yINWLgmLFELG5m8-JdCeTjtR41rU,13192
 letta/schemas/message.py,sha256=DQxnRYrYgHXpTKfMzfS-bpCAe-BO_Rmcfc1Wf-4GHjw,33703
 letta/schemas/openai/chat_completion_request.py,sha256=AOIwgbN3CZKVqkuXeMHeSa53u4h0wVq69t3T_LJ0vIE,3389
 letta/schemas/openai/chat_completion_response.py,sha256=ub-oVSyLpuJd-5_yzCSIRR8tD3GM83IeDO1c1uAATa4,3970
@@ -152,7 +152,7 @@ letta/schemas/openai/openai.py,sha256=Hilo5BiLAGabzxCwnwfzK5QrWqwYD8epaEKFa4Pwnd
 letta/schemas/organization.py,sha256=d2oN3IK2HeruEHKXwIzCbJ3Fxdi_BEe9JZ8J9aDbHwQ,698
 letta/schemas/passage.py,sha256=eYQMxD_XjHAi72jmqcGBU4wM4VZtSU0XK8uhQxxN3Ug,3563
 letta/schemas/source.py,sha256=B1VbaDJV-EGPv1nQXwCx_RAzeAJd50UqP_1m1cIRT8c,2854
-letta/schemas/tool.py,sha256=HCUW4RXUS9RtvfpTPeNhauFN3s23BojSOceaIxv9bKI,9596
+letta/schemas/tool.py,sha256=Ehdl4fB1tLG-kgUTVD7MAhvSs_H_Tim2aROu0S0diB8,8083
 letta/schemas/tool_rule.py,sha256=zv4jE0b8LW78idP4UbJARnrZcnmaqjGNUk_YV99Y0c0,884
 letta/schemas/usage.py,sha256=lvn1ooHwLEdv6gwQpw5PBUbcwn_gwdT6HA-fCiix6sY,817
 letta/schemas/user.py,sha256=V32Tgl6oqB3KznkxUz12y7agkQicjzW7VocSpj78i6Q,1526
@@ -174,7 +174,7 @@ letta/server/rest_api/routers/openai/assistants/threads.py,sha256=WXVGBaBvSNPB7Z
 letta/server/rest_api/routers/openai/chat_completions/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 letta/server/rest_api/routers/openai/chat_completions/chat_completions.py,sha256=-uye6cm4SnoQGwxhr1N1FrSXOlnO2Hvbfj6k8JSc45k,4918
 letta/server/rest_api/routers/v1/__init__.py,sha256=sqlVZa-u9DJwdRsp0_8YUGrac9DHguIB4wETlEDRylA,666
-letta/server/rest_api/routers/v1/agents.py,sha256=bvlKgARwXWHq8_gJkiqYsU9ZXKBm2iDRTuosLnY8d9w,22043
+letta/server/rest_api/routers/v1/agents.py,sha256=yKpbqQauHHbvuV8IWgAPgri0lPmr6EWbYUx_C64RBGA,25541
 letta/server/rest_api/routers/v1/blocks.py,sha256=ogJdn-Ir7h1ZEv28bHtUNNsR2zq9-wxXAMpu2t1EoIA,2946
 letta/server/rest_api/routers/v1/health.py,sha256=pKCuVESlVOhGIb4VC4K-H82eZqfghmT6kvj2iOkkKuc,401
 letta/server/rest_api/routers/v1/jobs.py,sha256=a-j0v-5A0un0pVCOHpfeWnzpOWkVDQO6ti42k_qAlZY,2272
@@ -185,7 +185,7 @@ letta/server/rest_api/routers/v1/tools.py,sha256=Bkb9oKswOycj5S3fBeim7LpDrZf37Sy
 letta/server/rest_api/routers/v1/users.py,sha256=M1wEr2IyHzuRwINYxLXTkrbAH3osLe_cWjzrWrzR1aw,3729
 letta/server/rest_api/static_files.py,sha256=NG8sN4Z5EJ8JVQdj19tkFa9iQ1kBPTab9f_CUxd_u4Q,3143
 letta/server/rest_api/utils.py,sha256=GdHYCzXtbM5VCAYDPR0z5gnNZpRhwPld2BGZV7xT6cU,2924
-letta/server/server.py,sha256=hYlHYb93kjgtBvnQ6RoRstA80wTRfsKpSECVQVkgR7s,77287
+letta/server/server.py,sha256=uD7wO6f6iDZO1IUzAclIADpalhk-JrVNnzbVA1tt-YY,83736
 letta/server/startup.sh,sha256=wTOQOJJZw_Iec57WIu0UW0AVflk0ZMWYZWg8D3T_gSQ,698
 letta/server/static_files/assets/index-3ab03d5b.css,sha256=OrA9W4iKJ5h2Wlr7GwdAT4wow0CM8hVit1yOxEL49Qw,54295
 letta/server/static_files/assets/index-9fa459a2.js,sha256=j2oMcDJO9dWJaH5e-tsflbVpWK20gLWpZKJk4-Kuy6A,1815592
@@ -200,7 +200,7 @@ letta/server/ws_api/protocol.py,sha256=M_-gM5iuDBwa1cuN2IGNCG5GxMJwU2d3XW93XALv9
 letta/server/ws_api/server.py,sha256=C2Kv48PCwl46DQFb0ZP30s86KJLQ6dZk2AhWQEZn9pY,6004
 letta/services/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 letta/services/agents_tags_manager.py,sha256=zNqeXDpaf4dQ77jrRHiQfITdk4FawBzcND-9tWrj8gw,3127
-letta/services/block_manager.py,sha256=usUbUzHjQXtJ0GLAGlCVl3RgZeEaPz7BGMCjiF_2X4k,4439
+letta/services/block_manager.py,sha256=oxSeBTPILihcM65mZgvW9OD51z20wU232BFORxC-wlo,4468
 letta/services/organization_manager.py,sha256=OfE2_NMmhqXURX4sg7hCOiFQVQpV5ZiPu7J3sboCSYc,3555
 letta/services/source_manager.py,sha256=StX5Wfd7XSCKJet8qExIu3GMoI-eMIbEarAeTv2gq0s,6555
 letta/services/tool_manager.py,sha256=Vr2_JQ3TQUSPSPNbmGwY26HIFjYw0NhzJGgpMvS6GV8,8163
@@ -210,8 +210,8 @@ letta/streaming_interface.py,sha256=_FPUWy58j50evHcpXyd7zB1wWqeCc71NCFeWh_TBvnw,
 letta/streaming_utils.py,sha256=329fsvj1ZN0r0LpQtmMPZ2vSxkDBIUUwvGHZFkjm2I8,11745
 letta/system.py,sha256=buKYPqG5n2x41hVmWpu6JUpyd7vTWED9Km2_M7dLrvk,6960
 letta/utils.py,sha256=COwQLAt02eEM9tjp6p5kN8YeTqGXr714l5BvffLVCLU,32376
-letta_nightly-0.5.3.dev20241121022151.dist-info/LICENSE,sha256=mExtuZ_GYJgDEI38GWdiEYZizZS4KkVt2SF1g_GPNhI,10759
-letta_nightly-0.5.3.dev20241121022151.dist-info/METADATA,sha256=aZ1G_K6dHCtPcBzYou7tuKNzF8QEgntsnNvMYSHfbMQ,11070
-letta_nightly-0.5.3.dev20241121022151.dist-info/WHEEL,sha256=FMvqSimYX_P7y0a7UY-_Mc83r5zkBZsCYPm7Lr0Bsq4,88
-letta_nightly-0.5.3.dev20241121022151.dist-info/entry_points.txt,sha256=2zdiyGNEZGV5oYBuS-y2nAAgjDgcC9yM_mHJBFSRt5U,40
-letta_nightly-0.5.3.dev20241121022151.dist-info/RECORD,,
+letta_nightly-0.5.4.dev20241122104229.dist-info/LICENSE,sha256=mExtuZ_GYJgDEI38GWdiEYZizZS4KkVt2SF1g_GPNhI,10759
+letta_nightly-0.5.4.dev20241122104229.dist-info/METADATA,sha256=iD_Sb8bXV-LOgGdFN7FlJmO9h0Mwv8zuPhhqEErsUek,11395
+letta_nightly-0.5.4.dev20241122104229.dist-info/WHEEL,sha256=FMvqSimYX_P7y0a7UY-_Mc83r5zkBZsCYPm7Lr0Bsq4,88
+letta_nightly-0.5.4.dev20241122104229.dist-info/entry_points.txt,sha256=2zdiyGNEZGV5oYBuS-y2nAAgjDgcC9yM_mHJBFSRt5U,40
+letta_nightly-0.5.4.dev20241122104229.dist-info/RECORD,,