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

letta/schemas/memory.py

@@ -5,8 +5,9 @@ from pydantic import BaseModel, Field
 
 # Forward referencing to avoid circular import with Agent -> Memory -> Agent
 if TYPE_CHECKING:
-    from letta.agent import Agent
+    pass
 
+from letta.constants import CORE_MEMORY_BLOCK_CHAR_LIMIT
 from letta.schemas.block import Block
 from letta.schemas.message import Message
 from letta.schemas.openai.chat_completion_request import Tool
@@ -158,6 +159,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 +175,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):
@@ -196,7 +230,7 @@ class BasicBlockMemory(Memory):
             assert block.label is not None and block.label != "", "each existing chat block must have a name"
             self.link_block(block=block)
 
-    def core_memory_append(self: "Agent", label: str, content: str) -> Optional[str]:  # type: ignore
+    def core_memory_append(agent_state: "AgentState", label: str, content: str) -> Optional[str]:  # type: ignore
         """
         Append to the contents of core memory.
 
@@ -207,12 +241,12 @@ class BasicBlockMemory(Memory):
         Returns:
             Optional[str]: None is always returned as this function does not produce a response.
         """
-        current_value = str(self.memory.get_block(label).value)
+        current_value = str(agent_state.memory.get_block(label).value)
         new_value = current_value + "\n" + str(content)
-        self.memory.update_block_value(label=label, value=new_value)
+        agent_state.memory.update_block_value(label=label, value=new_value)
         return None
 
-    def core_memory_replace(self: "Agent", label: str, old_content: str, new_content: str) -> Optional[str]:  # type: ignore
+    def core_memory_replace(agent_state: "AgentState", label: str, old_content: str, new_content: str) -> Optional[str]:  # type: ignore
         """
         Replace the contents of core memory. To delete memories, use an empty string for new_content.
 
@@ -224,11 +258,11 @@ class BasicBlockMemory(Memory):
         Returns:
             Optional[str]: None is always returned as this function does not produce a response.
         """
-        current_value = str(self.memory.get_block(label).value)
+        current_value = str(agent_state.memory.get_block(label).value)
         if old_content not in current_value:
             raise ValueError(f"Old content '{old_content}' not found in memory block '{label}'")
         new_value = current_value.replace(str(old_content), str(new_content))
-        self.memory.update_block_value(label=label, value=new_value)
+        agent_state.memory.update_block_value(label=label, value=new_value)
         return None
 
 
@@ -237,7 +271,7 @@ class ChatMemory(BasicBlockMemory):
     ChatMemory initializes a BaseChatMemory with two default blocks, `human` and `persona`.
     """
 
-    def __init__(self, persona: str, human: str, limit: int = 2000):
+    def __init__(self, persona: str, human: str, limit: int = CORE_MEMORY_BLOCK_CHAR_LIMIT):
         """
         Initialize the ChatMemory object with a persona and human string.
 

letta/schemas/sandbox_config.py

