letta-nightly 0.6.24.dev20250212104045__py3-none-any.whl → 0.6.25.dev20250213023354__py3-none-any.whl

letta/schemas/agent.py

@@ -43,7 +43,6 @@ class AgentState(OrmMetadataBase, validate_assignment=True):
         system (str): The system prompt used by the agent.
         llm_config (LLMConfig): The LLM configuration used by the agent.
         embedding_config (EmbeddingConfig): The embedding configuration used by the agent.
-
     """
 
     __id_prefix__ = "agent"
@@ -85,6 +84,12 @@ class AgentState(OrmMetadataBase, validate_assignment=True):
     template_id: Optional[str] = Field(None, description="The id of the template the agent belongs to.")
     base_template_id: Optional[str] = Field(None, description="The base template id of the agent.")
 
+    # An advanced configuration that makes it so this agent does not remember any previous messages
+    message_buffer_autoclear: bool = Field(
+        False,
+        description="If set to True, the agent will not remember previous messages (though the agent will still retain state via core memory blocks and archival/recall memory). Not recommended unless you have an advanced use case.",
+    )
+
     def get_agent_env_vars_as_dict(self) -> Dict[str, str]:
         # Get environment variables for this agent specifically
         per_agent_env_vars = {}
@@ -146,6 +151,10 @@ class CreateAgent(BaseModel, validate_assignment=True):  #
     project_id: Optional[str] = Field(None, description="The id of the project the agent belongs to.")
     template_id: Optional[str] = Field(None, description="The id of the template the agent belongs to.")
     base_template_id: Optional[str] = Field(None, description="The base template id of the agent.")
+    message_buffer_autoclear: bool = Field(
+        False,
+        description="If set to True, the agent will not remember previous messages (though the agent will still retain state via core memory blocks and archival/recall memory). Not recommended unless you have an advanced use case.",
+    )
 
     @field_validator("name")
     @classmethod
@@ -216,6 +225,10 @@ class UpdateAgent(BaseModel):
     project_id: Optional[str] = Field(None, description="The id of the project the agent belongs to.")
     template_id: Optional[str] = Field(None, description="The id of the template the agent belongs to.")
     base_template_id: Optional[str] = Field(None, description="The base template id of the agent.")
+    message_buffer_autoclear: Optional[bool] = Field(
+        None,
+        description="If set to True, the agent will not remember previous messages (though the agent will still retain state via core memory blocks and archival/recall memory). Not recommended unless you have an advanced use case.",
+    )
 
     class Config:
         extra = "ignore"  # Ignores extra fields

letta/schemas/embedding_config.py

@@ -26,6 +26,7 @@ class EmbeddingConfig(BaseModel):
         "bedrock",
         "cohere",
         "google_ai",
+        "google_vertex",
         "azure",
         "groq",
         "ollama",

letta/schemas/llm_config.py

@@ -25,6 +25,7 @@ class LLMConfig(BaseModel):
         "anthropic",
         "cohere",
         "google_ai",
+        "google_vertex",
         "azure",
         "groq",
         "ollama",

letta/schemas/message.py

@@ -570,19 +570,12 @@ class Message(BaseMessage):
                 "role": "user",
             }
 
-            # Optional field, do not include if null
-            if self.name is not None:
-                anthropic_message["name"] = self.name
-
         elif self.role == "user":
             assert all([v is not None for v in [self.text, self.role]]), vars(self)
             anthropic_message = {
                 "content": self.text,
                 "role": self.role,
             }
-            # Optional field, do not include if null
-            if self.name is not None:
-                anthropic_message["name"] = self.name
 
         elif self.role == "assistant":
             assert self.tool_calls is not None or self.text is not None
@@ -624,10 +617,6 @@ class Message(BaseMessage):
             # TODO support multi-modal
             anthropic_message["content"] = content
 
-            # Optional fields, do not include if null
-            if self.name is not None:
-                anthropic_message["name"] = self.name
-
         elif self.role == "tool":
             # NOTE: Anthropic uses role "user" for "tool" responses
             assert all([v is not None for v in [self.role, self.tool_call_id]]), vars(self)

letta/schemas/providers.py

@@ -327,7 +327,7 @@ class LMStudioOpenAIProvider(OpenAIProvider):
                     embedding_endpoint_type="openai",
                     embedding_endpoint=self.base_url,
                     embedding_dim=context_window_size,
-                    embedding_chunk_size=300,
+                    embedding_chunk_size=300,  # NOTE: max is 2048
                     handle=self.get_handle(model_name),
                 ),
             )
@@ -737,6 +737,45 @@ class GoogleAIProvider(Provider):
         return google_ai_get_model_context_window(self.base_url, self.api_key, model_name)
 
 
+class GoogleVertexProvider(Provider):
+    name: str = "google_vertex"
+    google_cloud_project: str = Field(..., description="GCP project ID for the Google Vertex API.")
+    google_cloud_location: str = Field(..., description="GCP region for the Google Vertex API.")
+
+    def list_llm_models(self) -> List[LLMConfig]:
+        from letta.llm_api.google_constants import GOOGLE_MODEL_TO_CONTEXT_LENGTH
+
+        configs = []
+        for model, context_length in GOOGLE_MODEL_TO_CONTEXT_LENGTH.items():
+            configs.append(
+                LLMConfig(
+                    model=model,
+                    model_endpoint_type="google_vertex",
+                    model_endpoint=f"https://{self.google_cloud_location}-aiplatform.googleapis.com/v1/projects/{self.google_cloud_project}/locations/{self.google_cloud_location}",
+                    context_window=context_length,
+                    handle=self.get_handle(model),
+                )
+            )
+        return configs
+
+    def list_embedding_models(self) -> List[EmbeddingConfig]:
+        from letta.llm_api.google_constants import GOOGLE_EMBEDING_MODEL_TO_DIM
+
+        configs = []
+        for model, dim in GOOGLE_EMBEDING_MODEL_TO_DIM.items():
+            configs.append(
+                EmbeddingConfig(
+                    embedding_model=model,
+                    embedding_endpoint_type="google_vertex",
+                    embedding_endpoint=f"https://{self.google_cloud_location}-aiplatform.googleapis.com/v1/projects/{self.google_cloud_project}/locations/{self.google_cloud_location}",
+                    embedding_dim=dim,
+                    embedding_chunk_size=300,  # NOTE: max is 2048
+                    handle=self.get_handle(model, is_embedding=True),
+                )
+            )
+        return configs
+
+
 class AzureProvider(Provider):
     name: str = "azure"
     latest_api_version: str = "2024-09-01-preview"  # https://learn.microsoft.com/en-us/azure/ai-services/openai/api-version-deprecation
@@ -792,8 +831,8 @@ class AzureProvider(Provider):
                     embedding_endpoint=model_endpoint,
                     embedding_dim=768,
                     embedding_chunk_size=300,  # NOTE: max is 2048
-                    handle=self.get_handle(model_name, is_embedding=True),
-                )
+                    handle=self.get_handle(model_name),
+                ),
             )
         return configs
 

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

@@ -124,6 +124,10 @@ def upsert_tool(
         # Log the error and raise a conflict exception
         print(f"Unique constraint violation occurred: {e}")
         raise HTTPException(status_code=409, detail=str(e))
+    except LettaToolCreateError as e:
+        # HTTP 400 == Bad Request
+        print(f"Error occurred during tool upsert: {e}")
+        raise HTTPException(status_code=400, detail=str(e))
     except Exception as e:
         # Catch other unexpected errors and raise an internal server error
         print(f"Unexpected error occurred: {e}")
@@ -140,8 +144,17 @@ def modify_tool(
     """
     Update an existing tool
     """
-    actor = server.user_manager.get_user_or_default(user_id=user_id)
-    return server.tool_manager.update_tool_by_id(tool_id=tool_id, tool_update=request, actor=actor)
+    try:
+        actor = server.user_manager.get_user_or_default(user_id=user_id)
+        return server.tool_manager.update_tool_by_id(tool_id=tool_id, tool_update=request, actor=actor)
+    except LettaToolCreateError as e:
+        # HTTP 400 == Bad Request
+        print(f"Error occurred during tool update: {e}")
+        raise HTTPException(status_code=400, detail=str(e))
+    except Exception as e:
+        # Catch other unexpected errors and raise an internal server error
+        print(f"Unexpected error occurred: {e}")
+        raise HTTPException(status_code=500, detail=f"An unexpected error occurred: {str(e)}")
 
 
 @router.post("/add-base-tools", response_model=List[Tool], operation_id="add_base_tools")

letta/server/server.py

@@ -47,6 +47,7 @@ from letta.schemas.providers import (
     AnthropicProvider,
     AzureProvider,
     GoogleAIProvider,
+    GoogleVertexProvider,
     GroqProvider,
     LettaProvider,
     LMStudioOpenAIProvider,
@@ -352,6 +353,13 @@ class SyncServer(Server):
                     api_key=model_settings.gemini_api_key,
                 )
             )
+        if model_settings.google_cloud_location and model_settings.google_cloud_project:
+            self._enabled_providers.append(
+                GoogleVertexProvider(
+                    google_cloud_project=model_settings.google_cloud_project,
+                    google_cloud_location=model_settings.google_cloud_location,
+                )
+            )
         if model_settings.azure_api_key and model_settings.azure_base_url:
             assert model_settings.azure_api_version, "AZURE_API_VERSION is required"
             self._enabled_providers.append(
@@ -875,14 +883,12 @@ class SyncServer(Server):
         # TODO: Thread actor directly through this function, since the top level caller most likely already retrieved the user
 
         actor = self.user_manager.get_user_or_default(user_id=user_id)
-        start_date = self.message_manager.get_message_by_id(after, actor=actor).created_at if after else None
-        end_date = self.message_manager.get_message_by_id(before, actor=actor).created_at if before else None
 
         records = self.message_manager.list_messages_for_agent(
             agent_id=agent_id,
             actor=actor,
-            start_date=start_date,
-            end_date=end_date,
+            after=after,
+            before=before,
             limit=limit,
             ascending=not reverse,
         )

letta/services/agent_manager.py

@@ -123,6 +123,7 @@ class AgentManager:
             project_id=agent_create.project_id,
             template_id=agent_create.template_id,
             base_template_id=agent_create.base_template_id,
+            message_buffer_autoclear=agent_create.message_buffer_autoclear,
         )
 
         # If there are provided environment variables, add them in
@@ -185,6 +186,7 @@ class AgentManager:
         project_id: Optional[str] = None,
         template_id: Optional[str] = None,
         base_template_id: Optional[str] = None,
+        message_buffer_autoclear: bool = False,
     ) -> PydanticAgentState:
         """Create a new agent."""
         with self.session_maker() as session:
@@ -202,6 +204,7 @@ class AgentManager:
                 "project_id": project_id,
                 "template_id": template_id,
                 "base_template_id": base_template_id,
+                "message_buffer_autoclear": message_buffer_autoclear,
             }
 
             # Create the new agent using SqlalchemyBase.create
@@ -263,6 +266,7 @@ class AgentManager:
                 "project_id",
                 "template_id",
                 "base_template_id",
+                "message_buffer_autoclear",
             }
             for field in scalar_fields:
                 value = getattr(agent_update, field, None)
@@ -494,6 +498,7 @@ class AgentManager:
     @enforce_types
     def trim_all_in_context_messages_except_system(self, agent_id: str, actor: PydanticUser) -> PydanticAgentState:
         message_ids = self.get_agent_by_id(agent_id=agent_id, actor=actor).message_ids
+        # TODO: How do we know this?
         new_messages = [message_ids[0]]  # 0 is system message
         return self._set_in_context_messages(agent_id=agent_id, message_ids=new_messages, actor=actor)
 

letta/services/message_manager.py

@@ -1,6 +1,8 @@
-from datetime import datetime
-from typing import Dict, List, Optional
+from typing import List, Optional
 
+from sqlalchemy import and_, or_
+
+from letta.orm.agent import Agent as AgentModel
 from letta.orm.errors import NoResultFound
 from letta.orm.message import Message as MessageModel
 from letta.schemas.enums import MessageRole
@@ -127,44 +129,21 @@ class MessageManager:
     def list_user_messages_for_agent(
         self,
         agent_id: str,
-        actor: Optional[PydanticUser] = None,
-        before: Optional[str] = None,
+        actor: PydanticUser,
         after: Optional[str] = None,
-        start_date: Optional[datetime] = None,
-        end_date: Optional[datetime] = None,
-        limit: Optional[int] = 50,
-        filters: Optional[Dict] = None,
+        before: Optional[str] = None,
         query_text: Optional[str] = None,
+        limit: Optional[int] = 50,
         ascending: bool = True,
     ) -> List[PydanticMessage]:
-        """List user messages with flexible filtering and pagination options.
-
-        Args:
-            before: Cursor-based pagination - return records before this ID (exclusive)
-            after: Cursor-based pagination - return records after this ID (exclusive)
-            start_date: Filter records created after this date
-            end_date: Filter records created before this date
-            limit: Maximum number of records to return
-            filters: Additional filters to apply
-            query_text: Optional text to search for in message content
-
-        Returns:
-            List[PydanticMessage] - List of messages matching the criteria
-        """
-        message_filters = {"role": "user"}
-        if filters:
-            message_filters.update(filters)
-
         return self.list_messages_for_agent(
             agent_id=agent_id,
             actor=actor,
-            before=before,
             after=after,
-            start_date=start_date,
-            end_date=end_date,
-            limit=limit,
-            filters=message_filters,
+            before=before,
             query_text=query_text,
+            role=MessageRole.user,
+            limit=limit,
             ascending=ascending,
         )
 
@@ -172,48 +151,94 @@ class MessageManager:
     def list_messages_for_agent(
         self,
         agent_id: str,
-        actor: Optional[PydanticUser] = None,
-        before: Optional[str] = None,
+        actor: PydanticUser,
         after: Optional[str] = None,
-        start_date: Optional[datetime] = None,
-        end_date: Optional[datetime] = None,
-        limit: Optional[int] = 50,
-        filters: Optional[Dict] = None,
+        before: Optional[str] = None,
         query_text: Optional[str] = None,
+        role: Optional[MessageRole] = None,  # New parameter for filtering by role
+        limit: Optional[int] = 50,
         ascending: bool = True,
     ) -> List[PydanticMessage]:
-        """List messages with flexible filtering and pagination options.
+        """
+        Most performant query to list messages for an agent by directly querying the Message table.
+
+        This function filters by the agent_id (leveraging the index on messages.agent_id)
+        and applies efficient pagination using (created_at, id) as the cursor.
+        If query_text is provided, it will filter messages whose text content partially matches the query.
+        If role is provided, it will filter messages by the specified role.
 
         Args:
-            before: Cursor-based pagination - return records before this ID (exclusive)
-            after: Cursor-based pagination - return records after this ID (exclusive)
-            start_date: Filter records created after this date
-            end_date: Filter records created before this date
-            limit: Maximum number of records to return
-            filters: Additional filters to apply
-            query_text: Optional text to search for in message content
+            agent_id: The ID of the agent whose messages are queried.
+            actor: The user performing the action (used for permission checks).
+            after: A message ID; if provided, only messages *after* this message (per sort order) are returned.
+            before: A message ID; if provided, only messages *before* this message are returned.
+            query_text: Optional string to partially match the message text content.
+            role: Optional MessageRole to filter messages by role.
+            limit: Maximum number of messages to return.
+            ascending: If True, sort by (created_at, id) ascending; if False, sort descending.
 
         Returns:
-            List[PydanticMessage] - List of messages matching the criteria
+            List[PydanticMessage]: A list of messages (converted via .to_pydantic()).
+
+        Raises:
+            NoResultFound: If the provided after/before message IDs do not exist.
         """
         with self.session_maker() as session:
