letta-nightly 0.7.9.dev20250504104059__tar.gz → 0.7.10.dev20250506042051__tar.gz

{letta_nightly-0.7.9.dev20250504104059 → letta_nightly-0.7.10.dev20250506042051}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: letta-nightly
-Version: 0.7.9.dev20250504104059
+Version: 0.7.10.dev20250506042051
 Summary: Create LLM agents with long-term memory and custom tools
 License: Apache License
 Author: Letta Team

{letta_nightly-0.7.9.dev20250504104059 → letta_nightly-0.7.10.dev20250506042051}/letta/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "0.7.9"
+__version__ = "0.7.10"
 
 # import clients
 from letta.client.client import LocalClient, RESTClient, create_client

{letta_nightly-0.7.9.dev20250504104059 → letta_nightly-0.7.10.dev20250506042051}/letta/agents/letta_agent_batch.py

@@ -66,7 +66,7 @@ class _ResumeContext:
     request_status_updates: List[RequestStatusUpdateInfo]
 
 
-async def execute_tool_wrapper(params: ToolExecutionParams):
+async def execute_tool_wrapper(params: ToolExecutionParams) -> Tuple[str, Tuple[str, bool]]:
     """
     Executes the tool in an out‑of‑process worker and returns:
         (agent_id, (tool_result:str, success_flag:bool))
@@ -324,8 +324,13 @@ class LettaAgentBatch:
     @trace_method
     async def _execute_tools(self, ctx: _ResumeContext) -> Sequence[Tuple[str, Tuple[str, bool]]]:
         sbx_cfg, sbx_env = self._build_sandbox()
-        params = [
-            ToolExecutionParams(
+        rethink_memory_tool_name = "rethink_memory"
+        tool_params = []
+        # TODO: This is a special case - we need to think about how to generalize this
+        # TODO: Rethink memory is a common op that is easily batchable, so we pull this logic out
+        rethink_memory_params = []
+        for aid in ctx.agent_ids:
+            param = ToolExecutionParams(
                 agent_id=aid,
                 tool_call_name=ctx.tool_call_name_map[aid],
                 tool_args=ctx.tool_call_args_map[aid],
@@ -334,10 +339,44 @@ class LettaAgentBatch:
                 sbx_config=sbx_cfg,
                 sbx_env_vars=sbx_env,
             )
-            for aid in ctx.agent_ids
-        ]
-        async with Pool() as pool:
-            return await pool.map(execute_tool_wrapper, params)
+
+            if ctx.tool_call_name_map[aid] == rethink_memory_tool_name:
+                rethink_memory_params.append(param)
+            else:
+                tool_params.append(param)
+
+        if rethink_memory_params:
+            return self._bulk_rethink_memory(rethink_memory_params)
+
+        if tool_params:
+            async with Pool() as pool:
+                return await pool.map(execute_tool_wrapper, tool_params)
+
+    @trace_method
+    def _bulk_rethink_memory(self, params: List[ToolExecutionParams]) -> Sequence[Tuple[str, Tuple[str, bool]]]:
+        updates = {}
+        result = []
+        for param in params:
+            # Sanity check
+            # TODO: This is very brittle and done quickly for performance
+            # TODO: If the end tool is changed, this will break
+            # TODO: Move 'rethink_memory' to a native Letta tool that we control
+            if "new_memory" not in param.tool_args or "target_block_label" not in param.tool_args:
+                raise ValueError(f"Missing either `new_memory` or `target_block_label` in the tool args: {param.tool_args}")
+
+            # Find the block id/update
+            block_id = param.agent_state.memory.get_block(label=param.tool_args.get("target_block_label")).id
+            new_value = param.tool_args.get("new_memory")
+
+            # This is sensitive to multiple agents overwriting the same memory block
+            updates[block_id] = new_value
+
+            # TODO: This is quite ugly and confusing - this is mostly to align with the returns of other tools
+            result.append((param.agent_id, ("", True)))
+
+        self.block_manager.bulk_update_block_values(updates=updates, actor=self.actor)
+
+        return result
 
     def _persist_tool_messages(
         self,

{letta_nightly-0.7.9.dev20250504104059 → letta_nightly-0.7.10.dev20250506042051}/letta/agents/voice_agent.py

@@ -46,6 +46,7 @@ from letta.services.message_manager import MessageManager
 from letta.services.passage_manager import PassageManager
 from letta.services.summarizer.enums import SummarizationMode
 from letta.services.summarizer.summarizer import Summarizer
+from letta.settings import model_settings
 from letta.utils import united_diff
 
 logger = get_logger(__name__)
@@ -125,6 +126,14 @@ class VoiceAgent(BaseAgent):
 
         agent_state = self.agent_manager.get_agent_by_id(self.agent_id, actor=self.actor)
 
+        # TODO: Refactor this so it uses our in-house clients
+        # TODO: For now, piggyback off of OpenAI client for ease
+        if agent_state.llm_config.model_endpoint_type == "anthropic":
+            self.openai_client.api_key = model_settings.anthropic_api_key
+            self.openai_client.base_url = "https://api.anthropic.com/v1/"
+        elif agent_state.llm_config.model_endpoint_type != "openai":
+            raise ValueError("Letta voice agents are only compatible with OpenAI or Anthropic.")
+
         # Safety check
         if agent_state.agent_type != AgentType.voice_convo_agent:
             raise IncompatibleAgentType(expected_type=AgentType.voice_convo_agent, actual_type=agent_state.agent_type)

{letta_nightly-0.7.9.dev20250504104059 → letta_nightly-0.7.10.dev20250506042051}/letta/interfaces/openai_chat_completions_streaming_interface.py

@@ -35,18 +35,19 @@ class OpenAIChatCompletionsStreamingInterface:
         """
         async with stream:
             async for chunk in stream:
