letta-nightly 0.7.13.dev20250512104305__py3-none-any.whl → 0.7.14.dev20250513020711__py3-none-any.whl

letta/server/rest_api/interface.py

@@ -472,6 +472,7 @@ class StreamingServerInterface(AgentChunkStreamingInterface):
         expect_reasoning_content: bool = False,
         name: Optional[str] = None,
         message_index: int = 0,
+        prev_message_type: Optional[str] = None,
     ) -> Optional[Union[ReasoningMessage, ToolCallMessage, AssistantMessage]]:
         """
         Example data from non-streaming response looks like:
@@ -488,7 +489,6 @@ class StreamingServerInterface(AgentChunkStreamingInterface):
 
         choice = chunk.choices[0]
         message_delta = choice.delta
-        otid = Message.generate_otid_from_id(message_id, message_index)
 
         if (
             message_delta.content is None
@@ -503,6 +503,8 @@ class StreamingServerInterface(AgentChunkStreamingInterface):
 
         # inner thoughts
         if expect_reasoning_content and message_delta.reasoning_content is not None:
+            if prev_message_type and prev_message_type != "reasoning_message":
+                message_index += 1
             processed_chunk = ReasoningMessage(
                 id=message_id,
                 date=message_date,
@@ -510,16 +512,18 @@ class StreamingServerInterface(AgentChunkStreamingInterface):
                 signature=message_delta.reasoning_content_signature,
                 source="reasoner_model" if message_delta.reasoning_content else "non_reasoner_model",
                 name=name,
-                otid=otid,
+                otid=Message.generate_otid_from_id(message_id, message_index),
             )
         elif expect_reasoning_content and message_delta.redacted_reasoning_content is not None:
+            if prev_message_type and prev_message_type != "hidden_reasoning_message":
+                message_index += 1
             processed_chunk = HiddenReasoningMessage(
                 id=message_id,
                 date=message_date,
                 hidden_reasoning=message_delta.redacted_reasoning_content,
                 state="redacted",
                 name=name,
-                otid=otid,
+                otid=Message.generate_otid_from_id(message_id, message_index),
             )
         elif expect_reasoning_content and message_delta.content is not None:
             # "ignore" content if we expect reasoning content
@@ -537,6 +541,8 @@ class StreamingServerInterface(AgentChunkStreamingInterface):
                 # NOTE: this is hardcoded for our DeepSeek API integration
                 json_reasoning_content = parse_json(self.expect_reasoning_content_buffer)
 
+                if prev_message_type and prev_message_type != "tool_call_message":
+                    message_index += 1
                 processed_chunk = ToolCallMessage(
                     id=message_id,
                     date=message_date,
@@ -546,7 +552,7 @@ class StreamingServerInterface(AgentChunkStreamingInterface):
                         tool_call_id=None,
                     ),
                     name=name,
-                    otid=otid,
+                    otid=Message.generate_otid_from_id(message_id, message_index),
                 )
 
             except json.JSONDecodeError as e:
@@ -576,12 +582,14 @@ class StreamingServerInterface(AgentChunkStreamingInterface):
             # print(f"Hiding content delta stream: '{message_delta.content}'")
             # return None
         elif message_delta.content is not None:
+            if prev_message_type and prev_message_type != "reasoning_message":
+                message_index += 1
             processed_chunk = ReasoningMessage(
                 id=message_id,
                 date=message_date,
                 reasoning=message_delta.content,
                 name=name,
-                otid=otid,
+                otid=Message.generate_otid_from_id(message_id, message_index),
             )
 
         # tool calls
@@ -629,7 +637,15 @@ class StreamingServerInterface(AgentChunkStreamingInterface):
                         # TODO: Assumes consistent state and that prev_content is subset of new_content
                         diff = new_content.replace(prev_content, "", 1)
                         self.current_json_parse_result = parsed_args
-                        processed_chunk = AssistantMessage(id=message_id, date=message_date, content=diff, name=name, otid=otid)
+                        if prev_message_type and prev_message_type != "assistant_message":
+                            message_index += 1
+                        processed_chunk = AssistantMessage(
+                            id=message_id,
+                            date=message_date,
+                            content=diff,
+                            name=name,
+                            otid=Message.generate_otid_from_id(message_id, message_index),
+                        )
                     else:
                         return None
 
@@ -653,6 +669,8 @@ class StreamingServerInterface(AgentChunkStreamingInterface):
                         processed_chunk = None
                         print("skipping empty chunk...")
                     else:
+                        if prev_message_type and prev_message_type != "tool_call_message":
+                            message_index += 1
                         processed_chunk = ToolCallMessage(
                             id=message_id,
                             date=message_date,
@@ -662,7 +680,7 @@ class StreamingServerInterface(AgentChunkStreamingInterface):
                                 tool_call_id=tool_call_delta.get("id"),
                             ),
                             name=name,
-                            otid=otid,
+                            otid=Message.generate_otid_from_id(message_id, message_index),
                         )
 
             elif self.inner_thoughts_in_kwargs and tool_call.function:
@@ -694,12 +712,14 @@ class StreamingServerInterface(AgentChunkStreamingInterface):
 
                     # If we have inner thoughts, we should output them as a chunk
                     if updates_inner_thoughts:
+                        if prev_message_type and prev_message_type != "reasoning_message":
+                            message_index += 1
                         processed_chunk = ReasoningMessage(
                             id=message_id,
                             date=message_date,
                             reasoning=updates_inner_thoughts,
                             name=name,
-                            otid=otid,
+                            otid=Message.generate_otid_from_id(message_id, message_index),
                         )
                         # Additionally inner thoughts may stream back with a chunk of main JSON
                         # In that case, since we can only return a chunk at a time, we should buffer it
@@ -727,6 +747,8 @@ class StreamingServerInterface(AgentChunkStreamingInterface):
                                     self.prev_assistant_message_id = self.function_id_buffer
 
                             else:
+                                if prev_message_type and prev_message_type != "tool_call_message":
+                                    message_index += 1
                                 processed_chunk = ToolCallMessage(
                                     id=message_id,
                                     date=message_date,
@@ -736,7 +758,7 @@ class StreamingServerInterface(AgentChunkStreamingInterface):
                                         tool_call_id=self.function_id_buffer,
                                     ),
                                     name=name,
-                                    otid=otid,
+                                    otid=Message.generate_otid_from_id(message_id, message_index),
                                 )
 
                             # Record what the last function name we flushed was
@@ -789,12 +811,14 @@ class StreamingServerInterface(AgentChunkStreamingInterface):
                                     # In this case, we should release the buffer + new data at once
                                     combined_chunk = self.function_args_buffer + updates_main_json
 
+                                    if prev_message_type and prev_message_type != "assistant_message":
+                                        message_index += 1
                                     processed_chunk = AssistantMessage(
                                         id=message_id,
                                         date=message_date,
                                         content=combined_chunk,
                                         name=name,
-                                        otid=otid,
+                                        otid=Message.generate_otid_from_id(message_id, message_index),
                                     )
                                     # Store the ID of the tool call so allow skipping the corresponding response
                                     if self.function_id_buffer:
@@ -818,8 +842,14 @@ class StreamingServerInterface(AgentChunkStreamingInterface):
                                         # TODO: Assumes consistent state and that prev_content is subset of new_content
                                         diff = new_content.replace(prev_content, "", 1)
                                         self.current_json_parse_result = parsed_args
+                                        if prev_message_type and prev_message_type != "assistant_message":
+                                            message_index += 1
                                         processed_chunk = AssistantMessage(
-                                            id=message_id, date=message_date, content=diff, name=name, otid=otid
+                                            id=message_id,
+                                            date=message_date,
+                                            content=diff,
+                                            name=name,
+                                            otid=Message.generate_otid_from_id(message_id, message_index),
                                         )
                                     else:
                                         return None
@@ -836,6 +866,8 @@ class StreamingServerInterface(AgentChunkStreamingInterface):
                                 if self.function_args_buffer:
                                     # In this case, we should release the buffer + new data at once
                                     combined_chunk = self.function_args_buffer + updates_main_json
+                                    if prev_message_type and prev_message_type != "tool_call_message":
+                                        message_index += 1
                                     processed_chunk = ToolCallMessage(
                                         id=message_id,
                                         date=message_date,
@@ -845,13 +877,15 @@ class StreamingServerInterface(AgentChunkStreamingInterface):
                                             tool_call_id=self.function_id_buffer,
                                         ),
                                         name=name,
-                                        otid=otid,
+                                        otid=Message.generate_otid_from_id(message_id, message_index),
                                     )
                                     # clear buffer
                                     self.function_args_buffer = None
                                     self.function_id_buffer = None
                                 else:
                                     # If there's no buffer to clear, just output a new chunk with new data
+                                    if prev_message_type and prev_message_type != "tool_call_message":
+                                        message_index += 1
                                     processed_chunk = ToolCallMessage(
                                         id=message_id,
                                         date=message_date,
@@ -861,7 +895,7 @@ class StreamingServerInterface(AgentChunkStreamingInterface):
                                             tool_call_id=self.function_id_buffer,
                                         ),
                                         name=name,
-                                        otid=otid,
+                                        otid=Message.generate_otid_from_id(message_id, message_index),
                                     )
                                     self.function_id_buffer = None
 
@@ -982,6 +1016,8 @@ class StreamingServerInterface(AgentChunkStreamingInterface):
                     processed_chunk = None
                     print("skipping empty chunk...")
                 else:
+                    if prev_message_type and prev_message_type != "tool_call_message":
+                        message_index += 1
                     processed_chunk = ToolCallMessage(
                         id=message_id,
                         date=message_date,
@@ -991,7 +1027,7 @@ class StreamingServerInterface(AgentChunkStreamingInterface):
                             tool_call_id=tool_call_delta.get("id"),
                         ),
                         name=name,
-                        otid=otid,
+                        otid=Message.generate_otid_from_id(message_id, message_index),
                     )
 
         elif choice.finish_reason is not None:
@@ -1074,6 +1110,7 @@ class StreamingServerInterface(AgentChunkStreamingInterface):
         expect_reasoning_content: bool = False,
         name: Optional[str] = None,
         message_index: int = 0,
+        prev_message_type: Optional[str] = None,
     ):
         """Process a streaming chunk from an OpenAI-compatible server.
 