@@ -0,0 +1,114 @@
+import hashlib
+import json
+from enum import Enum
+from typing import Any, Dict, List, Optional, Union
+
+from pydantic import BaseModel, Field
+
+from letta.schemas.agent import AgentState
+from letta.schemas.letta_base import LettaBase, OrmMetadataBase
+
+
+# Sandbox Config
+class SandboxType(str, Enum):
+    E2B = "e2b"
+    LOCAL = "local"
+
+
+class SandboxRunResult(BaseModel):
+    func_return: Optional[Any] = Field(None, description="The function return object")
+    agent_state: Optional[AgentState] = Field(None, description="The agent state")
+    stdout: Optional[List[str]] = Field(None, description="Captured stdout (e.g. prints, logs) from the function invocation")
+    sandbox_config_fingerprint: str = Field(None, description="The fingerprint of the config for the sandbox")
+
+
+class LocalSandboxConfig(BaseModel):
+    sandbox_dir: str = Field(..., description="Directory for the sandbox environment.")
+
+    @property
+    def type(self) -> "SandboxType":
+        return SandboxType.LOCAL
+
+
+class E2BSandboxConfig(BaseModel):
+    timeout: int = Field(5 * 60, description="Time limit for the sandbox (in seconds).")
+    template: Optional[str] = Field(None, description="The E2B template id (docker image).")
+    pip_requirements: Optional[List[str]] = Field(None, description="A list of pip packages to install on the E2B Sandbox")
+
+    @property
+    def type(self) -> "SandboxType":
+        return SandboxType.E2B
+
+
+class SandboxConfigBase(OrmMetadataBase):
+    __id_prefix__ = "sandbox"
+
+
+class SandboxConfig(SandboxConfigBase):
+    id: str = SandboxConfigBase.generate_id_field()
+    type: SandboxType = Field(None, description="The type of sandbox.")
+    organization_id: Optional[str] = Field(None, description="The unique identifier of the organization associated with the sandbox.")
+    config: Dict = Field(default_factory=lambda: {}, description="The JSON sandbox settings data.")
+
+    def get_e2b_config(self) -> E2BSandboxConfig:
+        return E2BSandboxConfig(**self.config)
+
+    def get_local_config(self) -> LocalSandboxConfig:
+        return LocalSandboxConfig(**self.config)
+
+    def fingerprint(self) -> str:
+        # Only take into account type, org_id, and the config items
+        # Canonicalize input data into JSON with sorted keys
+        hash_input = json.dumps(
+            {
+                "type": self.type.value,
+                "organization_id": self.organization_id,
+                "config": self.config,
+            },
+            sort_keys=True,  # Ensure stable ordering
+            separators=(",", ":"),  # Minimize serialization differences
+        )
+
+        # Compute SHA-256 hash
+        hash_digest = hashlib.sha256(hash_input.encode("utf-8")).digest()
+
+        # Convert the digest to an integer for compatibility with Python's hash requirements
+        return str(int.from_bytes(hash_digest, byteorder="big"))
+
+
+class SandboxConfigCreate(LettaBase):
+    config: Union[LocalSandboxConfig, E2BSandboxConfig] = Field(..., description="The configuration for the sandbox.")
+
+
+class SandboxConfigUpdate(LettaBase):
+    """Pydantic model for updating SandboxConfig fields."""
+
+    config: Union[LocalSandboxConfig, E2BSandboxConfig] = Field(None, description="The JSON configuration data for the sandbox.")
+
+
+# Environment Variable
+class SandboxEnvironmentVariableBase(OrmMetadataBase):
+    __id_prefix__ = "sandbox-env"
+
+
+class SandboxEnvironmentVariable(SandboxEnvironmentVariableBase):
+    id: str = SandboxEnvironmentVariableBase.generate_id_field()
+    key: str = Field(..., description="The name of the environment variable.")
+    value: str = Field(..., description="The value of the environment variable.")
+    description: Optional[str] = Field(None, description="An optional description of the environment variable.")
+    sandbox_config_id: str = Field(..., description="The ID of the sandbox config this environment variable belongs to.")
+    organization_id: Optional[str] = Field(None, description="The ID of the organization this environment variable belongs to.")
+
+
+class SandboxEnvironmentVariableCreate(LettaBase):
+    key: str = Field(..., description="The name of the environment variable.")
+    value: str = Field(..., description="The value of the environment variable.")
+    description: Optional[str] = Field(None, description="An optional description of the environment variable.")
+
+
+class SandboxEnvironmentVariableUpdate(LettaBase):
+    """Pydantic model for updating SandboxEnvironmentVariable fields."""
+
+    key: Optional[str] = Field(None, description="The name of the environment variable.")
+    value: Optional[str] = Field(None, description="The value of the environment variable.")
+    description: Optional[str] = Field(None, description="An optional description of the environment variable.")

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/__init__.py

@@ -3,15 +3,10 @@ from letta.server.rest_api.routers.v1.blocks import router as blocks_router
 from letta.server.rest_api.routers.v1.health import router as health_router
 from letta.server.rest_api.routers.v1.jobs import router as jobs_router
 from letta.server.rest_api.routers.v1.llms import router as llm_router
+from letta.server.rest_api.routers.v1.sandbox_configs import (
+    router as sandbox_configs_router,
+)
 from letta.server.rest_api.routers.v1.sources import router as sources_router
 from letta.server.rest_api.routers.v1.tools import router as tools_router
 
-ROUTERS = [
-    tools_router,
-    sources_router,
-    agents_router,
-    llm_router,
-    blocks_router,
-    jobs_router,
-    health_router,
-]
+ROUTERS = [tools_router, sources_router, agents_router, llm_router, blocks_router, jobs_router, health_router, sandbox_configs_router]

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/rest_api/routers/v1/sandbox_configs.py

