letta-nightly 0.7.14.dev20250513104323__tar.gz → 0.7.15.dev20250514104255__tar.gz

{letta_nightly-0.7.14.dev20250513104323 → letta_nightly-0.7.15.dev20250514104255}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: letta-nightly
-Version: 0.7.14.dev20250513104323
+Version: 0.7.15.dev20250514104255
 Summary: Create LLM agents with long-term memory and custom tools
 License: Apache License
 Author: Letta Team

{letta_nightly-0.7.14.dev20250513104323 → letta_nightly-0.7.15.dev20250514104255}/letta/__init__.py

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

{letta_nightly-0.7.14.dev20250513104323 → letta_nightly-0.7.15.dev20250514104255}/letta/agents/base_agent.py

@@ -127,7 +127,13 @@ class BaseAgent(ABC):
             logger.exception(f"Failed to rebuild memory for agent id={agent_state.id} and actor=({self.actor.id}, {self.actor.name})")
             raise
 
-    async def _rebuild_memory_async(self, in_context_messages: List[Message], agent_state: AgentState) -> List[Message]:
+    async def _rebuild_memory_async(
+        self,
+        in_context_messages: List[Message],
+        agent_state: AgentState,
+        num_messages: int | None = None,  # storing these calculations is specific to the voice agent
+        num_archival_memories: int | None = None,
+    ) -> List[Message]:
         """
         Async version of function above. For now before breaking up components, changes should be made in both places.
         """
@@ -165,7 +171,7 @@ class BaseAgent(ABC):
                 logger.debug(f"Rebuilding system with new memory...\nDiff:\n{diff}")
 
                 # [DB Call] Update Messages
-                new_system_message = self.message_manager.update_message_by_id_async(
+                new_system_message = await self.message_manager.update_message_by_id_async(
                     curr_system_message.id, message_update=MessageUpdate(content=new_system_message_str), actor=self.actor
                 )
                 return [new_system_message] + in_context_messages[1:]

{letta_nightly-0.7.14.dev20250513104323 → letta_nightly-0.7.15.dev20250514104255}/letta/agents/letta_agent.py

@@ -60,6 +60,10 @@ class LettaAgent(BaseAgent):
 
         self.last_function_response = self._load_last_function_response()
 
+        # Cached archival memory/message size
+        self.num_messages = self.message_manager.size(actor=self.actor, agent_id=agent_id)
+        self.num_archival_memories = self.passage_manager.size(actor=self.actor, agent_id=agent_id)
+
     @trace_method
     async def step(self, input_messages: List[MessageCreate], max_steps: int = 10) -> LettaResponse:
         agent_state = self.agent_manager.get_agent_by_id(self.agent_id, actor=self.actor)
@@ -164,6 +168,11 @@ class LettaAgent(BaseAgent):
             message_ids = [m.id for m in (current_in_context_messages + new_in_context_messages)]
             self.agent_manager.set_in_context_messages(agent_id=self.agent_id, message_ids=message_ids, actor=self.actor)
 
+        # TODO: This may be out of sync, if in between steps users add files
+        # NOTE (cliandy): temporary for now for particlar use cases.
+        self.num_messages = self.message_manager.size(actor=self.actor, agent_id=agent_state.id)
+        self.num_archival_memories = self.passage_manager.size(actor=self.actor, agent_id=agent_state.id)
+
         # TODO: Also yield out a letta usage stats SSE
 
         yield f"data: {MessageStreamStatus.done.model_dump_json()}\n\n"
@@ -179,7 +188,9 @@ class LettaAgent(BaseAgent):
         stream: bool,
     ) -> ChatCompletion | AsyncStream[ChatCompletionChunk]:
         if settings.experimental_enable_async_db_engine:
-            in_context_messages = await self._rebuild_memory_async(in_context_messages, agent_state)
+            in_context_messages = await self._rebuild_memory_async(
+                in_context_messages, agent_state, num_messages=self.num_messages, num_archival_memories=self.num_archival_memories
+            )
         else:
             if settings.experimental_skip_rebuild_memory and agent_state.llm_config.model_endpoint_type == "google_vertex":
                 logger.info("Skipping memory rebuild")

{letta_nightly-0.7.14.dev20250513104323 → letta_nightly-0.7.15.dev20250514104255}/letta/interfaces/anthropic_streaming_interface.py

@@ -83,6 +83,9 @@ class AnthropicStreamingInterface:
         self.inner_thoughts_complete = False
         self.put_inner_thoughts_in_kwarg = put_inner_thoughts_in_kwarg
 
+        # Buffer to handle partial XML tags across chunks
+        self.partial_tag_buffer = ""
+
     def get_tool_call_object(self) -> ToolCall:
         """Useful for agent loop"""
         return ToolCall(id=self.tool_call_id, function=FunctionCall(arguments=self.accumulated_tool_call_args, name=self.tool_call_name))
