letta-nightly 0.5.4.dev20241121104201__py3-none-any.whl → 0.5.4.dev20241123104112__py3-none-any.whl

letta/agent.py

@@ -9,6 +9,7 @@ from tqdm import tqdm
 
 from letta.agent_store.storage import StorageConnector
 from letta.constants import (
+    BASE_TOOLS,
     CLI_WARNING_PREFIX,
     FIRST_MESSAGE_ATTEMPTS,
     FUNC_FAILED_HEARTBEAT_MESSAGE,
@@ -49,6 +50,7 @@ from letta.schemas.tool_rule import TerminalToolRule
 from letta.schemas.usage import LettaUsageStatistics
 from letta.services.block_manager import BlockManager
 from letta.services.source_manager import SourceManager
+from letta.services.tool_execution_sandbox import ToolExecutionSandbox
 from letta.services.user_manager import UserManager
 from letta.streaming_interface import StreamingRefreshCLIInterface
 from letta.system import (
@@ -725,9 +727,27 @@ class Agent(BaseAgent):
                     if isinstance(function_args[name], dict):
                         function_args[name] = spec[name](**function_args[name])
 
-                function_args["self"] = self  # need to attach self to arg since it's dynamically linked
+                # TODO: This needs to be rethought, how do we allow functions that modify agent state/db?
+                # TODO: There should probably be two types of tools: stateless/stateful
+
+                if function_name in BASE_TOOLS:
+                    function_args["self"] = self  # need to attach self to arg since it's dynamically linked
+                    function_response = function_to_call(**function_args)
+                else:
+                    # execute tool in a sandbox
+                    # TODO: allow agent_state to specify which sandbox to execute tools in
+                    sandbox_run_result = ToolExecutionSandbox(function_name, function_args, self.agent_state.user_id).run(
+                        agent_state=self.agent_state
+                    )
+                    function_response, updated_agent_state = sandbox_run_result.func_return, sandbox_run_result.agent_state
+                    # update agent state
+                    if self.agent_state != updated_agent_state and updated_agent_state is not None:
+                        self.agent_state = updated_agent_state
+                        self.memory = self.agent_state.memory  # TODO: don't duplicate
+
+                        # rebuild memory
+                        self.rebuild_memory()
 
-                function_response = function_to_call(**function_args)
                 if function_name in ["conversation_search", "conversation_search_date", "archival_memory_search"]:
                     # with certain functions we rely on the paging mechanism to handle overflow
                     truncate = False
@@ -747,6 +767,7 @@ class Agent(BaseAgent):
                 error_msg_user = f"{error_msg}\n{traceback.format_exc()}"
                 printd(error_msg_user)
                 function_response = package_function_response(False, error_msg)
+                # TODO: truncate error message somehow
                 messages.append(
                     Message.dict_to_message(
                         agent_id=self.agent_state.id,
@@ -1208,6 +1229,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 +1264,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
@@ -1281,7 +1305,6 @@ class Agent(BaseAgent):
         assert isinstance(new_system_prompt, str)
 
         if new_system_prompt == self.system:
-            input("same???")
             return
 
         self.system = new_system_prompt

letta/agent_store/db.py

@@ -433,7 +433,7 @@ class PostgresStorageConnector(SQLStorageConnector):
                 else:
                     db_record = self.db_model(**record.dict())
                     session.add(db_record)
-                    print(f"Added record with id {record.id}")
+                    # print(f"Added record with id {record.id}")
                     session.commit()
 
                 added_ids.append(record.id)

letta/client/client.py

@@ -39,6 +39,16 @@ from letta.schemas.message import Message, MessageCreate, UpdateMessage
 from letta.schemas.openai.chat_completions import ToolCall
 from letta.schemas.organization import Organization
 from letta.schemas.passage import Passage
+from letta.schemas.sandbox_config import (
+    E2BSandboxConfig,
+    LocalSandboxConfig,
+    SandboxConfig,
+    SandboxConfigCreate,
+    SandboxConfigUpdate,
+    SandboxEnvironmentVariable,
+    SandboxEnvironmentVariableCreate,
+    SandboxEnvironmentVariableUpdate,
+)
 from letta.schemas.source import Source, SourceCreate, SourceUpdate
 from letta.schemas.tool import Tool, ToolCreate, ToolUpdate
 from letta.schemas.tool_rule import BaseToolRule
@@ -190,9 +200,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
 
@@ -299,6 +306,112 @@ class AbstractClient(object):
     def delete_org(self, org_id: str) -> Organization:
         raise NotImplementedError
 
+    def create_sandbox_config(self, config: Union[LocalSandboxConfig, E2BSandboxConfig]) -> SandboxConfig:
+        """
+        Create a new sandbox configuration.
+
+        Args:
+            config (Union[LocalSandboxConfig, E2BSandboxConfig]): The sandbox settings.
+
+        Returns:
+            SandboxConfig: The created sandbox configuration.
+        """
+        raise NotImplementedError
+
+    def update_sandbox_config(self, sandbox_config_id: str, config: Union[LocalSandboxConfig, E2BSandboxConfig]) -> SandboxConfig:
+        """
+        Update an existing sandbox configuration.
+
+        Args:
+            sandbox_config_id (str): The ID of the sandbox configuration to update.
+            config (Union[LocalSandboxConfig, E2BSandboxConfig]): The updated sandbox settings.
+
+        Returns:
+            SandboxConfig: The updated sandbox configuration.
+        """
+        raise NotImplementedError
+
+    def delete_sandbox_config(self, sandbox_config_id: str) -> None:
+        """
+        Delete a sandbox configuration.
+
+        Args:
+            sandbox_config_id (str): The ID of the sandbox configuration to delete.
+        """
+        raise NotImplementedError
+
+    def list_sandbox_configs(self, limit: int = 50, cursor: Optional[str] = None) -> List[SandboxConfig]:
+        """
+        List all sandbox configurations.
+
+        Args:
+            limit (int, optional): The maximum number of sandbox configurations to return. Defaults to 50.
+            cursor (Optional[str], optional): The pagination cursor for retrieving the next set of results.
+
+        Returns:
+            List[SandboxConfig]: A list of sandbox configurations.
+        """
+        raise NotImplementedError
+
+    def create_sandbox_env_var(
+        self, sandbox_config_id: str, key: str, value: str, description: Optional[str] = None
+    ) -> SandboxEnvironmentVariable:
+        """
+        Create a new environment variable for a sandbox configuration.
+
+        Args:
+            sandbox_config_id (str): The ID of the sandbox configuration to associate the environment variable with.
+            key (str): The name of the environment variable.
+            value (str): The value of the environment variable.
+            description (Optional[str], optional): A description of the environment variable. Defaults to None.
+
+        Returns:
+            SandboxEnvironmentVariable: The created environment variable.
+        """
+        raise NotImplementedError
+
+    def update_sandbox_env_var(
+        self, env_var_id: str, key: Optional[str] = None, value: Optional[str] = None, description: Optional[str] = None
+    ) -> SandboxEnvironmentVariable:
+        """
+        Update an existing environment variable.
+
+        Args:
+            env_var_id (str): The ID of the environment variable to update.
+            key (Optional[str], optional): The updated name of the environment variable. Defaults to None.
+            value (Optional[str], optional): The updated value of the environment variable. Defaults to None.
+            description (Optional[str], optional): The updated description of the environment variable. Defaults to None.
+
+        Returns:
+            SandboxEnvironmentVariable: The updated environment variable.
+        """
+        raise NotImplementedError
+
+    def delete_sandbox_env_var(self, env_var_id: str) -> None:
+        """
+        Delete an environment variable by its ID.
+
+        Args:
+            env_var_id (str): The ID of the environment variable to delete.
+        """
+        raise NotImplementedError
+
+    def list_sandbox_env_vars(
+        self, sandbox_config_id: str, limit: int = 50, cursor: Optional[str] = None
+    ) -> List[SandboxEnvironmentVariable]:
+        """
+        List all environment variables associated with a sandbox configuration.
+
+        Args:
+            sandbox_config_id (str): The ID of the sandbox configuration to retrieve environment variables for.
+            limit (int, optional): The maximum number of environment variables to return. Defaults to 50.
+            cursor (Optional[str], optional): The pagination cursor for retrieving the next set of results.
+
+        Returns:
+            List[SandboxEnvironmentVariable]: A list of environment variables.
+        """
+        raise NotImplementedError
+
 
 class RESTClient(AbstractClient):
     """
@@ -899,8 +1012,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 +1681,161 @@ class RESTClient(AbstractClient):
         # Parse and return the deleted organization
         return Organization(**response.json())
 
+    def create_sandbox_config(self, config: Union[LocalSandboxConfig, E2BSandboxConfig]) -> SandboxConfig:
+        """
+        Create a new sandbox configuration.
+        """
+        payload = {
+            "config": config.model_dump(),
+        }
+        response = requests.post(f"{self.base_url}/{self.api_prefix}/sandbox-config", headers=self.headers, json=payload)
+        if response.status_code != 200:
+            raise ValueError(f"Failed to create sandbox config: {response.text}")
+        return SandboxConfig(**response.json())
+
+    def update_sandbox_config(self, sandbox_config_id: str, config: Union[LocalSandboxConfig, E2BSandboxConfig]) -> SandboxConfig:
+        """
+        Update an existing sandbox configuration.
+        """
+        payload = {
+            "config": config.model_dump(),
+        }
+        response = requests.patch(
+            f"{self.base_url}/{self.api_prefix}/sandbox-config/{sandbox_config_id}",
+            headers=self.headers,
+            json=payload,
+        )
+        if response.status_code != 200:
+            raise ValueError(f"Failed to update sandbox config with ID '{sandbox_config_id}': {response.text}")
+        return SandboxConfig(**response.json())
+
+    def delete_sandbox_config(self, sandbox_config_id: str) -> None:
+        """
+        Delete a sandbox configuration.
+        """
+        response = requests.delete(f"{self.base_url}/{self.api_prefix}/sandbox-config/{sandbox_config_id}", headers=self.headers)
+        if response.status_code == 404:
+            raise ValueError(f"Sandbox config with ID '{sandbox_config_id}' does not exist")
+        elif response.status_code != 204:
+            raise ValueError(f"Failed to delete sandbox config with ID '{sandbox_config_id}': {response.text}")
+
+    def list_sandbox_configs(self, limit: int = 50, cursor: Optional[str] = None) -> List[SandboxConfig]:
+        """
+        List all sandbox configurations.
+        """
+        params = {"limit": limit, "cursor": cursor}
+        response = requests.get(f"{self.base_url}/{self.api_prefix}/sandbox-config", headers=self.headers, params=params)
+        if response.status_code != 200:
+            raise ValueError(f"Failed to list sandbox configs: {response.text}")
+        return [SandboxConfig(**config_data) for config_data in response.json()]
+
+    def create_sandbox_env_var(
+        self, sandbox_config_id: str, key: str, value: str, description: Optional[str] = None
+    ) -> SandboxEnvironmentVariable:
+        """
+        Create a new environment variable for a sandbox configuration.
+        """
+        payload = {"key": key, "value": value, "description": description}
+        response = requests.post(
+            f"{self.base_url}/{self.api_prefix}/sandbox-config/{sandbox_config_id}/environment-variable",
+            headers=self.headers,
+            json=payload,
+        )
+        if response.status_code != 200:
+            raise ValueError(f"Failed to create environment variable for sandbox config ID '{sandbox_config_id}': {response.text}")
+        return SandboxEnvironmentVariable(**response.json())
+
+    def update_sandbox_env_var(
+        self, env_var_id: str, key: Optional[str] = None, value: Optional[str] = None, description: Optional[str] = None
+    ) -> SandboxEnvironmentVariable:
+        """
+        Update an existing environment variable.
+        """
+        payload = {k: v for k, v in {"key": key, "value": value, "description": description}.items() if v is not None}
+        response = requests.patch(
+            f"{self.base_url}/{self.api_prefix}/sandbox-config/environment-variable/{env_var_id}",
+            headers=self.headers,
+            json=payload,
+        )
+        if response.status_code != 200:
+            raise ValueError(f"Failed to update environment variable with ID '{env_var_id}': {response.text}")
+        return SandboxEnvironmentVariable(**response.json())
+
+    def delete_sandbox_env_var(self, env_var_id: str) -> None:
+        """
+        Delete an environment variable by its ID.
+        """
+        response = requests.delete(
+            f"{self.base_url}/{self.api_prefix}/sandbox-config/environment-variable/{env_var_id}", headers=self.headers
+        )
+        if response.status_code == 404:
+            raise ValueError(f"Environment variable with ID '{env_var_id}' does not exist")
+        elif response.status_code != 204:
+            raise ValueError(f"Failed to delete environment variable with ID '{env_var_id}': {response.text}")
+
+    def list_sandbox_env_vars(
+        self, sandbox_config_id: str, limit: int = 50, cursor: Optional[str] = None
+    ) -> List[SandboxEnvironmentVariable]:
+        """
+        List all environment variables associated with a sandbox configuration.
+        """
+        params = {"limit": limit, "cursor": cursor}
+        response = requests.get(
+            f"{self.base_url}/{self.api_prefix}/sandbox-config/{sandbox_config_id}/environment-variable",
+            headers=self.headers,
+            params=params,
+        )
+        if response.status_code != 200:
+            raise ValueError(f"Failed to list environment variables for sandbox config ID '{sandbox_config_id}': {response.text}")
+        return [SandboxEnvironmentVariable(**var_data) for var_data in 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 +2958,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 +2971,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 +3044,87 @@ 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 create_sandbox_config(self, config: Union[LocalSandboxConfig, E2BSandboxConfig]) -> SandboxConfig:
+        """
+        Create a new sandbox configuration.
+        """
+        config_create = SandboxConfigCreate(config=config)
+        return self.server.sandbox_config_manager.create_or_update_sandbox_config(sandbox_config_create=config_create, actor=self.user)
+
+    def update_sandbox_config(self, sandbox_config_id: str, config: Union[LocalSandboxConfig, E2BSandboxConfig]) -> SandboxConfig:
+        """
+        Update an existing sandbox configuration.
+        """
+        sandbox_update = SandboxConfigUpdate(config=config)
+        return self.server.sandbox_config_manager.update_sandbox_config(
+            sandbox_config_id=sandbox_config_id, sandbox_update=sandbox_update, actor=self.user
+        )
+
+    def delete_sandbox_config(self, sandbox_config_id: str) -> None:
+        """
+        Delete a sandbox configuration.
+        """
+        return self.server.sandbox_config_manager.delete_sandbox_config(sandbox_config_id=sandbox_config_id, actor=self.user)
+
+    def list_sandbox_configs(self, limit: int = 50, cursor: Optional[str] = None) -> List[SandboxConfig]:
+        """
+        List all sandbox configurations.
+        """
+        return self.server.sandbox_config_manager.list_sandbox_configs(actor=self.user, limit=limit, cursor=cursor)
+
+    def create_sandbox_env_var(
+        self, sandbox_config_id: str, key: str, value: str, description: Optional[str] = None
+    ) -> SandboxEnvironmentVariable:
+        """
+        Create a new environment variable for a sandbox configuration.
+        """
+        env_var_create = SandboxEnvironmentVariableCreate(key=key, value=value, description=description)
+        return self.server.sandbox_config_manager.create_sandbox_env_var(
+            env_var_create=env_var_create, sandbox_config_id=sandbox_config_id, actor=self.user
+        )
+
+    def update_sandbox_env_var(
+        self, env_var_id: str, key: Optional[str] = None, value: Optional[str] = None, description: Optional[str] = None
+    ) -> SandboxEnvironmentVariable:
+        """
+        Update an existing environment variable.
+        """
+        env_var_update = SandboxEnvironmentVariableUpdate(key=key, value=value, description=description)
+        return self.server.sandbox_config_manager.update_sandbox_env_var(
+            env_var_id=env_var_id, env_var_update=env_var_update, actor=self.user
+        )
+
+    def delete_sandbox_env_var(self, env_var_id: str) -> None:
+        """
+        Delete an environment variable by its ID.
+        """
+        return self.server.sandbox_config_manager.delete_sandbox_env_var(env_var_id=env_var_id, actor=self.user)
+
+    def list_sandbox_env_vars(
+        self, sandbox_config_id: str, limit: int = 50, cursor: Optional[str] = None
+    ) -> List[SandboxEnvironmentVariable]:
+        """
+        List all environment variables associated with a sandbox configuration.
+        """
+        return self.server.sandbox_config_manager.list_sandbox_env_vars(
+            sandbox_config_id=sandbox_config_id, actor=self.user, limit=limit, cursor=cursor
+        )
+
+    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/constants.py

@@ -36,14 +36,8 @@ DEFAULT_PERSONA = "sam_pov"
 DEFAULT_HUMAN = "basic"
 DEFAULT_PRESET = "memgpt_chat"
 
-# Tools
-BASE_TOOLS = [
-    "send_message",
-    "conversation_search",
-    "conversation_search_date",
-    "archival_memory_insert",
-    "archival_memory_search",
-]
+# Base tools that cannot be edited, as they access agent state directly
+BASE_TOOLS = ["send_message", "conversation_search", "conversation_search_date", "archival_memory_insert", "archival_memory_search"]
 
 # The name of the tool used to send message to the user
 # May not be relevant in cases where the agent has multiple ways to message to user (send_imessage, send_discord_mesasge, ...)
@@ -134,8 +128,9 @@ MESSAGE_SUMMARY_REQUEST_ACK = "Understood, I will respond with a summary of the
 MESSAGE_SUMMARY_TRUNC_KEEP_N_LAST = 3
 
 # Default memory limits
-CORE_MEMORY_PERSONA_CHAR_LIMIT = 2000
-CORE_MEMORY_HUMAN_CHAR_LIMIT = 2000
+CORE_MEMORY_PERSONA_CHAR_LIMIT: int = 5000
+CORE_MEMORY_HUMAN_CHAR_LIMIT: int = 5000
+CORE_MEMORY_BLOCK_CHAR_LIMIT: int = 5000
 
 # Function return limits
 FUNCTION_RETURN_CHAR_LIMIT = 6000  # ~300 words
@@ -155,9 +150,5 @@ FUNC_FAILED_HEARTBEAT_MESSAGE = f"{NON_USER_MSG_PREFIX}Function call failed, ret
 
 RETRIEVAL_QUERY_DEFAULT_PAGE_SIZE = 5
 
-# TODO Is this config or constant?
-CORE_MEMORY_PERSONA_CHAR_LIMIT: int = 2000
-CORE_MEMORY_HUMAN_CHAR_LIMIT: int = 2000
-
 MAX_FILENAME_LENGTH = 255
 RESERVED_FILENAMES = {"CON", "PRN", "AUX", "NUL", "COM1", "COM2", "LPT1", "LPT2"}