@@ -1101,6 +1138,7 @@ class StreamingServerInterface(AgentChunkStreamingInterface):
                 expect_reasoning_content=expect_reasoning_content,
                 name=name,
                 message_index=message_index,
+                prev_message_type=prev_message_type,
             )
         if processed_chunk is None:
             return
@@ -1303,7 +1341,7 @@ class StreamingServerInterface(AgentChunkStreamingInterface):
                     stdout=msg_obj.tool_returns[0].stdout if msg_obj.tool_returns else None,
                     stderr=msg_obj.tool_returns[0].stderr if msg_obj.tool_returns else None,
                     name=msg_obj.name,
-                    otid=Message.generate_otid_from_id(msg_obj.id, chunk_index),
+                    otid=Message.generate_otid_from_id(msg_obj.id, chunk_index) if chunk_index is not None else None,
                 )
 
         elif msg.startswith("Error: "):
@@ -1319,7 +1357,7 @@ class StreamingServerInterface(AgentChunkStreamingInterface):
                 stdout=msg_obj.tool_returns[0].stdout if msg_obj.tool_returns else None,
                 stderr=msg_obj.tool_returns[0].stderr if msg_obj.tool_returns else None,
                 name=msg_obj.name,
-                otid=Message.generate_otid_from_id(msg_obj.id, chunk_index),
+                otid=Message.generate_otid_from_id(msg_obj.id, chunk_index) if chunk_index is not None else None,
             )
 
         else:

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