-                choice = chunk.choices[0]
-                delta = choice.delta
-                finish_reason = choice.finish_reason
+                if chunk.choices:
+                    choice = chunk.choices[0]
+                    delta = choice.delta
+                    finish_reason = choice.finish_reason
 
-                async for sse_chunk in self._process_content(delta, chunk):
-                    yield sse_chunk
+                    async for sse_chunk in self._process_content(delta, chunk):
+                        yield sse_chunk
 
-                async for sse_chunk in self._process_tool_calls(delta, chunk):
-                    yield sse_chunk
+                    async for sse_chunk in self._process_tool_calls(delta, chunk):
+                        yield sse_chunk
 
-                if self._handle_finish_reason(finish_reason):
-                    break
+                    if self._handle_finish_reason(finish_reason):
+                        break
 
     async def _process_content(self, delta: ChoiceDelta, chunk: ChatCompletionChunk) -> AsyncGenerator[str, None]:
         """Processes regular content tokens and streams them."""

{letta_nightly-0.7.9.dev20250504104059 → letta_nightly-0.7.10.dev20250506042051}/letta/llm_api/anthropic.py

@@ -115,6 +115,8 @@ MODEL_LIST = [
 
 DUMMY_FIRST_USER_MESSAGE = "User initializing bootup sequence."
 
+VALID_EVENT_TYPES = {"content_block_stop", "message_stop"}
+
 
 def antropic_get_model_context_window(url: str, api_key: Union[str, None], model: str) -> int:
     for model_dict in anthropic_get_model_list(url=url, api_key=api_key):
@@ -596,7 +598,8 @@ def convert_anthropic_stream_event_to_chatcompletion(
             redacted_reasoning_content = event.content_block.data
         else:
             warnings.warn("Unexpected content start type: " + str(type(event.content_block)))
-
+    elif event.type in VALID_EVENT_TYPES:
+        pass
     else:
         warnings.warn("Unexpected event type: " + event.type)
 

{letta_nightly-0.7.9.dev20250504104059 → letta_nightly-0.7.10.dev20250506042051}/letta/llm_api/google_constants.py

@@ -1,5 +1,6 @@
 GOOGLE_MODEL_TO_CONTEXT_LENGTH = {
     "gemini-2.5-pro-exp-03-25": 1048576,
+    "gemini-2.5-flash-preview-04-17": 1048576,
     "gemini-2.0-flash-001": 1048576,
     "gemini-2.0-pro-exp-02-05": 2097152,
     "gemini-2.0-flash-lite-preview-02-05": 1048576,

{letta_nightly-0.7.9.dev20250504104059 → letta_nightly-0.7.10.dev20250506042051}/letta/llm_api/google_vertex_client.py

@@ -110,12 +110,12 @@ class GoogleVertexClient(GoogleAIClient):
             for candidate in response.candidates:
                 content = candidate.content
 
-                if "role" not in content or not content["role"]:
-                    # This means the response is malformed like MALFORMED_FUNCTION_CALL
-                    # NOTE: must be a ValueError to trigger a retry
-                    raise ValueError(f"Error in response data from LLM: {response_data}")
-                role = content["role"]
-                assert role == "model", f"Unknown role in response: {role}"
+                # if "role" not in content or not content["role"]:
+                #    # This means the response is malformed like MALFORMED_FUNCTION_CALL
+                #    # NOTE: must be a ValueError to trigger a retry
+                #    raise ValueError(f"Error in response data from LLM: {response_data}")
+                # role = content["role"]
+                # assert role == "model", f"Unknown role in response: {role}"
 
                 parts = content.parts
 

{letta_nightly-0.7.9.dev20250504104059 → letta_nightly-0.7.10.dev20250506042051}/letta/server/rest_api/app.py

@@ -181,17 +181,6 @@ def create_application() -> "FastAPI":
             },
         )
 
-    @app.exception_handler(IncompatibleAgentType)
-    async def handle_incompatible_agent_type(request: Request, exc: IncompatibleAgentType):
-        return JSONResponse(
-            status_code=400,
-            content={
-                "detail": str(exc),
-                "expected_type": exc.expected_type,
-                "actual_type": exc.actual_type,
-            },
-        )
-
     @app.exception_handler(Exception)
     async def generic_error_handler(request: Request, exc: Exception):
         # Log the actual error for debugging

{letta_nightly-0.7.9.dev20250504104059 → letta_nightly-0.7.10.dev20250506042051}/letta/server/rest_api/routers/v1/blocks.py

@@ -31,11 +31,22 @@ def list_blocks(
     )
 
 
+@router.get("/count", response_model=int, operation_id="count_blocks")
+def count_blocks(
+    server: SyncServer = Depends(get_letta_server),
+    actor_id: Optional[str] = Header(None, alias="user_id"),
+):
+    """
+    Count all blocks created by a user.
+    """
+    return server.block_manager.size(actor=server.user_manager.get_user_or_default(user_id=actor_id))
+
+
 @router.post("/", response_model=Block, operation_id="create_block")
 def create_block(
     create_block: CreateBlock = Body(...),
     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
+    actor_id: Optional[str] = Header(None, alias="user_id"),
 ):
     actor = server.user_manager.get_user_or_default(user_id=actor_id)
     block = Block(**create_block.model_dump())

{letta_nightly-0.7.9.dev20250504104059 → letta_nightly-0.7.10.dev20250506042051}/letta/server/rest_api/routers/v1/groups.py

@@ -40,11 +40,22 @@ def list_groups(
     )
 
 
+@router.get("/count", response_model=int, operation_id="count_groups")
+def count_groups(
+    server: SyncServer = Depends(get_letta_server),
+    actor_id: Optional[str] = Header(None, alias="user_id"),
+):
+    """
+    Get the count of all groups associated with a given user.
+    """
+    return server.group_manager.size(actor=server.user_manager.get_user_or_default(user_id=actor_id))
+
+
 @router.get("/{group_id}", response_model=Group, operation_id="retrieve_group")
 def retrieve_group(
     group_id: str,
     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
+    actor_id: Optional[str] = Header(None, alias="user_id"),
 ):
     """
     Retrieve the group by id.
@@ -61,7 +72,7 @@ def retrieve_group(
 def create_group(
     group: GroupCreate = Body(...),
     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
+    actor_id: Optional[str] = Header(None, alias="user_id"),
     x_project: Optional[str] = Header(None, alias="X-Project"),  # Only handled by next js middleware
 ):
     """
@@ -79,7 +90,7 @@ def modify_group(
     group_id: str,
     group: GroupUpdate = Body(...),
     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
+    actor_id: Optional[str] = Header(None, alias="user_id"),
     x_project: Optional[str] = Header(None, alias="X-Project"),  # Only handled by next js middleware
 ):
     """
@@ -96,7 +107,7 @@ def modify_group(
 def delete_group(
     group_id: str,
     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
+    actor_id: Optional[str] = Header(None, alias="user_id"),
 ):
     """
     Delete a multi-agent group.
@@ -118,7 +129,7 @@ async def send_group_message(
     group_id: str,
     server: SyncServer = Depends(get_letta_server),
     request: LettaRequest = Body(...),
-    actor_id: Optional[str] = Header(None, alias="user_id"),  # Extract user_id from header, default to None if not present
+    actor_id: Optional[str] = Header(None, alias="user_id"),
 ):
     """
     Process a user message and return the group's response.
@@ -156,7 +167,7 @@ async def send_group_message_streaming(
     group_id: str,
     server: SyncServer = Depends(get_letta_server),
     request: LettaStreamingRequest = Body(...),
-    actor_id: Optional[str] = Header(None, alias="user_id"),  # Extract user_id from header, default to None if not present
+    actor_id: Optional[str] = Header(None, alias="user_id"),
 ):
     """
     Process a user message and return the group's responses.
@@ -189,7 +200,7 @@ def modify_group_message(
     message_id: str,
     request: LettaMessageUpdateUnion = Body(...),
     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
+    actor_id: Optional[str] = Header(None, alias="user_id"),
 ):
     """
     Update the details of a message associated with an agent.
@@ -209,7 +220,7 @@ def list_group_messages(
     use_assistant_message: bool = Query(True, description="Whether to use assistant messages"),
     assistant_message_tool_name: str = Query(DEFAULT_MESSAGE_TOOL, description="The name of the designated message tool."),
     assistant_message_tool_kwarg: str = Query(DEFAULT_MESSAGE_TOOL_KWARG, description="The name of the message argument."),
-    actor_id: Optional[str] = Header(None, alias="user_id"),  # Extract user_id from header, default to None if not present
+    actor_id: Optional[str] = Header(None, alias="user_id"),
 ):
     """
     Retrieve message history for an agent.
@@ -247,7 +258,7 @@ def list_group_messages(
 def reset_group_messages(
     group_id: str,
     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
+    actor_id: Optional[str] = Header(None, alias="user_id"),
 ):
     """
     Delete the group messages for all agents that are part of the multi-agent group.

{letta_nightly-0.7.9.dev20250504104059 → letta_nightly-0.7.10.dev20250506042051}/letta/server/rest_api/utils.py

@@ -20,6 +20,7 @@ from letta.helpers.message_helper import convert_message_creates_to_messages
 from letta.log import get_logger
 from letta.schemas.enums import MessageRole
 from letta.schemas.letta_message_content import OmittedReasoningContent, ReasoningContent, RedactedReasoningContent, TextContent
+from letta.schemas.llm_config import LLMConfig
 from letta.schemas.message import Message, MessageCreate
 from letta.schemas.usage import LettaUsageStatistics
 from letta.schemas.user import User
@@ -53,6 +54,7 @@ async def sse_async_generator(
     usage_task: Optional[asyncio.Task] = None,
     finish_message=True,
     request_start_timestamp_ns: Optional[int] = None,
+    llm_config: Optional[LLMConfig] = None,
 ):
     """
     Wraps a generator for use in Server-Sent Events (SSE), handling errors and ensuring a completion message.
@@ -70,6 +72,7 @@ async def sse_async_generator(
     ttft_span = None
     if request_start_timestamp_ns is not None:
         ttft_span = tracer.start_span("time_to_first_token", start_time=request_start_timestamp_ns)
+        ttft_span.set_attributes({f"llm_config.{k}": v for k, v in llm_config.model_dump().items()})
 
     try:
         async for chunk in generator:

{letta_nightly-0.7.9.dev20250504104059 → letta_nightly-0.7.10.dev20250506042051}/letta/server/server.py

@@ -1725,6 +1725,7 @@ class SyncServer(Server):
                         usage_task=task,
                         finish_message=include_final_message,
                         request_start_timestamp_ns=request_start_timestamp_ns,
+                        llm_config=llm_config,
                     ),
                     media_type="text/event-stream",
                 )

{letta_nightly-0.7.9.dev20250504104059 → letta_nightly-0.7.10.dev20250506042051}/letta/services/agent_manager.py

@@ -866,8 +866,9 @@ class AgentManager:
     @enforce_types
     def trim_older_in_context_messages(self, num: int, agent_id: str, actor: PydanticUser) -> PydanticAgentState:
         message_ids = self.get_agent_by_id(agent_id=agent_id, actor=actor).message_ids
-        new_messages = [message_ids[0]] + message_ids[num:]  # 0 is system message
-        return self.set_in_context_messages(agent_id=agent_id, message_ids=new_messages, actor=actor)
+        newer_messages = self._trim_tool_response(agent_id=agent_id, actor=actor, message_ids=message_ids[num:])
+        trimmed_messages = [message_ids[0]] + newer_messages  # 0 is system message
+        return self.set_in_context_messages(agent_id=agent_id, message_ids=trimmed_messages, actor=actor)
 
     @enforce_types
     def trim_all_in_context_messages_except_system(self, agent_id: str, actor: PydanticUser) -> PydanticAgentState:
@@ -876,6 +877,16 @@ class AgentManager:
         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)
 