@@ -154,8 +157,22 @@ class AnthropicStreamingInterface:
                                     f"Streaming integrity failed - received BetaTextDelta object while not in TEXT EventMode: {delta}"
                                 )
 
-                            # TODO: Strip out </thinking> more robustly, this is pretty hacky lol
-                            delta.text = delta.text.replace("</thinking>", "")
+                            # Combine buffer with current text to handle tags split across chunks
+                            combined_text = self.partial_tag_buffer + delta.text
+
+                            # Remove all occurrences of </thinking> tag
+                            cleaned_text = combined_text.replace("</thinking>", "")
+
+                            # Extract just the new content (without the buffer part)
+                            if len(self.partial_tag_buffer) <= len(cleaned_text):
+                                delta.text = cleaned_text[len(self.partial_tag_buffer) :]
+                            else:
+                                # Edge case: the tag was removed and now the text is shorter than the buffer
+                                delta.text = ""
+
+                            # Store the last 10 characters (or all if less than 10) for the next chunk
+                            # This is enough to catch "</thinking" which is 10 characters
+                            self.partial_tag_buffer = combined_text[-10:] if len(combined_text) > 10 else combined_text
                             self.accumulated_inner_thoughts.append(delta.text)
 
                             reasoning_message = ReasoningMessage(

{letta_nightly-0.7.14.dev20250513104323 → letta_nightly-0.7.15.dev20250514104255}/letta/llm_api/openai.py

@@ -393,7 +393,9 @@ def openai_chat_completions_process_stream(
                         if tool_call_delta.id is not None:
                             # TODO assert that we're not overwriting?
                             # TODO += instead of =?
-                            if tool_call_delta.index not in range(len(accum_message.tool_calls)):
+                            try:
+                                accum_message.tool_calls[tool_call_delta.index].id = tool_call_delta.id
+                            except IndexError:
                                 warnings.warn(
                                     f"Tool call index out of range ({tool_call_delta.index})\ncurrent tool calls: {accum_message.tool_calls}\ncurrent delta: {tool_call_delta}"
                                 )
@@ -403,25 +405,21 @@ def openai_chat_completions_process_stream(
                                 accum_message.tool_calls[tool_call_delta.index].id = tool_call_delta.id
                         if tool_call_delta.function is not None:
                             if tool_call_delta.function.name is not None:
-                                # TODO assert that we're not overwriting?
-                                # TODO += instead of =?
-                                if tool_call_delta.index not in range(len(accum_message.tool_calls)):
+                                try:
+                                    accum_message.tool_calls[
+                                        tool_call_delta.index
+                                    ].function.name += tool_call_delta.function.name  # TODO check for parallel tool calls
+                                except IndexError:
                                     warnings.warn(
                                         f"Tool call index out of range ({tool_call_delta.index})\ncurrent tool calls: {accum_message.tool_calls}\ncurrent delta: {tool_call_delta}"
                                     )
-                                    # force index 0
-                                    # accum_message.tool_calls[0].function.name = tool_call_delta.function.name
-                                else:
-                                    accum_message.tool_calls[tool_call_delta.index].function.name = tool_call_delta.function.name
                             if tool_call_delta.function.arguments is not None:
-                                if tool_call_delta.index not in range(len(accum_message.tool_calls)):
+                                try:
+                                    accum_message.tool_calls[tool_call_delta.index].function.arguments += tool_call_delta.function.arguments
+                                except IndexError:
                                     warnings.warn(
                                         f"Tool call index out of range ({tool_call_delta.index})\ncurrent tool calls: {accum_message.tool_calls}\ncurrent delta: {tool_call_delta}"
                                     )
-                                    # force index 0
-                                    # accum_message.tool_calls[0].function.arguments += tool_call_delta.function.arguments
-                                else:
-                                    accum_message.tool_calls[tool_call_delta.index].function.arguments += tool_call_delta.function.arguments
 
                 if message_delta.function_call is not None:
                     raise NotImplementedError(f"Old function_call style not support with stream=True")

{letta_nightly-0.7.14.dev20250513104323 → letta_nightly-0.7.15.dev20250514104255}/letta/schemas/llm_config.py

@@ -75,7 +75,8 @@ class LLMConfig(BaseModel):
         description="The reasoning effort to use when generating text reasoning models",
     )
     max_reasoning_tokens: int = Field(
-        0, description="Configurable thinking budget for extended thinking. Used for enable_reasoner and also for Google Vertex models like Gemini 2.5 Flash. Minimum value is 1024 when used with enable_reasoner."
+        0,
+        description="Configurable thinking budget for extended thinking. Used for enable_reasoner and also for Google Vertex models like Gemini 2.5 Flash. Minimum value is 1024 when used with enable_reasoner.",
     )
 
     # FIXME hack to silence pydantic protected namespace warning

{letta_nightly-0.7.14.dev20250513104323 → letta_nightly-0.7.15.dev20250514104255}/letta/server/db.py

@@ -123,6 +123,7 @@ class DatabaseRegistry:
                     async_pg_uri = pg_uri.replace("postgresql://", "postgresql+asyncpg://")
                 else:
                     async_pg_uri = f"postgresql+asyncpg://{pg_uri.split('://', 1)[1]}" if "://" in pg_uri else pg_uri
+                async_pg_uri = async_pg_uri.replace("sslmode=", "ssl=")
 
                 async_engine = create_async_engine(
                     async_pg_uri,

{letta_nightly-0.7.14.dev20250513104323 → letta_nightly-0.7.15.dev20250514104255}/letta/server/rest_api/routers/v1/blocks.py

@@ -15,19 +15,26 @@ router = APIRouter(prefix="/blocks", tags=["blocks"])
 
 
 @router.get("/", response_model=List[Block], operation_id="list_blocks")
-def list_blocks(
+async def list_blocks(
     # query parameters
     label: Optional[str] = Query(None, description="Labels to include (e.g. human, persona)"),
     templates_only: bool = Query(False, description="Whether to include only templates"),
     name: Optional[str] = Query(None, description="Name of the block"),
     identity_id: Optional[str] = Query(None, description="Search agents by identifier id"),
     identifier_keys: Optional[List[str]] = Query(None, description="Search agents by identifier keys"),
+    limit: Optional[int] = Query(50, description="Number of blocks to return"),
     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 = server.user_manager.get_user_or_default(user_id=actor_id)
-    return server.block_manager.get_blocks(
-        actor=actor, label=label, is_template=templates_only, template_name=name, identity_id=identity_id, identifier_keys=identifier_keys
+    return await server.block_manager.get_blocks_async(
+        actor=actor,
+        label=label,
+        is_template=templates_only,
+        template_name=name,
+        identity_id=identity_id,
+        identifier_keys=identifier_keys,
+        limit=limit,
     )
 
 

{letta_nightly-0.7.14.dev20250513104323 → letta_nightly-0.7.15.dev20250514104255}/letta/services/block_manager.py

@@ -117,6 +117,68 @@ class BlockManager:
 
             return [block.to_pydantic() for block in blocks]
 
+    @enforce_types
+    async def get_blocks_async(
+        self,
+        actor: PydanticUser,
+        label: Optional[str] = None,
+        is_template: Optional[bool] = None,
+        template_name: Optional[str] = None,
+        identity_id: Optional[str] = None,
+        identifier_keys: Optional[List[str]] = None,
+        limit: Optional[int] = 50,
+    ) -> List[PydanticBlock]:
+        """Async version of get_blocks method. Retrieve blocks based on various optional filters."""
+        from sqlalchemy import select
+        from sqlalchemy.orm import noload
+
+        from letta.orm.sqlalchemy_base import AccessType
+
+        async with db_registry.async_session() as session:
+            # Start with a basic query
+            query = select(BlockModel)
+
+            # Explicitly avoid loading relationships
+            query = query.options(noload(BlockModel.agents), noload(BlockModel.identities), noload(BlockModel.groups))
+
+            # Apply access control
+            query = BlockModel.apply_access_predicate(query, actor, ["read"], AccessType.ORGANIZATION)
+
+            # Add filters
+            query = query.where(BlockModel.organization_id == actor.organization_id)
+            if label:
+                query = query.where(BlockModel.label == label)
+
+            if is_template is not None:
+                query = query.where(BlockModel.is_template == is_template)
+
+            if template_name:
+                query = query.where(BlockModel.template_name == template_name)
+
+            if identifier_keys:
+                query = (
+                    query.join(BlockModel.identities)
+                    .filter(BlockModel.identities.property.mapper.class_.identifier_key.in_(identifier_keys))
+                    .distinct(BlockModel.id)
+                )
+
+            if identity_id:
+                query = (
+                    query.join(BlockModel.identities)
+                    .filter(BlockModel.identities.property.mapper.class_.id == identity_id)
+                    .distinct(BlockModel.id)
+                )
+
+            # Add limit
+            if limit:
+                query = query.limit(limit)
+
+            # Execute the query
+            result = await session.execute(query)
+            blocks = result.scalars().all()
+
+            return [block.to_pydantic() for block in blocks]
+
     @enforce_types
     def get_block_by_id(self, block_id: str, actor: Optional[PydanticUser] = None) -> Optional[PydanticBlock]:
         """Retrieve a block by its name."""

{letta_nightly-0.7.14.dev20250513104323 → letta_nightly-0.7.15.dev20250514104255}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "letta-nightly"
-version = "0.7.14.dev20250513104323"
+version = "0.7.15.dev20250514104255"
 packages = [
     {include = "letta"},
 ]