@@ -112,6 +112,7 @@ def create_source(
         name=source_create.name,
         embedding_config=source_create.embedding_config,
         description=source_create.description,
+        instructions=source_create.instructions,
         metadata=source_create.metadata,
     )
     return server.source_manager.create_source(source=source, actor=actor)

letta/server/server.py

@@ -223,7 +223,6 @@ class SyncServer(Server):
         if init_with_default_org_and_user:
             self.default_org = self.organization_manager.create_default_organization()
             self.default_user = self.user_manager.create_default_user()
-            self.block_manager.add_default_blocks(actor=self.default_user)
             self.tool_manager.upsert_base_tools(actor=self.default_user)
 
             # Add composio keys to the tool sandbox env vars of the org
@@ -1115,7 +1114,7 @@ class SyncServer(Server):
                 ),
                 CreateBlock(
                     label="instructions",
-                    value=source.description,
+                    value=source.instructions,
                 ),
             ],
             llm_config=main_agent.llm_config,

letta/services/agent_manager.py

@@ -56,6 +56,7 @@ from letta.serialize_schemas import MarshmallowAgentSchema
 from letta.serialize_schemas.marshmallow_message import SerializedMessageSchema
 from letta.serialize_schemas.marshmallow_tool import SerializedToolSchema
 from letta.serialize_schemas.pydantic_agent_schema import AgentSchema