+    def _trim_tool_response(self, agent_id: str, actor: PydanticUser, message_ids: list[str]) -> PydanticAgentState:
+        """
+        Trims the tool response from the in-context messages if there is no tool call present in trimmed messages.
+        """
+        if message_ids:
+            messages = self.message_manager.get_messages_by_ids(message_ids=[message_ids[0]], actor=actor)
+            if messages and messages[0].role == "tool":
+                return message_ids[1:]
+        return message_ids
+
     @enforce_types
     def prepend_to_in_context_messages(self, messages: List[PydanticMessage], agent_id: str, actor: PydanticUser) -> PydanticAgentState:
         message_ids = self.get_agent_by_id(agent_id=agent_id, actor=actor).message_ids

{letta_nightly-0.7.9.dev20250504104059 → letta_nightly-0.7.10.dev20250506042051}/letta/services/block_manager.py

@@ -1,8 +1,9 @@
 import os
-from typing import List, Optional
+from typing import Dict, List, Optional
 
 from sqlalchemy.orm import Session
 
+from letta.log import get_logger
 from letta.orm.block import Block as BlockModel
 from letta.orm.block_history import BlockHistory
 from letta.orm.enums import ActorType
@@ -13,6 +14,8 @@ from letta.schemas.block import BlockUpdate, Human, Persona
 from letta.schemas.user import User as PydanticUser
 from letta.utils import enforce_types, list_human_files, list_persona_files
 
