letta-nightly 0.6.50.dev20250411104155__py3-none-any.whl → 0.6.52.dev20250412051016__py3-none-any.whl

letta/server/server.py

@@ -95,7 +95,7 @@ from letta.services.tool_manager import ToolManager
 from letta.services.user_manager import UserManager
 from letta.settings import model_settings, settings, tool_settings
 from letta.sleeptime_agent import SleeptimeAgent
-from letta.tracing import trace_method
+from letta.tracing import log_event, trace_method
 from letta.utils import get_friendly_error_msg, make_key
 
 config = LettaConfig.load()
@@ -706,18 +706,21 @@ class SyncServer(Server):
                 command = command[1:]  # strip the prefix
         return self._command(user_id=user_id, agent_id=agent_id, command=command)
 
+    @trace_method
     def get_cached_llm_config(self, **kwargs):
         key = make_key(**kwargs)
         if key not in self._llm_config_cache:
             self._llm_config_cache[key] = self.get_llm_config_from_handle(**kwargs)
         return self._llm_config_cache[key]
 
+    @trace_method
     def get_cached_embedding_config(self, **kwargs):
         key = make_key(**kwargs)
         if key not in self._embedding_config_cache:
             self._embedding_config_cache[key] = self.get_embedding_config_from_handle(**kwargs)
         return self._embedding_config_cache[key]
 