+from letta.server.db import db_registry
 from letta.services.block_manager import BlockManager
 from letta.services.helpers.agent_manager_helper import (
     _apply_filters,
@@ -85,9 +86,6 @@ class AgentManager:
     """Manager class to handle business logic related to Agents."""
 
     def __init__(self):
-        from letta.server.db import db_context
-
-        self.session_maker = db_context
         self.block_manager = BlockManager()
         self.tool_manager = ToolManager()
         self.source_manager = SourceManager()
@@ -200,7 +198,7 @@ class AgentManager:
         identity_ids = agent_create.identity_ids or []
         tag_values = agent_create.tags or []
 
-        with self.session_maker() as session:
+        with db_registry.session() as session:
             with session.begin():
                 name_to_id, id_to_name = self._resolve_tools(
                     session,
@@ -356,7 +354,7 @@ class AgentManager:
         new_idents = set(agent_update.identity_ids or [])
         new_tags = set(agent_update.tags or [])
 
-        with self.session_maker() as session, session.begin():
+        with db_registry.session() as session, session.begin():
 
             agent: AgentModel = AgentModel.read(db_session=session, identifier=agent_id, actor=actor)
             agent.updated_at = datetime.now(timezone.utc)
@@ -503,7 +501,7 @@ class AgentManager:
         Returns:
             List[PydanticAgentState]: The filtered list of matching agents.
         """
-        with self.session_maker() as session:
+        with db_registry.session() as session:
             query = select(AgentModel).distinct(AgentModel.created_at, AgentModel.id)
             query = AgentModel.apply_access_predicate(query, actor, ["read"], AccessType.ORGANIZATION)
 
@@ -541,7 +539,7 @@ class AgentManager:
         Returns:
             List[PydanticAgentState: The filtered list of matching agents.
         """
-        with self.session_maker() as session:
+        with db_registry.session() as session:
             query = select(AgentModel).where(AgentModel.organization_id == actor.organization_id)
 
             if match_all:
@@ -569,20 +567,20 @@ class AgentManager:
         """
         Get the total count of agents for the given user.
         """
-        with self.session_maker() as session:
+        with db_registry.session() as session:
             return AgentModel.size(db_session=session, actor=actor)
 
     @enforce_types
     def get_agent_by_id(self, agent_id: str, actor: PydanticUser) -> PydanticAgentState:
         """Fetch an agent by its ID."""
-        with self.session_maker() as session:
+        with db_registry.session() as session:
             agent = AgentModel.read(db_session=session, identifier=agent_id, actor=actor)
             return agent.to_pydantic()
 
     @enforce_types
     def get_agent_by_name(self, agent_name: str, actor: PydanticUser) -> PydanticAgentState:
         """Fetch an agent by its ID."""
-        with self.session_maker() as session:
+        with db_registry.session() as session:
             agent = AgentModel.read(db_session=session, name=agent_name, actor=actor)
             return agent.to_pydantic()
 
@@ -599,7 +597,7 @@ class AgentManager:
         Raises:
             NoResultFound: If agent doesn't exist
         """
-        with self.session_maker() as session:
+        with db_registry.session() as session:
             # Retrieve the agent
             logger.debug(f"Hard deleting Agent with ID: {agent_id} with actor={actor}")
             agent = AgentModel.read(db_session=session, identifier=agent_id, actor=actor)
@@ -635,7 +633,7 @@ class AgentManager:
 
     @enforce_types
     def serialize(self, agent_id: str, actor: PydanticUser) -> AgentSchema:
-        with self.session_maker() as session:
+        with db_registry.session() as session:
             agent = AgentModel.read(db_session=session, identifier=agent_id, actor=actor)
             schema = MarshmallowAgentSchema(session=session, actor=actor)
             data = schema.dump(agent)
@@ -665,7 +663,7 @@ class AgentManager:
 
         serialized_agent_dict[MarshmallowAgentSchema.FIELD_MESSAGE_IDS] = message_ids
 
-        with self.session_maker() as session:
+        with db_registry.session() as session:
             schema = MarshmallowAgentSchema(session=session, actor=actor)
             agent = schema.load(serialized_agent_dict, session=session)
 
@@ -728,7 +726,7 @@ class AgentManager:
         Returns:
             PydanticAgentState: The updated agent as a Pydantic model.
         """
-        with self.session_maker() as session:
+        with db_registry.session() as session:
             # Retrieve the agent
             agent = AgentModel.read(db_session=session, identifier=agent_id, actor=actor)
 
@@ -767,7 +765,7 @@ class AgentManager:
 
     @enforce_types
     def list_groups(self, agent_id: str, actor: PydanticUser, manager_type: Optional[str] = None) -> List[PydanticGroup]:
-        with self.session_maker() as session:
+        with db_registry.session() as session:
             agent = AgentModel.read(db_session=session, identifier=agent_id, actor=actor)
             if manager_type:
                 return [group.to_pydantic() for group in agent.groups if group.manager_type == manager_type]
@@ -908,7 +906,7 @@ class AgentManager:
         Returns:
             PydanticAgentState: The updated agent state with no linked messages.
         """
-        with self.session_maker() as session:
+        with db_registry.session() as session:
             # Retrieve the existing agent (will raise NoResultFound if invalid)
             agent = AgentModel.read(db_session=session, identifier=agent_id, actor=actor)
 
@@ -985,6 +983,17 @@ class AgentManager:
         )
         return agent_state
 
+    @enforce_types
+    async def refresh_memory_async(self, agent_state: PydanticAgentState, actor: PydanticUser) -> PydanticAgentState:
+        block_ids = [b.id for b in agent_state.memory.blocks]
+        if not block_ids:
+            return agent_state
+
+        agent_state.memory.blocks = await self.block_manager.get_all_blocks_by_ids_async(
+            block_ids=[b.id for b in agent_state.memory.blocks], actor=actor
+        )
+        return agent_state
+
     # ======================================================================================================================
     # Source Management
     # ======================================================================================================================
@@ -1003,7 +1012,7 @@ class AgentManager:
             IntegrityError: If the source is already attached to the agent
         """
 
-        with self.session_maker() as session:
+        with db_registry.session() as session:
             # Verify both agent and source exist and user has permission to access them
             agent = AgentModel.read(db_session=session, identifier=agent_id, actor=actor)
 
@@ -1056,7 +1065,7 @@ class AgentManager:
         Returns:
             List[str]: List of source IDs attached to the agent
         """
-        with self.session_maker() as session:
+        with db_registry.session() as session:
             # Verify agent exists and user has permission to access it
             agent = AgentModel.read(db_session=session, identifier=agent_id, actor=actor)
 
@@ -1073,7 +1082,7 @@ class AgentManager:
             source_id: ID of the source to detach
             actor: User performing the action
         """
-        with self.session_maker() as session:
+        with db_registry.session() as session:
             # Verify agent exists and user has permission to access it
             agent = AgentModel.read(db_session=session, identifier=agent_id, actor=actor)
 
@@ -1101,7 +1110,7 @@ class AgentManager:
         actor: PydanticUser,
     ) -> PydanticBlock:
         """Gets a block attached to an agent by its label."""
-        with self.session_maker() as session:
+        with db_registry.session() as session:
             agent = AgentModel.read(db_session=session, identifier=agent_id, actor=actor)
             for block in agent.core_memory:
                 if block.label == block_label:
@@ -1117,7 +1126,7 @@ class AgentManager:
         actor: PydanticUser,
     ) -> PydanticAgentState:
         """Updates which block is assigned to a specific label for an agent."""