+logger = get_logger(__name__)
+
 
 class BlockManager:
     """Manager class to handle business logic related to Blocks."""
@@ -165,6 +168,17 @@ class BlockManager:
 
             return agents_pydantic
 
+    @enforce_types
+    def size(
+        self,
+        actor: PydanticUser,
+    ) -> int:
+        """
+        Get the total count of blocks for the given user.
+        """
+        with self.session_maker() as session:
+            return BlockModel.size(db_session=session, actor=actor)
+
     # Block History Functions
 
     @enforce_types
@@ -349,3 +363,44 @@ class BlockManager:
 
             session.commit()
             return block.to_pydantic()
+
+    @enforce_types
+    def bulk_update_block_values(
+        self, updates: Dict[str, str], actor: PydanticUser, return_hydrated: bool = False
+    ) -> Optional[List[PydanticBlock]]:
+        """
+        Bulk-update the `value` field for multiple blocks in one transaction.
+
+        Args:
+            updates: mapping of block_id -> new value
+            actor:   the user performing the update (for org scoping, permissions, audit)
+            return_hydrated: whether to return the pydantic Block objects that were updated
+
+        Returns:
+            the updated Block objects as Pydantic schemas
+
+        Raises:
+            NoResultFound if any block_id doesn’t exist or isn’t visible to this actor
+            ValueError     if any new value exceeds its block’s limit
+        """
+        with self.session_maker() as session:
+            q = session.query(BlockModel).filter(BlockModel.id.in_(updates.keys()), BlockModel.organization_id == actor.organization_id)
+            blocks = q.all()
+
+            found_ids = {b.id for b in blocks}
+            missing = set(updates.keys()) - found_ids
+            if missing:
+                logger.warning(f"Block IDs not found or inaccessible, skipping during bulk update: {missing!r}")
+
+            for block in blocks:
+                new_val = updates[block.id]
+                if len(new_val) > block.limit:
+                    logger.warning(f"Value length ({len(new_val)}) exceeds limit " f"({block.limit}) for block {block.id!r}, truncating...")
+                    new_val = new_val[: block.limit]
+                block.value = new_val
+
+            session.commit()
+
+            if return_hydrated:
+                return [b.to_pydantic() for b in blocks]
+            return None

{letta_nightly-0.7.9.dev20250504104059 → letta_nightly-0.7.10.dev20250506042051}/letta/services/group_manager.py

@@ -239,6 +239,17 @@ class GroupManager:
 
             return prev_last_processed_message_id
 
+    @enforce_types
+    def size(
+        self,
+        actor: PydanticUser,
+    ) -> int:
+        """
+        Get the total count of groups for the given user.
+        """
+        with self.session_maker() as session:
+            return GroupModel.size(db_session=session, actor=actor)
+
     def _process_agent_relationship(self, session: Session, group: GroupModel, agent_ids: List[str], allow_partial=False, replace=True):
         if not agent_ids:
             if replace:

{letta_nightly-0.7.9.dev20250504104059 → letta_nightly-0.7.10.dev20250506042051}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "letta-nightly"
-version = "0.7.9.dev20250504104059"
+version = "0.7.10.dev20250506042051"
 packages = [
     {include = "letta"},
 ]