Skip to content

armgit / letta

Public Imported from GitHub
0

Platform for stateful agents: AI with advanced memory that can learn and self-improve over time.

feat: launch darkly modal flag (#6345)

jnjpngccafb2526821
diff --git a/letta/server/rest_api/dependencies.py b/letta/server/rest_api/dependencies.py
index 2bab4ed3f..fccc4a54e 100644
--- a/letta/server/rest_api/dependencies.py
+++ b/letta/server/rest_api/dependencies.py
@@ -13,6 +13,7 @@ class ExperimentalParams(BaseModel):
message_async: Optional[bool] = None
letta_v1_agent: Optional[bool] = None
letta_v1_agent_message_async: Optional[bool] = None
+ modal_sandbox: Optional[bool] = None
class HeaderParams(BaseModel):
@@ -33,6 +34,7 @@ def get_headers(
message_async: Optional[str] = Header(None, alias="X-Experimental-Message-Async"),
letta_v1_agent: Optional[str] = Header(None, alias="X-Experimental-Letta-V1-Agent"),
letta_v1_agent_message_async: Optional[str] = Header(None, alias="X-Experimental-Letta-V1-Agent-Message-Async"),
+ modal_sandbox: Optional[str] = Header(None, alias="X-Experimental-Modal-Sandbox"),
) -> HeaderParams:
"""Dependency injection function to extract common headers from requests."""
return HeaderParams(
@@ -44,6 +46,7 @@ def get_headers(
message_async=(message_async == "true") if message_async else None,
letta_v1_agent=(letta_v1_agent == "true") if letta_v1_agent else None,
letta_v1_agent_message_async=(letta_v1_agent_message_async == "true") if letta_v1_agent_message_async else None,
+ modal_sandbox=(modal_sandbox == "true") if modal_sandbox else None,
),
)
diff --git a/letta/server/rest_api/routers/v1/tools.py b/letta/server/rest_api/routers/v1/tools.py
index 16e8eab51..edd4c83ad 100644
--- a/letta/server/rest_api/routers/v1/tools.py
+++ b/letta/server/rest_api/routers/v1/tools.py
@@ -282,7 +282,10 @@ async def create_tool(
"""
actor = await server.user_manager.get_actor_or_default_async(actor_id=headers.actor_id)
tool = Tool(**request.model_dump(exclude_unset=True))
- return await server.tool_manager.create_or_update_tool_async(pydantic_tool=tool, actor=actor)
+ modal_sandbox_enabled = bool(headers.experimental_params.modal_sandbox) if headers.experimental_params else False
+ return await server.tool_manager.create_or_update_tool_async(
+ pydantic_tool=tool, actor=actor, modal_sandbox_enabled=modal_sandbox_enabled
+ )
@router.put("/", response_model=Tool, operation_id="upsert_tool")
@@ -295,7 +298,10 @@ async def upsert_tool(
Create or update a tool
"""
actor = await server.user_manager.get_actor_or_default_async(actor_id=headers.actor_id)
- tool = await server.tool_manager.create_or_update_tool_async(pydantic_tool=Tool(**request.model_dump(exclude_unset=True)), actor=actor)
+ modal_sandbox_enabled = bool(headers.experimental_params.modal_sandbox) if headers.experimental_params else False
+ tool = await server.tool_manager.create_or_update_tool_async(
+ pydantic_tool=Tool(**request.model_dump(exclude_unset=True)), actor=actor, modal_sandbox_enabled=modal_sandbox_enabled
+ )
return tool
@@ -310,7 +316,10 @@ async def modify_tool(
Update an existing tool
"""
actor = await server.user_manager.get_actor_or_default_async(actor_id=headers.actor_id)
- tool = await server.tool_manager.update_tool_by_id_async(tool_id=tool_id, tool_update=request, actor=actor)
+ modal_sandbox_enabled = bool(headers.experimental_params.modal_sandbox) if headers.experimental_params else False
+ tool = await server.tool_manager.update_tool_by_id_async(
+ tool_id=tool_id, tool_update=request, actor=actor, modal_sandbox_enabled=modal_sandbox_enabled
+ )
return tool
diff --git a/letta/services/tool_manager.py b/letta/services/tool_manager.py
index aa5764537..d69440978 100644
--- a/letta/services/tool_manager.py
+++ b/letta/services/tool_manager.py
@@ -197,7 +197,7 @@ class ToolManager:
@enforce_types
@trace_method
async def create_or_update_tool_async(
- self, pydantic_tool: PydanticTool, actor: PydanticUser, bypass_name_check: bool = False
+ self, pydantic_tool: PydanticTool, actor: PydanticUser, bypass_name_check: bool = False, modal_sandbox_enabled: bool = False
) -> PydanticTool:
"""Create a new tool based on the ToolCreate schema."""
if pydantic_tool.tool_type == ToolType.CUSTOM and not pydantic_tool.json_schema:
@@ -239,7 +239,11 @@ class ToolManager:
if "tool_type" in update_data:
updated_tool_type = update_data.get("tool_type")
tool = await self.update_tool_by_id_async(
- current_tool.id, ToolUpdate(**update_data), actor, updated_tool_type=updated_tool_type
+ current_tool.id,
+ ToolUpdate(**update_data),
+ actor,
+ updated_tool_type=updated_tool_type,
+ modal_sandbox_enabled=modal_sandbox_enabled,
)
else:
printd(
@@ -248,7 +252,7 @@ class ToolManager:
tool = await self.get_tool_by_id_async(current_tool.id, actor=actor)
return tool
- return await self.create_tool_async(pydantic_tool, actor=actor)
+ return await self.create_tool_async(pydantic_tool, actor=actor, modal_sandbox_enabled=modal_sandbox_enabled)
@enforce_types
async def create_mcp_server(
@@ -283,7 +287,9 @@ class ToolManager:
@enforce_types
@trace_method
- async def create_tool_async(self, pydantic_tool: PydanticTool, actor: PydanticUser) -> PydanticTool:
+ async def create_tool_async(
+ self, pydantic_tool: PydanticTool, actor: PydanticUser, modal_sandbox_enabled: bool = False
+ ) -> PydanticTool:
"""Create a new tool based on the ToolCreate schema."""
# Generate schema only if not provided (only for custom tools)
@@ -292,6 +298,12 @@ class ToolManager:
if pydantic_tool.description is None and pydantic_tool.json_schema:
pydantic_tool.description = pydantic_tool.json_schema.get("description", None)
+ # Add sandbox:modal to metadata if flag is enabled
+ if modal_sandbox_enabled:
+ if pydantic_tool.metadata_ is None:
+ pydantic_tool.metadata_ = {}
+ pydantic_tool.metadata_["sandbox"] = "modal"
+
# Add tool hash to metadata for Modal deployment tracking
tool_hash = compute_tool_hash(pydantic_tool)
if pydantic_tool.metadata_ is None:
@@ -704,6 +716,7 @@ class ToolManager:
actor: PydanticUser,
updated_tool_type: Optional[ToolType] = None,
bypass_name_check: bool = False,
+ modal_sandbox_enabled: bool = False,
) -> PydanticTool:
"""Update a tool by its ID with the given ToolUpdate object."""
# Fetch current tool early to allow conditional logic based on tool type
@@ -782,6 +795,26 @@ class ToolManager:
if updated_tool_type:
updated_tool_pydantic.tool_type = updated_tool_type
+ # Handle sandbox:modal metadata based on flag
+ if modal_sandbox_enabled:
+ # Add sandbox:modal to metadata if flag is enabled
+ if updated_tool_pydantic.metadata_ is None:
+ updated_tool_pydantic.metadata_ = {}
+ updated_tool_pydantic.metadata_["sandbox"] = "modal"
+ # Update the update_data to reflect this change if metadata was in the update
+ if "metadata_" not in update_data:
+ update_data["metadata_"] = updated_tool_pydantic.metadata_
+ else:
+ update_data["metadata_"]["sandbox"] = "modal"
+ else:
+ # Remove sandbox:modal from metadata if flag is not enabled
+ if updated_tool_pydantic.metadata_ and updated_tool_pydantic.metadata_.get("sandbox") == "modal":
+ updated_tool_pydantic.metadata_ = {k: v for k, v in updated_tool_pydantic.metadata_.items() if k != "sandbox"}
+ if not updated_tool_pydantic.metadata_: # If metadata becomes empty, set to None
+ updated_tool_pydantic.metadata_ = None
+ # Update the update_data to reflect this change
+ update_data["metadata_"] = updated_tool_pydantic.metadata_
+
# Check if we need to redeploy the Modal app due to changes
# Compute this before the session to avoid issues
tool_requests_modal = updated_tool_pydantic.metadata_ and updated_tool_pydantic.metadata_.get("sandbox") == "modal"
@@ -845,6 +878,19 @@ class ToolManager:
async with db_registry.async_session() as session:
try:
tool = await ToolModel.read_async(db_session=session, identifier=tool_id, actor=actor)
+ tool_pydantic = tool.to_pydantic()
+
+ # Check if tool had Modal deployment and delete it
+ tool_requests_modal = tool_pydantic.metadata_ and tool_pydantic.metadata_.get("sandbox") == "modal"
+ modal_configured = tool_settings.modal_sandbox_enabled
+
+ if tool_pydantic.tool_type == ToolType.CUSTOM and tool_requests_modal and modal_configured:
+ try:
+ await self.delete_modal_app(tool_pydantic, actor)
+ except Exception as e:
+ logger.warning(f"Failed to delete Modal app for tool {tool_pydantic.name}: {e}")
+ # Continue with tool deletion even if Modal cleanup fails
+
await tool.hard_delete_async(db_session=session, actor=actor)
except NoResultFound:
raise ValueError(f"Tool with id {tool_id} not found.")
@@ -1001,7 +1047,6 @@ class ToolManager:
tools.append(created_tool)
return tools
- # MODAL RELATED METHODS
@trace_method
async def create_or_update_modal_app(self, tool: PydanticTool, actor: PydanticUser):
"""Create a Modal app with the tool function registered"""
@@ -1046,3 +1091,24 @@ class ToolManager:
logger.warning(f"Failed to configure autoscaler for Modal function {modal_app.name}: {e}")
return deploy
+
+ async def delete_modal_app(self, tool: PydanticTool, actor: PydanticUser):
+ """Delete a Modal app deployment for the tool"""
+ try:
+ # Generate the app name for this tool
+ modal_app_name = generate_modal_function_name(tool.id, actor.organization_id)
+
+ # Try to delete the app
+ # TODO: we need to soft delete, and then potentially stop via the CLI, no programmatic way to delete currently
+ # try:
+ # app = modal.App.from_name(modal_app_name)
+ # await app.delete_async()
+ # logger.info(f"Deleted Modal app {modal_app_name} for tool {tool.name}")
+ # except modal.exception.NotFoundError:
+ # logger.info(f"Modal app {modal_app_name} not found, may have been already deleted")
+ # except Exception as e:
+ # logger.warning(f"Failed to delete Modal app {modal_app_name}: {e}")
+
+ except Exception as e:
+ logger.error(f"Error during Modal app deletion for tool {tool.name}: {e}")
+ raise