-        with self.session_maker() as session:
+        with db_registry.session() as session:
             agent = AgentModel.read(db_session=session, identifier=agent_id, actor=actor)
             new_block = BlockModel.read(db_session=session, identifier=new_block_id, actor=actor)
 
@@ -1135,7 +1144,7 @@ class AgentManager:
     @enforce_types
     def attach_block(self, agent_id: str, block_id: str, actor: PydanticUser) -> PydanticAgentState:
         """Attaches a block to an agent."""
-        with self.session_maker() as session:
+        with db_registry.session() as session:
             agent = AgentModel.read(db_session=session, identifier=agent_id, actor=actor)
             block = BlockModel.read(db_session=session, identifier=block_id, actor=actor)
 
@@ -1151,7 +1160,7 @@ class AgentManager:
         actor: PydanticUser,
     ) -> PydanticAgentState:
         """Detaches a block from an agent."""
-        with self.session_maker() as session:
+        with db_registry.session() as session:
             agent = AgentModel.read(db_session=session, identifier=agent_id, actor=actor)
             original_length = len(agent.core_memory)
 
@@ -1171,7 +1180,7 @@ class AgentManager:
         actor: PydanticUser,
     ) -> PydanticAgentState:
         """Detaches a block with the specified label from an agent."""
-        with self.session_maker() as session:
+        with db_registry.session() as session:
             agent = AgentModel.read(db_session=session, identifier=agent_id, actor=actor)
             original_length = len(agent.core_memory)
 