-            # Start with base filters
-            message_filters = {"agent_id": agent_id}
-            if actor:
-                message_filters.update({"organization_id": actor.organization_id})
-            if filters:
-                message_filters.update(filters)
-
-            results = MessageModel.list(
-                db_session=session,
-                before=before,
-                after=after,
-                start_date=start_date,
-                end_date=end_date,
-                limit=limit,
-                query_text=query_text,
-                ascending=ascending,
-                **message_filters,
-            )
+            # Permission check: raise if the agent doesn't exist or actor is not allowed.
+            AgentModel.read(db_session=session, identifier=agent_id, actor=actor)
+
+            # Build a query that directly filters the Message table by agent_id.
+            query = session.query(MessageModel).filter(MessageModel.agent_id == agent_id)
+
+            # If query_text is provided, filter messages by partial match on text.
+            if query_text:
+                query = query.filter(MessageModel.text.ilike(f"%{query_text}%"))
+
+            # If role is provided, filter messages by role.
+            if role:
+                query = query.filter(MessageModel.role == role.value)  # Enum.value ensures comparison is against the string value
+
+            # Apply 'after' pagination if specified.
+            if after:
+                after_ref = session.query(MessageModel.created_at, MessageModel.id).filter(MessageModel.id == after).limit(1).one_or_none()
+                if not after_ref:
+                    raise NoResultFound(f"No message found with id '{after}' for agent '{agent_id}'.")
+                query = query.filter(
+                    or_(
+                        MessageModel.created_at > after_ref.created_at,
+                        and_(
+                            MessageModel.created_at == after_ref.created_at,
+                            MessageModel.id > after_ref.id,
+                        ),
+                    )
+                )
+
+            # Apply 'before' pagination if specified.
+            if before:
+                before_ref = (
+                    session.query(MessageModel.created_at, MessageModel.id).filter(MessageModel.id == before).limit(1).one_or_none()
+                )
+                if not before_ref:
+                    raise NoResultFound(f"No message found with id '{before}' for agent '{agent_id}'.")
+                query = query.filter(
+                    or_(
+                        MessageModel.created_at < before_ref.created_at,
+                        and_(
+                            MessageModel.created_at == before_ref.created_at,
+                            MessageModel.id < before_ref.id,
+                        ),
+                    )
+                )
+
+            # Apply ordering based on the ascending flag.
+            if ascending:
+                query = query.order_by(MessageModel.created_at.asc(), MessageModel.id.asc())
+            else:
+                query = query.order_by(MessageModel.created_at.desc(), MessageModel.id.desc())
+
+            # Limit the number of results.
+            query = query.limit(limit)
 