+    @trace_method
     def create_agent(
         self,
         request: CreateAgent,
@@ -728,26 +731,34 @@ class SyncServer(Server):
         if request.llm_config is None:
             if request.model is None:
                 raise ValueError("Must specify either model or llm_config in request")
-            request.llm_config = self.get_cached_llm_config(
-                handle=request.model,
-                context_window_limit=request.context_window_limit,
-                max_tokens=request.max_tokens,
-                max_reasoning_tokens=request.max_reasoning_tokens,
-                enable_reasoner=request.enable_reasoner,
-            )
+            config_params = {
+                "handle": request.model,
+                "context_window_limit": request.context_window_limit,
+                "max_tokens": request.max_tokens,
+                "max_reasoning_tokens": request.max_reasoning_tokens,
+                "enable_reasoner": request.enable_reasoner,
+            }
+            log_event(name="start get_cached_llm_config", attributes=config_params)
+            request.llm_config = self.get_cached_llm_config(**config_params)
+            log_event(name="end get_cached_llm_config", attributes=config_params)
 
         if request.embedding_config is None:
             if request.embedding is None:
                 raise ValueError("Must specify either embedding or embedding_config in request")
-            request.embedding_config = self.get_cached_embedding_config(
-                handle=request.embedding,
-                embedding_chunk_size=request.embedding_chunk_size or constants.DEFAULT_EMBEDDING_CHUNK_SIZE,
-            )
-
+            embedding_config_params = {
+                "handle": request.embedding,
+                "embedding_chunk_size": request.embedding_chunk_size or constants.DEFAULT_EMBEDDING_CHUNK_SIZE,
+            }
+            log_event(name="start get_cached_embedding_config", attributes=embedding_config_params)
+            request.embedding_config = self.get_cached_embedding_config(**embedding_config_params)
+            log_event(name="end get_cached_embedding_config", attributes=embedding_config_params)
+
+        log_event(name="start create_agent db")
         main_agent = self.agent_manager.create_agent(
             agent_create=request,
             actor=actor,
         )
+        log_event(name="end create_agent db")
 
         if request.enable_sleeptime:
             main_agent = self.create_sleeptime_agent(main_agent=main_agent, actor=actor)
@@ -1108,6 +1119,7 @@ class SyncServer(Server):
         # Merge the two dictionaries, keeping the values from providers_from_db where conflicts occur
         return {**providers_from_env, **providers_from_db}.values()
 
+    @trace_method
     def get_llm_config_from_handle(
         self,
         handle: str,
@@ -1157,6 +1169,7 @@ class SyncServer(Server):
 
         return llm_config
 
+    @trace_method
     def get_embedding_config_from_handle(
         self, handle: str, embedding_chunk_size: int = constants.DEFAULT_EMBEDDING_CHUNK_SIZE
     ) -> EmbeddingConfig:
@@ -1259,16 +1272,16 @@ class SyncServer(Server):
         if tool_source_type is not None and tool_source_type != "python":
             raise ValueError("Only Python source code is supported at this time")
 
-        # NOTE: we're creating a floating Tool object and NOT persisting to DB
-        tool = Tool(
-            name=tool_name,
-            source_code=tool_source,
-            args_json_schema=tool_args_json_schema,
-        )
-
         # If tools_json_schema is explicitly passed in, override it on the created Tool object
         if tool_json_schema:
-            tool.json_schema = tool_json_schema
+            tool = Tool(name=tool_name, source_code=tool_source, json_schema=tool_json_schema)
+        else:
+            # NOTE: we're creating a floating Tool object and NOT persisting to DB
+            tool = Tool(
+                name=tool_name,
+                source_code=tool_source,
+                args_json_schema=tool_args_json_schema,
+            )
 
         assert tool.name is not None, "Failed to create tool object"
 

letta/services/agent_manager.py

@@ -42,8 +42,8 @@ from letta.schemas.message import MessageCreate, MessageUpdate
 from letta.schemas.passage import Passage as PydanticPassage
 from letta.schemas.source import Source as PydanticSource
 from letta.schemas.tool import Tool as PydanticTool
-from letta.schemas.tool_rule import ChildToolRule as PydanticChildToolRule
 from letta.schemas.tool_rule import ContinueToolRule as PydanticContinueToolRule
+from letta.schemas.tool_rule import ParentToolRule as PydanticParentToolRule
 from letta.schemas.tool_rule import TerminalToolRule as PydanticTerminalToolRule
 from letta.schemas.tool_rule import ToolRule as PydanticToolRule
 from letta.schemas.user import User as PydanticUser
@@ -70,6 +70,7 @@ from letta.services.passage_manager import PassageManager
 from letta.services.source_manager import SourceManager
 from letta.services.tool_manager import ToolManager
 from letta.settings import settings
+from letta.tracing import trace_method
 from letta.utils import enforce_types, united_diff
 
 logger = get_logger(__name__)
@@ -93,6 +94,7 @@ class AgentManager:
     # ======================================================================================================================
     # Basic CRUD operations
     # ======================================================================================================================
+    @trace_method
     @enforce_types
     def create_agent(
         self,
@@ -162,7 +164,7 @@ class AgentManager:
                     tool_rules.append(PydanticContinueToolRule(tool_name=tool_name))
 
             if agent_create.agent_type == AgentType.sleeptime_agent:
-                tool_rules.append(PydanticChildToolRule(tool_name="view_core_memory_with_line_numbers", children=["core_memory_insert"]))
+                tool_rules.append(PydanticParentToolRule(tool_name="view_core_memory_with_line_numbers", children=["core_memory_insert"]))
 
         # if custom rules, check tool rules are valid
         if agent_create.tool_rules:
@@ -213,7 +215,6 @@ class AgentManager:
             # We always need the system prompt up front
             system_message_obj = PydanticMessage.dict_to_message(
                 agent_id=agent_state.id,
-                user_id=agent_state.created_by_id,
                 model=agent_state.llm_config.model,
                 openai_message_dict=init_messages[0],
             )
@@ -224,9 +225,7 @@ class AgentManager:
             )
         else:
             init_messages = [
-                PydanticMessage.dict_to_message(
-                    agent_id=agent_state.id, user_id=agent_state.created_by_id, model=agent_state.llm_config.model, openai_message_dict=msg
-                )
+                PydanticMessage.dict_to_message(agent_id=agent_state.id, model=agent_state.llm_config.model, openai_message_dict=msg)
                 for msg in init_messages
             ]
 
@@ -661,6 +660,9 @@ class AgentManager:
         message_ids = self.get_agent_by_id(agent_id=agent_id, actor=actor).message_ids
         return self.message_manager.get_message_by_id(message_id=message_ids[0], actor=actor)
 
+    # TODO: This is duplicated below
+    # TODO: This is legacy code and should be cleaned up
+    # TODO: A lot of the memory "compilation" should be offset to a separate class
     @enforce_types
     def rebuild_system_prompt(self, agent_id: str, actor: PydanticUser, force=False, update_timestamp=True) -> PydanticAgentState:
         """Rebuilds the system message with the latest memory object and any shared memory block updates
@@ -714,7 +716,6 @@ class AgentManager:
             # Swap the system message out (only if there is a diff)
             message = PydanticMessage.dict_to_message(
                 agent_id=agent_id,
-                user_id=actor.id,
                 model=agent_state.llm_config.model,
                 openai_message_dict={"role": "system", "content": new_system_message_str},
             )
@@ -801,7 +802,6 @@ class AgentManager:
             )
             system_message = PydanticMessage.dict_to_message(
                 agent_id=agent_state.id,
-                user_id=agent_state.created_by_id,
                 model=agent_state.llm_config.model,
                 openai_message_dict=init_messages[0],
             )
@@ -845,6 +845,10 @@ class AgentManager:
 
     @enforce_types
     def refresh_memory(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 = self.block_manager.get_all_blocks_by_ids(
             block_ids=[b.id for b in agent_state.memory.blocks], actor=actor
         )
@@ -903,7 +907,7 @@ class AgentManager:
         # get the agent
         agent = self.get_agent_by_id(agent_id=agent_id, actor=actor)
         message = PydanticMessage.dict_to_message(
-            agent_id=agent.id, user_id=actor.id, model=agent.llm_config.model, openai_message_dict={"role": "system", "content": content}
+            agent_id=agent.id, model=agent.llm_config.model, openai_message_dict={"role": "system", "content": content}
         )
 
         # update agent in-context message IDs

letta/services/block_manager.py

@@ -109,11 +109,9 @@ class BlockManager:
 
     @enforce_types
     def get_all_blocks_by_ids(self, block_ids: List[str], actor: Optional[PydanticUser] = None) -> List[PydanticBlock]:
-        """Retrieve blocks by their names."""
+        """Retrieve blocks by their ids."""
         with self.session_maker() as session:
-            blocks = list(
-                map(lambda obj: obj.to_pydantic(), BlockModel.read_multiple(db_session=session, identifiers=block_ids, actor=actor))
-            )
+            blocks = [block.to_pydantic() for block in BlockModel.read_multiple(db_session=session, identifiers=block_ids, actor=actor)]
             # backwards compatibility. previous implementation added None for every block not found.
             blocks.extend([None for _ in range(len(block_ids) - len(blocks))])
             return blocks

letta/services/identity_manager.py

@@ -8,7 +8,7 @@ from letta.orm.agent import Agent as AgentModel
 from letta.orm.block import Block as BlockModel
 from letta.orm.identity import Identity as IdentityModel
 from letta.schemas.identity import Identity as PydanticIdentity
-from letta.schemas.identity import IdentityCreate, IdentityType, IdentityUpdate
+from letta.schemas.identity import IdentityCreate, IdentityProperty, IdentityType, IdentityUpdate, IdentityUpsert
 from letta.schemas.user import User as PydanticUser
 from letta.utils import enforce_types
 
@@ -81,7 +81,7 @@ class IdentityManager:
             return new_identity.to_pydantic()
 
     @enforce_types
-    def upsert_identity(self, identity: IdentityCreate, actor: PydanticUser) -> PydanticIdentity:
+    def upsert_identity(self, identity: IdentityUpsert, actor: PydanticUser) -> PydanticIdentity:
         with self.session_maker() as session:
             existing_identity = IdentityModel.read(
                 db_session=session,
@@ -92,7 +92,7 @@ class IdentityManager:
             )
 
         if existing_identity is None:
-            return self.create_identity(identity=identity, actor=actor)
+            return self.create_identity(identity=IdentityCreate(**identity.model_dump()), actor=actor)
         else:
             identity_update = IdentityUpdate(
                 name=identity.name,
@@ -137,8 +137,10 @@ class IdentityManager:
             if replace:
                 existing_identity.properties = [prop.model_dump() for prop in identity.properties]
             else:
-                new_properties = existing_identity.properties + [prop.model_dump() for prop in identity.properties]
-                existing_identity.properties = new_properties
+                new_properties = {old_prop["key"]: old_prop for old_prop in existing_identity.properties} | {
+                    new_prop.key: new_prop.model_dump() for new_prop in identity.properties
+                }
+                existing_identity.properties = list(new_properties.values())
 
         if identity.agent_ids is not None:
             self._process_relationship(
@@ -163,6 +165,20 @@ class IdentityManager:
         existing_identity.update(session, actor=actor)
         return existing_identity.to_pydantic()
 
+    @enforce_types
+    def upsert_identity_properties(self, identity_id: str, properties: List[IdentityProperty], actor: PydanticUser) -> PydanticIdentity:
+        with self.session_maker() as session:
+            existing_identity = IdentityModel.read(db_session=session, identifier=identity_id, actor=actor)
+            if existing_identity is None:
+                raise HTTPException(status_code=404, detail="Identity not found")
+            return self._update_identity(
+                session=session,
+                existing_identity=existing_identity,
+                identity=IdentityUpdate(properties=properties),
+                actor=actor,
+                replace=True,
+            )
+
     @enforce_types
     def delete_identity(self, identity_id: str, actor: PydanticUser) -> None:
         with self.session_maker() as session:

letta/services/llm_batch_manager.py

@@ -28,7 +28,7 @@ class LLMBatchManager:
         self.session_maker = db_context
 
     @enforce_types
-    def create_batch_request(
+    def create_batch_job(
         self,
         llm_provider: ProviderType,
         create_batch_response: BetaMessageBatch,
@@ -172,6 +172,26 @@ class LLMBatchManager:
 
             return item.update(db_session=session, actor=actor).to_pydantic()
 
+    @enforce_types
+    def list_batch_items(
+        self,
+        batch_id: str,
+        limit: Optional[int] = None,
+        actor: Optional[PydanticUser] = None,
+    ) -> List[PydanticLLMBatchItem]:
+        """List all batch items for a given batch_id, optionally filtered by organization and limited in count."""
+        with self.session_maker() as session:
+            query = session.query(LLMBatchItem).filter(LLMBatchItem.batch_id == batch_id)
+
+            if actor is not None:
+                query = query.filter(LLMBatchItem.organization_id == actor.organization_id)
+
+            if limit:
+                query = query.limit(limit)
+
+            results = query.all()
+            return [item.to_pydantic() for item in results]
+
     def bulk_update_batch_items_by_agent(
         self,
         updates: List[ItemUpdateInfo],

letta/services/summarizer/summarizer.py

@@ -4,8 +4,8 @@ from typing import List, Tuple
 
 from letta.agents.base_agent import BaseAgent
 from letta.schemas.enums import MessageRole
-from letta.schemas.message import Message
-from letta.schemas.openai.chat_completion_request import UserMessage
+from letta.schemas.letta_message_content import TextContent
+from letta.schemas.message import Message, MessageCreate
 from letta.services.summarizer.enums import SummarizationMode
 
 
@@ -95,8 +95,15 @@ class Summarizer:
             "It should be in note-taking format in natural English. You are to return the new, updated memory only."
         )
 
-        messages = await self.summarizer_agent.step(UserMessage(content=summary_request_text))
-        current_summary = "\n".join([m.content[0].text for m in messages])
+        response = await self.summarizer_agent.step(
+            input_messages=[
+                MessageCreate(
+                    role=MessageRole.user,
+                    content=[TextContent(text=summary_request_text)],
+                ),
+            ],
+        )
+        current_summary = "\n".join([m.content[0].text for m in response.messages if m.message_type == "assistant_message"])
         current_summary = f"{self.summary_prefix}{current_summary}"
 
         return updated_in_context_messages, current_summary, True

letta/services/tool_manager.py

@@ -54,7 +54,7 @@ class ToolManager:
 
             # If there's anything to update
             if update_data:
-                self.update_tool_by_id(tool.id, ToolUpdate(**update_data), actor)
+                tool = self.update_tool_by_id(tool.id, ToolUpdate(**update_data), actor)
             else:
                 printd(
                     f"`create_or_update_tool` was called with user_id={actor.id}, organization_id={actor.organization_id}, name={pydantic_tool.name}, but found existing tool with nothing to update."

letta/settings.py

@@ -205,6 +205,7 @@ class Settings(BaseSettings):
     httpx_keepalive_expiry: float = 120.0
 
     # cron job parameters
+    enable_batch_job_polling: bool = False
     poll_running_llm_batches_interval_seconds: int = 5 * 60
 
     @property

letta/utils.py

@@ -828,7 +828,7 @@ def parse_json(string) -> dict:
             raise ValueError(f"JSON from string input ({string}) is not a dictionary (type {type(result)}): {result}")
         return result
     except Exception as e:
-        print(f"Error parsing json with json package: {e}")
+        print(f"Error parsing json with json package, falling back to demjson: {e}")
 
     try:
         result = demjson.decode(string)
@@ -836,7 +836,7 @@ def parse_json(string) -> dict:
             raise ValueError(f"JSON from string input ({string}) is not a dictionary (type {type(result)}): {result}")
         return result
     except demjson.JSONDecodeError as e:
-        print(f"Error parsing json with demjson package: {e}")
+        print(f"Error parsing json with demjson package (fatal): {e}")
         raise e
 
 

{letta_nightly-0.6.50.dev20250411104155.dist-info → letta_nightly-0.6.52.dev20250412051016.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: letta-nightly
-Version: 0.6.50.dev20250411104155
+Version: 0.6.52.dev20250412051016
 Summary: Create LLM agents with long-term memory and custom tools
 License: Apache License
 Author: Letta Team
@@ -50,7 +50,7 @@ Requires-Dist: isort (>=5.13.2,<6.0.0) ; extra == "dev" or extra == "all"
 Requires-Dist: jinja2 (>=3.1.5,<4.0.0)
 Requires-Dist: langchain (>=0.3.7,<0.4.0) ; extra == "external-tools" or extra == "desktop" or extra == "all"
 Requires-Dist: langchain-community (>=0.3.7,<0.4.0) ; extra == "external-tools" or extra == "desktop" or extra == "all"
-Requires-Dist: letta_client (>=0.1.97,<0.2.0)
+Requires-Dist: letta_client (>=0.1.104,<0.2.0)
 Requires-Dist: llama-index (>=0.12.2,<0.13.0)
 Requires-Dist: llama-index-embeddings-openai (>=0.3.1,<0.4.0)
 Requires-Dist: locust (>=2.31.5,<3.0.0) ; extra == "dev" or extra == "desktop" or extra == "all"
@@ -255,7 +255,7 @@ No, the data in your Letta server database stays on your machine. The Letta ADE
 
 > _"Do I have to use your ADE? Can I build my own?"_
 
-The ADE is built on top of the (fully open source) Letta server and Letta Agents API. You can build your own application like the ADE on top of the REST API (view the documention [here](https://docs.letta.com/api-reference)).
+The ADE is built on top of the (fully open source) Letta server and Letta Agents API. You can build your own application like the ADE on top of the REST API (view the documentation [here](https://docs.letta.com/api-reference)).
 
 > _"Can I interact with Letta agents via the CLI?"_