@@ -1215,7 +1224,7 @@ class AgentManager:
             embedded_text = np.array(embedded_text)
             embedded_text = np.pad(embedded_text, (0, MAX_EMBEDDING_DIM - embedded_text.shape[0]), mode="constant").tolist()
 
-        with self.session_maker() as session:
+        with db_registry.session() as session:
             # Start with base query for source passages
             source_passages = None
             if not agent_only:  # Include source passages
@@ -1389,7 +1398,7 @@ class AgentManager:
         agent_only: bool = False,
     ) -> List[PydanticPassage]:
         """Lists all passages attached to an agent."""
-        with self.session_maker() as session:
+        with db_registry.session() as session:
             main_query = self._build_passage_query(
                 actor=actor,
                 agent_id=agent_id,
@@ -1447,7 +1456,7 @@ class AgentManager:
         agent_only: bool = False,
     ) -> int:
         """Returns the count of passages matching the given criteria."""
-        with self.session_maker() as session:
+        with db_registry.session() as session:
             main_query = self._build_passage_query(
                 actor=actor,
                 agent_id=agent_id,
@@ -1487,7 +1496,7 @@ class AgentManager:
         Returns:
             PydanticAgentState: The updated agent state.
         """
-        with self.session_maker() as session:
+        with db_registry.session() as session:
             # Verify the agent exists and user has permission to access it
             agent = AgentModel.read(db_session=session, identifier=agent_id, actor=actor)
 
@@ -1522,7 +1531,7 @@ class AgentManager:
         Returns:
             PydanticAgentState: The updated agent state.
         """
-        with self.session_maker() as session:
+        with db_registry.session() as session:
             # Verify the agent exists and user has permission to access it
             agent = AgentModel.read(db_session=session, identifier=agent_id, actor=actor)
 
@@ -1551,7 +1560,7 @@ class AgentManager:
         Returns:
             List[PydanticTool]: List of tools attached to the agent.
         """
-        with self.session_maker() as session:
+        with db_registry.session() as session:
             agent = AgentModel.read(db_session=session, identifier=agent_id, actor=actor)
             return [tool.to_pydantic() for tool in agent.tools]
 
@@ -1574,7 +1583,7 @@ class AgentManager:
         Returns:
             List[str]: List of all tags.
         """
-        with self.session_maker() as session:
+        with db_registry.session() as session:
             query = (
                 session.query(AgentsTags.tag)
                 .join(AgentModel, AgentModel.id == AgentsTags.agent_id)