@@ -0,0 +1,108 @@
+from typing import List, Optional
+
+from fastapi import APIRouter, Depends, Query
+
+from letta.schemas.sandbox_config import SandboxConfig as PydanticSandboxConfig
+from letta.schemas.sandbox_config import SandboxConfigCreate, SandboxConfigUpdate
+from letta.schemas.sandbox_config import SandboxEnvironmentVariable as PydanticEnvVar
+from letta.schemas.sandbox_config import (
+    SandboxEnvironmentVariableCreate,
+    SandboxEnvironmentVariableUpdate,
+)
+from letta.server.rest_api.utils import get_letta_server, get_user_id
+from letta.server.server import SyncServer
+
+router = APIRouter(prefix="/sandbox-config", tags=["sandbox-config"])
+
+
+### Sandbox Config Routes
+
+
+@router.post("/", response_model=PydanticSandboxConfig)
+def create_sandbox_config(
+    config_create: SandboxConfigCreate,
+    server: SyncServer = Depends(get_letta_server),
+    user_id: str = Depends(get_user_id),
+):
+    actor = server.get_user_or_default(user_id=user_id)
+
+    return server.sandbox_config_manager.create_or_update_sandbox_config(config_create, actor)
+
+
+@router.patch("/{sandbox_config_id}", response_model=PydanticSandboxConfig)
+def update_sandbox_config(
+    sandbox_config_id: str,
+    config_update: SandboxConfigUpdate,
+    server: SyncServer = Depends(get_letta_server),
+    user_id: str = Depends(get_user_id),
+):
+    actor = server.get_user_or_default(user_id=user_id)
+    return server.sandbox_config_manager.update_sandbox_config(sandbox_config_id, config_update, actor)
+
+
+@router.delete("/{sandbox_config_id}", status_code=204)
+def delete_sandbox_config(
+    sandbox_config_id: str,
+    server: SyncServer = Depends(get_letta_server),
+    user_id: str = Depends(get_user_id),
+):
+    actor = server.get_user_or_default(user_id=user_id)
+    server.sandbox_config_manager.delete_sandbox_config(sandbox_config_id, actor)
+
+
+@router.get("/", response_model=List[PydanticSandboxConfig])
+def list_sandbox_configs(
+    limit: int = Query(1000, description="Number of results to return"),
+    cursor: Optional[str] = Query(None, description="Pagination cursor to fetch the next set of results"),
+    server: SyncServer = Depends(get_letta_server),
+    user_id: str = Depends(get_user_id),
+):
+    actor = server.get_user_or_default(user_id=user_id)
+    return server.sandbox_config_manager.list_sandbox_configs(actor, limit=limit, cursor=cursor)
+
+
+### Sandbox Environment Variable Routes
+
+
+@router.post("/{sandbox_config_id}/environment-variable", response_model=PydanticEnvVar)
+def create_sandbox_env_var(
+    sandbox_config_id: str,
+    env_var_create: SandboxEnvironmentVariableCreate,
+    server: SyncServer = Depends(get_letta_server),
+    user_id: str = Depends(get_user_id),
+):
+    actor = server.get_user_or_default(user_id=user_id)
+    return server.sandbox_config_manager.create_sandbox_env_var(env_var_create, sandbox_config_id, actor)
+
+
+@router.patch("/environment-variable/{env_var_id}", response_model=PydanticEnvVar)
+def update_sandbox_env_var(
+    env_var_id: str,
+    env_var_update: SandboxEnvironmentVariableUpdate,
+    server: SyncServer = Depends(get_letta_server),
+    user_id: str = Depends(get_user_id),
+):
+    actor = server.get_user_or_default(user_id=user_id)
+    return server.sandbox_config_manager.update_sandbox_env_var(env_var_id, env_var_update, actor)
+
+
+@router.delete("/environment-variable/{env_var_id}", status_code=204)
+def delete_sandbox_env_var(
+    env_var_id: str,
+    server: SyncServer = Depends(get_letta_server),
+    user_id: str = Depends(get_user_id),
+):
+    actor = server.get_user_or_default(user_id=user_id)
+    server.sandbox_config_manager.delete_sandbox_env_var(env_var_id, actor)
+
+
+@router.get("/{sandbox_config_id}/environment-variable", response_model=List[PydanticEnvVar])
+def list_sandbox_env_vars(
+    sandbox_config_id: str,
+    limit: int = Query(1000, description="Number of results to return"),
+    cursor: Optional[str] = Query(None, description="Pagination cursor to fetch the next set of results"),
+    server: SyncServer = Depends(get_letta_server),
+    user_id: str = Depends(get_user_id),
+):
+    actor = server.get_user_or_default(user_id=user_id)
+    return server.sandbox_config_manager.list_sandbox_env_vars(sandbox_config_id, actor, limit=limit, cursor=cursor)

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

@@ -2,7 +2,6 @@ from typing import List, Optional
 
 from fastapi import APIRouter, Body, Depends, Header, HTTPException
 
-from letta.orm.errors import NoResultFound
 from letta.schemas.tool import Tool, ToolCreate, ToolUpdate
 from letta.server.rest_api.utils import get_letta_server
 from letta.server.server import SyncServer
@@ -49,11 +48,10 @@ def get_tool_id(
     Get a tool ID by name
     """
     actor = server.get_user_or_default(user_id=user_id)
-
-    try:
-        tool = server.tool_manager.get_tool_by_name(tool_name=tool_name, actor=actor)
+    tool = server.tool_manager.get_tool_by_name(tool_name=tool_name, actor=actor)
+    if tool:
         return tool.id
-    except NoResultFound:
+    else:
         raise HTTPException(status_code=404, detail=f"Tool with name {tool_name} and organization id {actor.organization_id} not found.")
 
 

letta/server/rest_api/utils.py

@@ -5,6 +5,7 @@ import warnings
 from enum import Enum
 from typing import AsyncGenerator, Optional, Union
 
+from fastapi import Header
 from pydantic import BaseModel
 
 from letta.schemas.usage import LettaUsageStatistics
@@ -84,5 +85,10 @@ def get_letta_server() -> SyncServer:
     return server
 
 
+# Dependency to get user_id from headers
+def get_user_id(user_id: Optional[str] = Header(None, alias="user_id")) -> Optional[str]:
+    return user_id
+
+
 def get_current_interface() -> StreamingServerInterface:
     return StreamingServerInterface