letta-nightly 0.11.6.dev20250902104140__py3-none-any.whl → 0.11.7.dev20250904045700__py3-none-any.whl

letta/services/tool_manager.py

@@ -1,9 +1,8 @@
 import importlib
-import os
 import warnings
 from typing import List, Optional, Set, Union
 
-from sqlalchemy import func, select
+from sqlalchemy import and_, func, or_, select
 
 from letta.constants import (
     BASE_FUNCTION_RETURN_CHAR_LIMIT,
@@ -19,7 +18,7 @@ from letta.constants import (
     LOCAL_ONLY_MULTI_AGENT_TOOLS,
     MCP_TOOL_TAG_NAME_PREFIX,
 )
-from letta.errors import LettaToolNameConflictError
+from letta.errors import LettaToolNameConflictError, LettaToolNameSchemaMismatchError
 from letta.functions.functions import derive_openai_json_schema, load_function_set
 from letta.log import get_logger
 
@@ -28,8 +27,7 @@ from letta.orm.errors import NoResultFound
 from letta.orm.tool import Tool as ToolModel
 from letta.otel.tracing import trace_method
 from letta.schemas.enums import ToolType
-from letta.schemas.tool import Tool as PydanticTool
-from letta.schemas.tool import ToolCreate, ToolUpdate
+from letta.schemas.tool import Tool as PydanticTool, ToolCreate, ToolUpdate
 from letta.schemas.user import User as PydanticUser
 from letta.server.db import db_registry
 from letta.services.helpers.agent_manager_helper import calculate_multi_agent_tools
@@ -321,19 +319,37 @@ class ToolManager:
     @enforce_types
     @trace_method
     async 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
         # TODO: This requires a deeper rethink about how we keep all our internal tools up-to-date
         if not after and upsert_base_tools:
             existing_tool_names = {tool.name for tool in tools}
-            base_tool_names = (
-                LETTA_TOOL_SET - set(LOCAL_ONLY_MULTI_AGENT_TOOLS) if os.getenv("LETTA_ENVIRONMENT") == "PRODUCTION" else LETTA_TOOL_SET
-            )
+            base_tool_names = LETTA_TOOL_SET - set(LOCAL_ONLY_MULTI_AGENT_TOOLS) if settings.environment == "PRODUCTION" else LETTA_TOOL_SET
             missing_base_tools = base_tool_names - existing_tool_names
 
             # If any base tools are missing, upsert all base tools
@@ -341,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 tools
             results = []
@@ -379,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_method
     async def size_async(
@@ -406,6 +541,7 @@ class ToolManager:
         updated_tool_type: Optional[ToolType] = None,
         bypass_name_check: bool = False,
     ) -> PydanticTool:
+        # TODO: remove this (legacy non-async)
         """
         Update a tool with complex validation and schema derivation logic.
 
@@ -522,55 +658,36 @@ class ToolManager:
         # Fetch current tool early to allow conditional logic based on tool type
         current_tool = await self.get_tool_by_id_async(tool_id=tool_id, actor=actor)
 
-        # For MCP tools, do NOT derive schema from Python source. Trust provided JSON schema.
-        if current_tool.tool_type == ToolType.EXTERNAL_MCP:
-            # Prefer provided json_schema; fall back to current
-            if "json_schema" in update_data:
-                new_schema = update_data["json_schema"].copy()
-                new_name = new_schema.get("name", current_tool.name)
-            else:
-                new_schema = current_tool.json_schema
-                new_name = current_tool.name
-            # Ensure we don't trigger derive
-            update_data.pop("source_code", None)
-            # If name changes, enforce uniqueness
-            if new_name != current_tool.name:
-                name_exists = await self.tool_name_exists_async(tool_name=new_name, actor=actor)
-                if name_exists:
-                    raise LettaToolNameConflictError(tool_name=new_name)
+        # Do NOT derive schema from Python source. Trust provided JSON schema.
+        # Prefer provided json_schema; fall back to current
+        if "json_schema" in update_data:
+            new_schema = update_data["json_schema"].copy()
+            new_name = new_schema.get("name", current_tool.name)
         else:
-            # For non-MCP tools, preserve existing behavior
-            # TODO: Consider this behavior...is this what we want?
-            # TODO: I feel like it's bad if json_schema strays from source code so
-            # if source code is provided, always derive the name from it
-            if "source_code" in update_data.keys() and not bypass_name_check:
-                # Check source type to use appropriate parser
-                source_type = update_data.get("source_type", current_tool.source_type)
-                if source_type == "typescript":
-                    from letta.functions.typescript_parser import derive_typescript_json_schema
+            new_schema = current_tool.json_schema
+            new_name = current_tool.name
 
-                    derived_schema = derive_typescript_json_schema(source_code=update_data["source_code"])
-                else:
-                    # Default to Python for backwards compatibility
-                    derived_schema = derive_openai_json_schema(source_code=update_data["source_code"])
-                new_name = derived_schema["name"]
-
-                # if json_schema wasn't provided, use the derived schema
-                if "json_schema" not in update_data.keys():
-                    new_schema = derived_schema
-                else:
-                    # if json_schema was provided, update only its name to match the source code
-                    new_schema = update_data["json_schema"].copy()
-                    new_schema["name"] = new_name
-                    # update the json_schema in update_data so it gets applied in the loop
-                    update_data["json_schema"] = new_schema
+        # original tool may no have a JSON schema at all for legacy reasons
+        # in this case, fallback to dangerous schema generation
+        if new_schema is None:
+            if source_type == "typescript":
+                from letta.functions.typescript_parser import derive_typescript_json_schema
 
-                # check if the name is changing and if so, verify it doesn't conflict
-                if new_name != current_tool.name:
-                    # check if a tool with the new name already exists
-                    name_exists = await self.tool_name_exists_async(tool_name=new_name, actor=actor)
-                    if name_exists:
-                        raise LettaToolNameConflictError(tool_name=new_name)
+                new_schema = derive_typescript_json_schema(source_code=update_data["source_code"])
+            else:
+                new_schema = derive_openai_json_schema(source_code=update_data["source_code"])
+
+        # If name changes, enforce uniqueness
+        if new_name != current_tool.name:
+            name_exists = await self.tool_name_exists_async(tool_name=new_name, actor=actor)
+            if name_exists:
+                raise LettaToolNameConflictError(tool_name=new_name)
+
+        # NOTE: EXTREMELEY HACKY, we need to stop making assumptions about the source_code
+        if "source_code" in update_data and f"def {new_name}" not in update_data.get("source_code", ""):
+            raise LettaToolNameSchemaMismatchError(
+                tool_name=new_name, json_schema_name=new_schema.get("name"), source_code=update_data.get("source_code")
+            )
 
         # Now perform the update within the session
         async with db_registry.async_session() as session:

letta/services/tool_sandbox/modal_deployment_manager.py

@@ -183,9 +183,9 @@ class ModalDeploymentManager:
                 existing_app = await self._try_get_existing_app(sbx_config, version_hash, user)
                 if existing_app:
                     return existing_app, version_hash
-                raise RuntimeError(f"Deployment completed but app not found")
+                raise RuntimeError("Deployment completed but app not found")
             else:
-                raise RuntimeError(f"Timeout waiting for deployment")
+                raise RuntimeError("Timeout waiting for deployment")
 
         # We're deploying - mark as in progress
         deployment_key = None

letta/services/user_manager.py

@@ -10,8 +10,7 @@ from letta.orm.errors import NoResultFound
 from letta.orm.organization import Organization as OrganizationModel
 from letta.orm.user import User as UserModel
 from letta.otel.tracing import trace_method
-from letta.schemas.user import User as PydanticUser
-from letta.schemas.user import UserUpdate
+from letta.schemas.user import User as PydanticUser, UserUpdate
 from letta.server.db import db_registry
 from letta.utils import enforce_types
 

letta/settings.py

@@ -23,7 +23,7 @@ class ToolSettings(BaseSettings):
 
     # Search Providers
     tavily_api_key: str | None = Field(default=None, description="API key for using Tavily as a search provider.")
-    firecrawl_api_key: str | None = Field(default=None, description="API key for using Firecrawl as a search provider.")
+    exa_api_key: str | None = Field(default=None, description="API key for using Exa as a search provider.")
 
     # Local Sandbox configurations
     tool_exec_dir: Optional[str] = None
@@ -89,7 +89,6 @@ class SummarizerSettings(BaseSettings):
 
 
 class ModelSettings(BaseSettings):
-
     model_config = SettingsConfigDict(env_file=".env", extra="ignore")
 
     global_max_context_window_limit: int = 32000
@@ -146,6 +145,7 @@ class ModelSettings(BaseSettings):
     gemini_api_key: Optional[str] = None
     gemini_base_url: str = "https://generativelanguage.googleapis.com/"
     gemini_force_minimum_thinking_budget: bool = False
+    gemini_max_retries: int = 5
 
     # google vertex
     google_cloud_project: Optional[str] = None
@@ -205,6 +205,7 @@ class Settings(BaseSettings):
     letta_dir: Optional[Path] = Field(Path.home() / ".letta", alias="LETTA_DIR")
     debug: Optional[bool] = False
     cors_origins: Optional[list] = cors_origins
+    environment: Optional[str] = Field(default=None, description="Application environment (PRODUCTION, DEV, etc.)")
 
     # SSE Streaming keepalive settings
     enable_keepalive: bool = Field(True, description="Enable keepalive messages in SSE streams to prevent timeouts")
@@ -299,7 +300,8 @@ class Settings(BaseSettings):
     # For tpuf - currently only for archival memories
     use_tpuf: bool = False
     tpuf_api_key: Optional[str] = None
-    tpuf_region: str = "gcp-us-central1.turbopuffer.com"
+    tpuf_region: str = "gcp-us-central1"
+    embed_all_messages: bool = False
 
     # File processing timeout settings
     file_processing_timeout_minutes: int = 30

letta/streaming_interface.py

@@ -117,9 +117,9 @@ class StreamingCLIInterface(AgentChunkStreamingInterface):
 
         # Starting a new buffer line
         if not self.streaming_buffer_type:
-            assert not (
-                message_delta.content is not None and message_delta.tool_calls is not None and len(message_delta.tool_calls)
-            ), f"Error: got both content and tool_calls in message stream\n{message_delta}"
+            assert not (message_delta.content is not None and message_delta.tool_calls is not None and len(message_delta.tool_calls)), (
+                f"Error: got both content and tool_calls in message stream\n{message_delta}"
+            )
 
             if message_delta.content is not None:
                 # Write out the prefix for inner thoughts

letta/system.py

@@ -187,7 +187,7 @@ def package_summarize_message(summary, summary_message_count, hidden_message_cou
 
 def package_summarize_message_no_counts(summary, timezone):
     context_message = (
-        f"Note: prior messages have been hidden from view due to conversation memory constraints.\n"
+        "Note: prior messages have been hidden from view due to conversation memory constraints.\n"
         + f"The following is a summary of the previous messages:\n {summary}"
     )
 

letta/utils.py

@@ -1149,7 +1149,6 @@ class CancellationSignal:
     """
 
     def __init__(self, job_manager=None, job_id=None, actor=None):
-
         from letta.log import get_logger
         from letta.schemas.user import User
         from letta.services.job_manager import JobManager

{letta_nightly-0.11.6.dev20250902104140.dist-info → letta_nightly-0.11.7.dev20250904045700.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: letta-nightly
-Version: 0.11.6.dev20250902104140
+Version: 0.11.7.dev20250904045700
 Summary: Create LLM agents with long-term memory and custom tools
 Author-email: Letta Team <contact@letta.com>
 License: Apache License
@@ -18,15 +18,15 @@ Requires-Dist: composio-core>=0.7.7
 Requires-Dist: datamodel-code-generator[http]>=0.25.0
 Requires-Dist: demjson3>=3.0.6
 Requires-Dist: docstring-parser<0.17,>=0.16
+Requires-Dist: exa-py>=1.15.4
 Requires-Dist: faker>=36.1.0
-Requires-Dist: firecrawl-py<3.0.0,>=2.8.0
 Requires-Dist: grpcio-tools>=1.68.1
 Requires-Dist: grpcio>=1.68.1
 Requires-Dist: html2text>=2020.1.16
 Requires-Dist: httpx-sse>=0.4.0
 Requires-Dist: httpx>=0.28.0
 Requires-Dist: jinja2>=3.1.5
-Requires-Dist: letta-client>=0.1.277
+Requires-Dist: letta-client==0.1.307
 Requires-Dist: llama-index-embeddings-openai>=0.3.1
 Requires-Dist: llama-index>=0.12.2
 Requires-Dist: markitdown[docx,pdf,pptx]>=0.1.2
@@ -53,7 +53,9 @@ Requires-Dist: python-multipart>=0.0.19
 Requires-Dist: pytz>=2023.3.post1
 Requires-Dist: pyyaml>=6.0.1
 Requires-Dist: questionary>=2.0.1
+Requires-Dist: readability-lxml
 Requires-Dist: rich>=13.9.4
+Requires-Dist: ruff[dev]>=0.12.10
 Requires-Dist: sentry-sdk[fastapi]==2.19.1
 Requires-Dist: setuptools>=70
 Requires-Dist: sqlalchemy-json>=0.7.0
@@ -63,6 +65,7 @@ Requires-Dist: sqlmodel>=0.0.16
 Requires-Dist: structlog>=25.4.0
 Requires-Dist: tavily-python>=0.7.2
 Requires-Dist: tqdm>=4.66.1
+Requires-Dist: trafilatura
 Requires-Dist: typer>=0.15.2
 Provides-Extra: bedrock
 Requires-Dist: aioboto3>=14.3.0; extra == 'bedrock'
@@ -71,22 +74,23 @@ Provides-Extra: cloud-tool-sandbox
 Requires-Dist: e2b-code-interpreter>=1.0.3; extra == 'cloud-tool-sandbox'
 Provides-Extra: desktop
 Requires-Dist: aiosqlite>=0.21.0; extra == 'desktop'
+Requires-Dist: async-lru>=2.0.5; extra == 'desktop'
 Requires-Dist: docker>=7.1.0; extra == 'desktop'
 Requires-Dist: fastapi>=0.115.6; extra == 'desktop'
 Requires-Dist: langchain-community>=0.3.7; extra == 'desktop'
 Requires-Dist: langchain>=0.3.7; extra == 'desktop'
 Requires-Dist: locust>=2.31.5; extra == 'desktop'
+Requires-Dist: magika>=0.6.2; extra == 'desktop'
+Requires-Dist: pgserver>=0.1.4; extra == 'desktop'
 Requires-Dist: pgvector>=0.2.3; extra == 'desktop'
 Requires-Dist: sqlite-vec>=0.1.7a2; extra == 'desktop'
+Requires-Dist: tiktoken>=0.11.0; extra == 'desktop'
 Requires-Dist: uvicorn>=0.24.0.post1; extra == 'desktop'
 Requires-Dist: websockets; extra == 'desktop'
 Requires-Dist: wikipedia>=1.4.0; extra == 'desktop'
 Provides-Extra: dev
-Requires-Dist: autoflake>=2.3.0; extra == 'dev'
-Requires-Dist: black[jupyter]>=24.4.2; extra == 'dev'
 Requires-Dist: ipdb>=0.13.13; extra == 'dev'
 Requires-Dist: ipykernel>=6.29.5; extra == 'dev'
-Requires-Dist: isort>=5.13.2; extra == 'dev'
 Requires-Dist: pexpect>=4.9.0; extra == 'dev'
 Requires-Dist: pre-commit>=3.5.0; extra == 'dev'
 Requires-Dist: pyright>=1.1.347; extra == 'dev'
@@ -101,7 +105,7 @@ Requires-Dist: granian[reload,uvloop]>=2.3.2; extra == 'experimental'
 Requires-Dist: uvloop>=0.21.0; extra == 'experimental'
 Provides-Extra: external-tools
 Requires-Dist: docker>=7.1.0; extra == 'external-tools'
-Requires-Dist: firecrawl-py<3.0.0,>=2.8.0; extra == 'external-tools'
+Requires-Dist: exa-py>=1.15.4; extra == 'external-tools'
 Requires-Dist: langchain-community>=0.3.7; extra == 'external-tools'
 Requires-Dist: langchain>=0.3.7; extra == 'external-tools'
 Requires-Dist: turbopuffer>=0.5.17; extra == 'external-tools'