+            # Execute and convert each Message to its Pydantic representation.
+            results = query.all()
             return [msg.to_pydantic() for msg in results]

letta/settings.py

@@ -86,6 +86,11 @@ class ModelSettings(BaseSettings):
     # google ai
     gemini_api_key: Optional[str] = None
     gemini_base_url: str = "https://generativelanguage.googleapis.com/"
+
+    # google vertex
+    google_cloud_project: Optional[str] = None
+    google_cloud_location: Optional[str] = None
+
     # together
     together_api_key: Optional[str] = None
 
@@ -151,6 +156,9 @@ class Settings(BaseSettings):
     multi_agent_send_message_timeout: int = 20 * 60
     multi_agent_concurrent_sends: int = 15
 
+    # telemetry logging
+    verbose_telemetry_logging: bool = False
+
     @property
     def letta_pg_uri(self) -> str:
         if self.pg_uri:

letta/utils.py

@@ -16,6 +16,7 @@ import uuid
 from contextlib import contextmanager
 from datetime import datetime, timedelta, timezone
 from functools import wraps
+from logging import Logger
 from typing import Any, Coroutine, List, Union, _GenericAlias, get_args, get_origin, get_type_hints
 from urllib.parse import urljoin, urlparse
 
@@ -1150,3 +1151,19 @@ def run_async_task(coro: Coroutine[Any, Any, Any]) -> Any:
     except RuntimeError:
         # If no event loop is running, create a new one
         return asyncio.run(coro)
