Platform for stateful agents: AI with advanced memory that can learn and self-improve over time.
feat: allow list tools by tool type [PRO-870] (#4036)
Shubham Naik6716f5b5e8bd
diff --git a/letta/server/rest_api/routers/v1/tools.py b/letta/server/rest_api/routers/v1/tools.pyindex 5b9cc0ea2..efd03b0b9 100644--- a/letta/server/rest_api/routers/v1/tools.py+++ b/letta/server/rest_api/routers/v1/tools.py@@ -27,7 +27,7 @@ from letta.log import get_loggerfrom letta.orm.errors import UniqueConstraintViolationErrorfrom letta.orm.mcp_oauth import OAuthSessionStatusfrom letta.prompts.gpt_system import get_system_text-from letta.schemas.enums import MessageRole+from letta.schemas.enums import MessageRole, ToolTypefrom letta.schemas.letta_message import ToolReturnMessagefrom letta.schemas.letta_message_content import TextContentfrom letta.schemas.mcp import UpdateSSEMCPServer, UpdateStdioMCPServer, UpdateStreamableHTTPMCPServer@@ -62,16 +62,94 @@ async def delete_tool(@router.get("/count", response_model=int, operation_id="count_tools")async def count_tools(+ name: Optional[str] = None,+ names: Optional[List[str]] = Query(None, description="Filter by specific tool names"),+ tool_ids: Optional[List[str]] = Query(+ None, description="Filter by specific tool IDs - accepts repeated params or comma-separated values"+ ),+ search: Optional[str] = Query(None, description="Search tool names (case-insensitive partial match)"),+ tool_types: Optional[List[str]] = Query(None, description="Filter by tool type(s) - accepts repeated params or comma-separated values"),+ exclude_tool_types: Optional[List[str]] = Query(+ None, description="Tool type(s) to exclude - accepts repeated params or comma-separated values"+ ),+ return_only_letta_tools: Optional[bool] = Query(False, description="Count only tools with tool_type starting with 'letta_'"),+ exclude_letta_tools: Optional[bool] = Query(False, description="Exclude built-in Letta tools from the count"),server: SyncServer = Depends(get_letta_server),actor_id: Optional[str] = Header(None, alias="user_id"),- include_base_tools: Optional[bool] = Query(False, description="Include built-in Letta tools in the count"),):"""Get a count of all tools available to agents belonging to the org of the user."""try:+ # Helper function to parse tool types - supports both repeated params and comma-separated values+ def parse_tool_types(tool_types_input: Optional[List[str]]) -> Optional[List[str]]:+ if tool_types_input is None:+ return None++ # Flatten any comma-separated values and validate against ToolType enum+ flattened_types = []+ for item in tool_types_input:+ # Split by comma in case user provided comma-separated values+ types_in_item = [t.strip() for t in item.split(",") if t.strip()]+ flattened_types.extend(types_in_item)++ # Validate each type against the ToolType enum+ valid_types = []+ valid_values = [tt.value for tt in ToolType]++ for tool_type in flattened_types:+ if tool_type not in valid_values:+ raise HTTPException(+ status_code=400, detail=f"Invalid tool_type '{tool_type}'. Must be one of: {', '.join(valid_values)}"+ )+ valid_types.append(tool_type)++ return valid_types if valid_types else None++ # Parse and validate tool types (same logic as list_tools)+ tool_types_str = parse_tool_types(tool_types)+ exclude_tool_types_str = parse_tool_types(exclude_tool_types)+actor = await server.user_manager.get_actor_or_default_async(actor_id=actor_id)- return await server.tool_manager.size_async(actor=actor, include_base_tools=include_base_tools)++ # Combine single name with names list for unified processing (same logic as list_tools)+ combined_names = []+ if name is not None:+ combined_names.append(name)+ if names is not None:+ combined_names.extend(names)++ # Use None if no names specified, otherwise use the combined list+ final_names = combined_names if combined_names else None++ # Helper function to parse tool IDs - supports both repeated params and comma-separated values+ def parse_tool_ids(tool_ids_input: Optional[List[str]]) -> Optional[List[str]]:+ if tool_ids_input is None:+ return None++ # Flatten any comma-separated values+ flattened_ids = []+ for item in tool_ids_input:+ # Split by comma in case user provided comma-separated values+ ids_in_item = [id.strip() for id in item.split(",") if id.strip()]+ flattened_ids.extend(ids_in_item)++ return flattened_ids if flattened_ids else None++ # Parse tool IDs (same logic as list_tools)+ final_tool_ids = parse_tool_ids(tool_ids)++ # Get the count of tools using unified query+ return await server.tool_manager.count_tools_async(+ actor=actor,+ tool_types=tool_types_str,+ exclude_tool_types=exclude_tool_types_str,+ names=final_names,+ tool_ids=final_tool_ids,+ search=search,+ return_only_letta_tools=return_only_letta_tools,+ exclude_letta_tools=exclude_letta_tools,+ )except Exception as e:print(f"Error occurred: {e}")raise HTTPException(status_code=500, detail=str(e))@@ -99,6 +177,16 @@ async def list_tools(after: Optional[str] = None,limit: Optional[int] = 50,name: Optional[str] = None,+ names: Optional[List[str]] = Query(None, description="Filter by specific tool names"),+ tool_ids: Optional[List[str]] = Query(+ None, description="Filter by specific tool IDs - accepts repeated params or comma-separated values"+ ),+ search: Optional[str] = Query(None, description="Search tool names (case-insensitive partial match)"),+ tool_types: Optional[List[str]] = Query(None, description="Filter by tool type(s) - accepts repeated params or comma-separated values"),+ exclude_tool_types: Optional[List[str]] = Query(+ None, description="Tool type(s) to exclude - accepts repeated params or comma-separated values"+ ),+ return_only_letta_tools: Optional[bool] = Query(False, description="Return only tools with tool_type starting with 'letta_'"),server: SyncServer = Depends(get_letta_server),actor_id: Optional[str] = Header(None, alias="user_id"), # Extract user_id from header, default to None if not present):@@ -106,13 +194,76 @@ async def list_tools(Get a list of all tools available to agents belonging to the org of the user"""try:+ # Helper function to parse tool types - supports both repeated params and comma-separated values+ def parse_tool_types(tool_types_input: Optional[List[str]]) -> Optional[List[str]]:+ if tool_types_input is None:+ return None++ # Flatten any comma-separated values and validate against ToolType enum+ flattened_types = []+ for item in tool_types_input:+ # Split by comma in case user provided comma-separated values+ types_in_item = [t.strip() for t in item.split(",") if t.strip()]+ flattened_types.extend(types_in_item)++ # Validate each type against the ToolType enum+ valid_types = []+ valid_values = [tt.value for tt in ToolType]++ for tool_type in flattened_types:+ if tool_type not in valid_values:+ raise HTTPException(+ status_code=400, detail=f"Invalid tool_type '{tool_type}'. Must be one of: {', '.join(valid_values)}"+ )+ valid_types.append(tool_type)++ return valid_types if valid_types else None++ # Parse and validate tool types+ tool_types_str = parse_tool_types(tool_types)+ exclude_tool_types_str = parse_tool_types(exclude_tool_types)+actor = await server.user_manager.get_actor_or_default_async(actor_id=actor_id)++ # Combine single name with names list for unified processing+ combined_names = []if name is not None:- tool = await server.tool_manager.get_tool_by_name_async(tool_name=name, actor=actor)- return [tool] if tool else []+ combined_names.append(name)+ if names is not None:+ combined_names.extend(names)- # Get the list of tools- return await server.tool_manager.list_tools_async(actor=actor, after=after, limit=limit)+ # Use None if no names specified, otherwise use the combined list+ final_names = combined_names if combined_names else None++ # Helper function to parse tool IDs - supports both repeated params and comma-separated values+ def parse_tool_ids(tool_ids_input: Optional[List[str]]) -> Optional[List[str]]:+ if tool_ids_input is None:+ return None++ # Flatten any comma-separated values+ flattened_ids = []+ for item in tool_ids_input:+ # Split by comma in case user provided comma-separated values+ ids_in_item = [id.strip() for id in item.split(",") if id.strip()]+ flattened_ids.extend(ids_in_item)++ return flattened_ids if flattened_ids else None++ # Parse tool IDs+ final_tool_ids = parse_tool_ids(tool_ids)++ # Get the list of tools using unified query+ return await server.tool_manager.list_tools_async(+ actor=actor,+ after=after,+ limit=limit,+ tool_types=tool_types_str,+ exclude_tool_types=exclude_tool_types_str,+ names=final_names,+ tool_ids=final_tool_ids,+ search=search,+ return_only_letta_tools=return_only_letta_tools,+ )except Exception as e:# Log or print the full exception here for debuggingprint(f"Error occurred: {e}")diff --git a/letta/services/tool_manager.py b/letta/services/tool_manager.pyindex 97aa6db98..011dd4a81 100644--- a/letta/services/tool_manager.py+++ b/letta/services/tool_manager.py@@ -2,7 +2,7 @@ import importlibimport warningsfrom typing import List, Optional, Set, Union-from sqlalchemy import func, select+from sqlalchemy import and_, func, or_, selectfrom letta.constants import (BASE_FUNCTION_RETURN_CHAR_LIMIT,@@ -319,10 +319,30 @@ class ToolManager:@enforce_types@trace_methodasync def list_tools_async(- self, actor: PydanticUser, after: Optional[str] = None, limit: Optional[int] = 50, upsert_base_tools: bool = True+ self,+ actor: PydanticUser,+ after: Optional[str] = None,+ limit: Optional[int] = 50,+ upsert_base_tools: bool = True,+ tool_types: Optional[List[str]] = None,+ exclude_tool_types: Optional[List[str]] = None,+ names: Optional[List[str]] = None,+ tool_ids: Optional[List[str]] = None,+ search: Optional[str] = None,+ return_only_letta_tools: bool = False,) -> List[PydanticTool]:"""List all tools with optional pagination."""- tools = await self._list_tools_async(actor=actor, after=after, limit=limit)+ tools = await self._list_tools_async(+ actor=actor,+ after=after,+ limit=limit,+ tool_types=tool_types,+ exclude_tool_types=exclude_tool_types,+ names=names,+ tool_ids=tool_ids,+ search=search,+ return_only_letta_tools=return_only_letta_tools,+ )# Check if all base tools are present if we requested all the tools w/o cursor# TODO: This is a temporary hack to resolve this issue@@ -337,22 +357,86 @@ class ToolManager:logger.info(f"Missing base tools detected: {missing_base_tools}. Upserting all base tools.")await self.upsert_base_tools_async(actor=actor)# Re-fetch the tools list after upserting base tools- tools = await self._list_tools_async(actor=actor, after=after, limit=limit)+ tools = await self._list_tools_async(+ actor=actor,+ after=after,+ limit=limit,+ tool_types=tool_types,+ exclude_tool_types=exclude_tool_types,+ names=names,+ tool_ids=tool_ids,+ search=search,+ return_only_letta_tools=return_only_letta_tools,+ )return tools@enforce_types@trace_method- async def _list_tools_async(self, actor: PydanticUser, after: Optional[str] = None, limit: Optional[int] = 50) -> List[PydanticTool]:+ async def _list_tools_async(+ self,+ actor: PydanticUser,+ after: Optional[str] = None,+ limit: Optional[int] = 50,+ tool_types: Optional[List[str]] = None,+ exclude_tool_types: Optional[List[str]] = None,+ names: Optional[List[str]] = None,+ tool_ids: Optional[List[str]] = None,+ search: Optional[str] = None,+ return_only_letta_tools: bool = False,+ ) -> List[PydanticTool]:"""List all tools with optional pagination."""tools_to_delete = []async with db_registry.async_session() as session:- tools = await ToolModel.list_async(- db_session=session,- after=after,- limit=limit,- organization_id=actor.organization_id,- )+ # Use SQLAlchemy directly for all cases - more control and consistency+ # Start with base query+ query = select(ToolModel).where(ToolModel.organization_id == actor.organization_id)++ # Apply tool_types filter+ if tool_types is not None:+ query = query.where(ToolModel.tool_type.in_(tool_types))++ # Apply names filter+ if names is not None:+ query = query.where(ToolModel.name.in_(names))++ # Apply tool_ids filter+ if tool_ids is not None:+ query = query.where(ToolModel.id.in_(tool_ids))++ # Apply search filter (ILIKE for case-insensitive partial match)+ if search is not None:+ query = query.where(ToolModel.name.ilike(f"%{search}%"))++ # Apply exclude_tool_types filter at database level+ if exclude_tool_types is not None:+ query = query.where(~ToolModel.tool_type.in_(exclude_tool_types))++ # Apply return_only_letta_tools filter at database level+ if return_only_letta_tools:+ query = query.where(ToolModel.tool_type.like("letta_%"))++ # Apply pagination if specified+ if after is not None:+ after_tool = await session.get(ToolModel, after)+ if after_tool:+ query = query.where(+ or_(+ ToolModel.created_at < after_tool.created_at,+ and_(ToolModel.created_at == after_tool.created_at, ToolModel.id < after_tool.id),+ )+ )++ # Apply limit+ if limit is not None:+ query = query.limit(limit)++ # Order by created_at and id for consistent pagination+ query = query.order_by(ToolModel.created_at.desc(), ToolModel.id.desc())++ # Execute query+ result = await session.execute(query)+ tools = list(result.scalars())# Remove any malformed toolsresults = []@@ -375,6 +459,61 @@ class ToolManager:return results+ @enforce_types+ @trace_method+ async def count_tools_async(+ self,+ actor: PydanticUser,+ tool_types: Optional[List[str]] = None,+ exclude_tool_types: Optional[List[str]] = None,+ names: Optional[List[str]] = None,+ tool_ids: Optional[List[str]] = None,+ search: Optional[str] = None,+ return_only_letta_tools: bool = False,+ exclude_letta_tools: bool = False,+ ) -> int:+ """Count tools with the same filtering logic as list_tools_async."""+ async with db_registry.async_session() as session:+ # Use SQLAlchemy directly with COUNT query - same filtering logic as list_tools_async+ # Start with base query+ query = select(func.count(ToolModel.id)).where(ToolModel.organization_id == actor.organization_id)++ # Apply tool_types filter+ if tool_types is not None:+ query = query.where(ToolModel.tool_type.in_(tool_types))++ # Apply names filter+ if names is not None:+ query = query.where(ToolModel.name.in_(names))++ # Apply tool_ids filter+ if tool_ids is not None:+ query = query.where(ToolModel.id.in_(tool_ids))++ # Apply search filter (ILIKE for case-insensitive partial match)+ if search is not None:+ query = query.where(ToolModel.name.ilike(f"%{search}%"))++ # Apply exclude_tool_types filter at database level+ if exclude_tool_types is not None:+ query = query.where(~ToolModel.tool_type.in_(exclude_tool_types))++ # Apply return_only_letta_tools filter at database level+ if return_only_letta_tools:+ query = query.where(ToolModel.tool_type.like("letta_%"))++ # Handle exclude_letta_tools logic (if True, exclude Letta tools)+ if exclude_letta_tools:+ # Exclude tools that are in the LETTA_TOOL_SET+ letta_tool_names = list(LETTA_TOOL_SET)+ query = query.where(~ToolModel.name.in_(letta_tool_names))++ # Execute count query+ result = await session.execute(query)+ count = result.scalar()++ return count or 0+@enforce_types@trace_methodasync def size_async(diff --git a/tests/test_managers.py b/tests/test_managers.pyindex 6700e3707..b1ebdfdf6 100644--- a/tests/test_managers.py+++ b/tests/test_managers.py@@ -4143,6 +4143,487 @@ async def test_list_tools(server: SyncServer, print_tool, default_user):assert any(t.id == print_tool.id for t in tools)+async def test_list_tools_with_tool_types(server: SyncServer, default_user):+ """Test filtering tools by tool_types parameter."""++ # create tools with different types+ def calculator_tool(a: int, b: int) -> int:+ """Add two numbers.++ Args:+ a: First number+ b: Second number++ Returns:+ Sum of a and b+ """+ return a + b++ def weather_tool(city: str) -> str:+ """Get weather for a city.++ Args:+ city: Name of the city++ Returns:+ Weather information+ """+ return f"Weather in {city}"++ # create custom tools+ custom_tool1 = PydanticTool(+ name="calculator",+ description="Math tool",+ source_code=parse_source_code(calculator_tool),+ source_type="python",+ tool_type=ToolType.CUSTOM,+ )+ custom_tool1.json_schema = derive_openai_json_schema(source_code=custom_tool1.source_code, name=custom_tool1.name)+ custom_tool1 = await server.tool_manager.create_or_update_tool_async(custom_tool1, actor=default_user)++ custom_tool2 = PydanticTool(+ name="weather",+ description="Weather tool",+ source_code=parse_source_code(weather_tool),+ source_type="python",+ tool_type=ToolType.CUSTOM,+ )+ custom_tool2.json_schema = derive_openai_json_schema(source_code=custom_tool2.source_code, name=custom_tool2.name)+ custom_tool2 = await server.tool_manager.create_or_update_tool_async(custom_tool2, actor=default_user)++ # test filtering by single tool type+ tools = await server.tool_manager.list_tools_async(actor=default_user, tool_types=[ToolType.CUSTOM.value], upsert_base_tools=False)+ assert len(tools) == 2+ assert all(t.tool_type == ToolType.CUSTOM for t in tools)++ # test filtering by multiple tool types (should get same result since we only have CUSTOM)+ tools = await server.tool_manager.list_tools_async(+ actor=default_user, tool_types=[ToolType.CUSTOM.value, ToolType.LETTA_CORE.value], upsert_base_tools=False+ )+ assert len(tools) == 2++ # test filtering by non-existent tool type+ tools = await server.tool_manager.list_tools_async(+ actor=default_user, tool_types=[ToolType.EXTERNAL_MCP.value], upsert_base_tools=False+ )+ assert len(tools) == 0+++async def test_list_tools_with_exclude_tool_types(server: SyncServer, default_user, print_tool):+ """Test excluding tools by exclude_tool_types parameter."""+ # we already have print_tool which is CUSTOM type++ # create a tool with a different type (simulate by updating tool type directly)+ def special_tool(msg: str) -> str:+ """Special tool.++ Args:+ msg: Message to return++ Returns:+ The message+ """+ return msg++ special = PydanticTool(+ name="special",+ description="Special tool",+ source_code=parse_source_code(special_tool),+ source_type="python",+ tool_type=ToolType.CUSTOM,+ )+ special.json_schema = derive_openai_json_schema(source_code=special.source_code, name=special.name)+ special = await server.tool_manager.create_or_update_tool_async(special, actor=default_user)++ # test excluding EXTERNAL_MCP (should get all tools since none are MCP)+ tools = await server.tool_manager.list_tools_async(+ actor=default_user, exclude_tool_types=[ToolType.EXTERNAL_MCP.value], upsert_base_tools=False+ )+ assert len(tools) == 2 # print_tool and special++ # test excluding CUSTOM (should get no tools)+ tools = await server.tool_manager.list_tools_async(+ actor=default_user, exclude_tool_types=[ToolType.CUSTOM.value], upsert_base_tools=False+ )+ assert len(tools) == 0+++async def test_list_tools_with_names(server: SyncServer, default_user):+ """Test filtering tools by names parameter."""++ # create tools with specific names+ def alpha_tool() -> str:+ """Alpha tool.++ Returns:+ Alpha string+ """+ return "alpha"++ def beta_tool() -> str:+ """Beta tool.++ Returns:+ Beta string+ """+ return "beta"++ def gamma_tool() -> str:+ """Gamma tool.++ Returns:+ Gamma string+ """+ return "gamma"++ alpha = PydanticTool(name="alpha_tool", description="Alpha", source_code=parse_source_code(alpha_tool), source_type="python")+ alpha.json_schema = derive_openai_json_schema(source_code=alpha.source_code, name=alpha.name)+ alpha = await server.tool_manager.create_or_update_tool_async(alpha, actor=default_user)++ beta = PydanticTool(name="beta_tool", description="Beta", source_code=parse_source_code(beta_tool), source_type="python")+ beta.json_schema = derive_openai_json_schema(source_code=beta.source_code, name=beta.name)+ beta = await server.tool_manager.create_or_update_tool_async(beta, actor=default_user)++ gamma = PydanticTool(name="gamma_tool", description="Gamma", source_code=parse_source_code(gamma_tool), source_type="python")+ gamma.json_schema = derive_openai_json_schema(source_code=gamma.source_code, name=gamma.name)+ gamma = await server.tool_manager.create_or_update_tool_async(gamma, actor=default_user)++ # test filtering by single name+ tools = await server.tool_manager.list_tools_async(actor=default_user, names=["alpha_tool"], upsert_base_tools=False)+ assert len(tools) == 1+ assert tools[0].name == "alpha_tool"++ # test filtering by multiple names+ tools = await server.tool_manager.list_tools_async(actor=default_user, names=["alpha_tool", "gamma_tool"], upsert_base_tools=False)+ assert len(tools) == 2+ assert set(t.name for t in tools) == {"alpha_tool", "gamma_tool"}++ # test filtering by non-existent name+ tools = await server.tool_manager.list_tools_async(actor=default_user, names=["non_existent_tool"], upsert_base_tools=False)+ assert len(tools) == 0+++async def test_list_tools_with_tool_ids(server: SyncServer, default_user):+ """Test filtering tools by tool_ids parameter."""++ # create multiple tools+ def tool1() -> str:+ """Tool 1.++ Returns:+ String 1+ """+ return "1"++ def tool2() -> str:+ """Tool 2.++ Returns:+ String 2+ """+ return "2"++ def tool3() -> str:+ """Tool 3.++ Returns:+ String 3+ """+ return "3"++ t1 = PydanticTool(name="tool1", description="First", source_code=parse_source_code(tool1), source_type="python")+ t1.json_schema = derive_openai_json_schema(source_code=t1.source_code, name=t1.name)+ t1 = await server.tool_manager.create_or_update_tool_async(t1, actor=default_user)++ t2 = PydanticTool(name="tool2", description="Second", source_code=parse_source_code(tool2), source_type="python")+ t2.json_schema = derive_openai_json_schema(source_code=t2.source_code, name=t2.name)+ t2 = await server.tool_manager.create_or_update_tool_async(t2, actor=default_user)++ t3 = PydanticTool(name="tool3", description="Third", source_code=parse_source_code(tool3), source_type="python")+ t3.json_schema = derive_openai_json_schema(source_code=t3.source_code, name=t3.name)+ t3 = await server.tool_manager.create_or_update_tool_async(t3, actor=default_user)++ # test filtering by single id+ tools = await server.tool_manager.list_tools_async(actor=default_user, tool_ids=[t1.id], upsert_base_tools=False)+ assert len(tools) == 1+ assert tools[0].id == t1.id++ # test filtering by multiple ids+ tools = await server.tool_manager.list_tools_async(actor=default_user, tool_ids=[t1.id, t3.id], upsert_base_tools=False)+ assert len(tools) == 2+ assert set(t.id for t in tools) == {t1.id, t3.id}++ # test filtering by non-existent id+ tools = await server.tool_manager.list_tools_async(actor=default_user, tool_ids=["non-existent-id"], upsert_base_tools=False)+ assert len(tools) == 0+++async def test_list_tools_with_search(server: SyncServer, default_user):+ """Test searching tools by partial name match."""++ # create tools with searchable names+ def calculator_add() -> str:+ """Calculator add.++ Returns:+ Add operation+ """+ return "add"++ def calculator_subtract() -> str:+ """Calculator subtract.++ Returns:+ Subtract operation+ """+ return "subtract"++ def weather_forecast() -> str:+ """Weather forecast.++ Returns:+ Forecast data+ """+ return "forecast"++ calc_add = PydanticTool(+ name="calculator_add", description="Add numbers", source_code=parse_source_code(calculator_add), source_type="python"+ )+ calc_add.json_schema = derive_openai_json_schema(source_code=calc_add.source_code, name=calc_add.name)+ calc_add = await server.tool_manager.create_or_update_tool_async(calc_add, actor=default_user)++ calc_sub = PydanticTool(+ name="calculator_subtract", description="Subtract numbers", source_code=parse_source_code(calculator_subtract), source_type="python"+ )+ calc_sub.json_schema = derive_openai_json_schema(source_code=calc_sub.source_code, name=calc_sub.name)+ calc_sub = await server.tool_manager.create_or_update_tool_async(calc_sub, actor=default_user)++ weather = PydanticTool(+ name="weather_forecast", description="Weather", source_code=parse_source_code(weather_forecast), source_type="python"+ )+ weather.json_schema = derive_openai_json_schema(source_code=weather.source_code, name=weather.name)+ weather = await server.tool_manager.create_or_update_tool_async(weather, actor=default_user)++ # test searching for "calculator" (should find both calculator tools)+ tools = await server.tool_manager.list_tools_async(actor=default_user, search="calculator", upsert_base_tools=False)+ assert len(tools) == 2+ assert all("calculator" in t.name for t in tools)++ # test case-insensitive search+ tools = await server.tool_manager.list_tools_async(actor=default_user, search="CALCULATOR", upsert_base_tools=False)+ assert len(tools) == 2++ # test partial match+ tools = await server.tool_manager.list_tools_async(actor=default_user, search="calc", upsert_base_tools=False)+ assert len(tools) == 2++ # test search with no matches+ tools = await server.tool_manager.list_tools_async(actor=default_user, search="nonexistent", upsert_base_tools=False)+ assert len(tools) == 0+++async def test_list_tools_return_only_letta_tools(server: SyncServer, default_user):+ """Test filtering for only Letta tools."""+ # first, upsert base tools to ensure we have Letta tools+ await server.tool_manager.upsert_base_tools_async(actor=default_user)++ # create a custom tool+ def custom_tool() -> str:+ """Custom tool.++ Returns:+ Custom string+ """+ return "custom"++ custom = PydanticTool(+ name="custom_tool",+ description="Custom",+ source_code=parse_source_code(custom_tool),+ source_type="python",+ tool_type=ToolType.CUSTOM,+ )+ custom.json_schema = derive_openai_json_schema(source_code=custom.source_code, name=custom.name)+ custom = await server.tool_manager.create_or_update_tool_async(custom, actor=default_user)++ # test without filter (should get custom tool + all letta tools)+ tools = await server.tool_manager.list_tools_async(actor=default_user, return_only_letta_tools=False, upsert_base_tools=False)+ # should have at least the custom tool and some letta tools+ assert len(tools) > 1+ assert any(t.name == "custom_tool" for t in tools)++ # test with filter (should only get letta tools)+ tools = await server.tool_manager.list_tools_async(actor=default_user, return_only_letta_tools=True, upsert_base_tools=False)+ assert len(tools) > 0+ # all tools should have tool_type starting with "letta_"+ assert all(t.tool_type.value.startswith("letta_") for t in tools)+ # custom tool should not be in the list+ assert not any(t.name == "custom_tool" for t in tools)+++async def test_list_tools_combined_filters(server: SyncServer, default_user):+ """Test combining multiple filters."""++ # create various tools+ def calc_add() -> str:+ """Calculator add.++ Returns:+ Add result+ """+ return "add"++ def calc_multiply() -> str:+ """Calculator multiply.++ Returns:+ Multiply result+ """+ return "multiply"++ def weather_tool() -> str:+ """Weather tool.++ Returns:+ Weather data+ """+ return "weather"++ calc1 = PydanticTool(+ name="calculator_add", description="Add", source_code=parse_source_code(calc_add), source_type="python", tool_type=ToolType.CUSTOM+ )+ calc1.json_schema = derive_openai_json_schema(source_code=calc1.source_code, name=calc1.name)+ calc1 = await server.tool_manager.create_or_update_tool_async(calc1, actor=default_user)++ calc2 = PydanticTool(+ name="calculator_multiply",+ description="Multiply",+ source_code=parse_source_code(calc_multiply),+ source_type="python",+ tool_type=ToolType.CUSTOM,+ )+ calc2.json_schema = derive_openai_json_schema(source_code=calc2.source_code, name=calc2.name)+ calc2 = await server.tool_manager.create_or_update_tool_async(calc2, actor=default_user)++ weather = PydanticTool(+ name="weather_current",+ description="Weather",+ source_code=parse_source_code(weather_tool),+ source_type="python",+ tool_type=ToolType.CUSTOM,+ )+ weather.json_schema = derive_openai_json_schema(source_code=weather.source_code, name=weather.name)+ weather = await server.tool_manager.create_or_update_tool_async(weather, actor=default_user)++ # combine search with tool_types+ tools = await server.tool_manager.list_tools_async(+ actor=default_user, search="calculator", tool_types=[ToolType.CUSTOM.value], upsert_base_tools=False+ )+ assert len(tools) == 2+ assert all("calculator" in t.name and t.tool_type == ToolType.CUSTOM for t in tools)++ # combine names with tool_ids+ tools = await server.tool_manager.list_tools_async(+ actor=default_user, names=["calculator_add"], tool_ids=[calc1.id], upsert_base_tools=False+ )+ assert len(tools) == 1+ assert tools[0].id == calc1.id++ # combine search with exclude_tool_types+ tools = await server.tool_manager.list_tools_async(+ actor=default_user, search="calculator", exclude_tool_types=[ToolType.EXTERNAL_MCP.value], upsert_base_tools=False+ )+ assert len(tools) == 2+++async def test_count_tools_async(server: SyncServer, default_user):+ """Test counting tools with various filters."""++ # create multiple tools+ def tool_a() -> str:+ """Tool A.++ Returns:+ String a+ """+ return "a"++ def tool_b() -> str:+ """Tool B.++ Returns:+ String b+ """+ return "b"++ def search_tool() -> str:+ """Search tool.++ Returns:+ Search result+ """+ return "search"++ ta = PydanticTool(+ name="tool_a", description="A", source_code=parse_source_code(tool_a), source_type="python", tool_type=ToolType.CUSTOM+ )+ ta.json_schema = derive_openai_json_schema(source_code=ta.source_code, name=ta.name)+ ta = await server.tool_manager.create_or_update_tool_async(ta, actor=default_user)++ tb = PydanticTool(+ name="tool_b", description="B", source_code=parse_source_code(tool_b), source_type="python", tool_type=ToolType.CUSTOM+ )+ tb.json_schema = derive_openai_json_schema(source_code=tb.source_code, name=tb.name)+ tb = await server.tool_manager.create_or_update_tool_async(tb, actor=default_user)++ # upsert base tools to ensure we have Letta tools for counting+ await server.tool_manager.upsert_base_tools_async(actor=default_user)++ # count all tools (should have 2 custom tools + letta tools)+ count = await server.tool_manager.count_tools_async(actor=default_user)+ assert count > 2 # at least our 2 custom tools + letta tools++ # count with tool_types filter+ count = await server.tool_manager.count_tools_async(actor=default_user, tool_types=[ToolType.CUSTOM.value])+ assert count == 2 # only our custom tools++ # count with search filter+ count = await server.tool_manager.count_tools_async(actor=default_user, search="tool")+ # should at least find our 2 tools (tool_a, tool_b)+ assert count >= 2++ # count with names filter+ count = await server.tool_manager.count_tools_async(actor=default_user, names=["tool_a", "tool_b"])+ assert count == 2++ # count with return_only_letta_tools+ count = await server.tool_manager.count_tools_async(actor=default_user, return_only_letta_tools=True)+ assert count > 0 # should have letta tools++ # count with exclude_tool_types (exclude all letta tool types)+ count = await server.tool_manager.count_tools_async(+ actor=default_user,+ exclude_tool_types=[+ ToolType.LETTA_CORE.value,+ ToolType.LETTA_MEMORY_CORE.value,+ ToolType.LETTA_MULTI_AGENT_CORE.value,+ ToolType.LETTA_SLEEPTIME_CORE.value,+ ToolType.LETTA_VOICE_SLEEPTIME_CORE.value,+ ToolType.LETTA_BUILTIN.value,+ ToolType.LETTA_FILES_CORE.value,+ ],+ )+ assert count == 2 # only our custom tools++def test_update_tool_by_id(server: SyncServer, print_tool, default_user):updated_description = "updated_description"return_char_limit = 10000