+
+
+def log_telemetry(logger: Logger, event: str, **kwargs):
+    """
+    Logs telemetry events with a timestamp.
+
+    :param logger: A logger
+    :param event: A string describing the event.
+    :param kwargs: Additional key-value pairs for logging metadata.
+    """
+    from letta.settings import settings
+
+    if settings.verbose_telemetry_logging:
+        timestamp = datetime.now(timezone.utc).strftime("%Y-%m-%d %H:%M:%S,%f UTC")  # More readable timestamp
+        extra_data = " | ".join(f"{key}={value}" for key, value in kwargs.items() if value is not None)
+        logger.info(f"[{timestamp}] EVENT: {event} | {extra_data}")

{letta_nightly-0.6.24.dev20250212104045.dist-info → letta_nightly-0.6.25.dev20250213023354.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: letta-nightly
-Version: 0.6.24.dev20250212104045
+Version: 0.6.25.dev20250213023354
 Summary: Create LLM agents with long-term memory and custom tools
 License: Apache License
 Author: Letta Team
@@ -16,6 +16,7 @@ Provides-Extra: bedrock
 Provides-Extra: cloud-tool-sandbox
 Provides-Extra: dev
 Provides-Extra: external-tools
+Provides-Extra: google
 Provides-Extra: postgres
 Provides-Extra: qdrant
 Provides-Extra: server
@@ -36,6 +37,7 @@ Requires-Dist: docx2txt (>=0.8,<0.9)
 Requires-Dist: e2b-code-interpreter (>=1.0.3,<2.0.0) ; extra == "cloud-tool-sandbox"
 Requires-Dist: faker (>=36.1.0,<37.0.0)
 Requires-Dist: fastapi (>=0.115.6,<0.116.0) ; extra == "server" or extra == "all"
+Requires-Dist: google-genai (>=1.1.0,<2.0.0) ; extra == "google"
 Requires-Dist: grpcio (>=1.68.1,<2.0.0)
 Requires-Dist: grpcio-tools (>=1.68.1,<2.0.0)
 Requires-Dist: html2text (>=2020.1.16,<2021.0.0)
@@ -82,7 +84,6 @@ Requires-Dist: sqlmodel (>=0.0.16,<0.0.17)
 Requires-Dist: tqdm (>=4.66.1,<5.0.0)
 Requires-Dist: typer (>=0.12,<1.0)
 Requires-Dist: uvicorn (>=0.24.0.post1,<0.25.0) ; extra == "server" or extra == "all"
-Requires-Dist: websockets (>=12.0,<13.0) ; extra == "server" or extra == "all"
 Requires-Dist: wikipedia (>=1.4.0,<2.0.0) ; extra == "external-tools" or extra == "tests" or extra == "all"
 Description-Content-Type: text/markdown