letta-nightly 0.7.22.dev20250523081403__py3-none-any.whl → 0.7.23.dev20250523164139__py3-none-any.whl

letta/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "0.7.22"
+__version__ = "0.7.23"
 
 # import clients
 from letta.client.client import RESTClient

letta/llm_api/google_ai_client.py

@@ -7,7 +7,10 @@ from letta.errors import ErrorCode, LLMAuthenticationError, LLMError
 from letta.llm_api.google_constants import GOOGLE_MODEL_FOR_API_KEY_CHECK
 from letta.llm_api.google_vertex_client import GoogleVertexClient
 from letta.log import get_logger
+from letta.schemas.llm_config import LLMConfig
+from letta.schemas.message import Message as PydanticMessage
 from letta.settings import model_settings
+from letta.tracing import trace_method
 
 logger = get_logger(__name__)
 
@@ -17,6 +20,18 @@ class GoogleAIClient(GoogleVertexClient):
     def _get_client(self):
         return genai.Client(api_key=model_settings.gemini_api_key)
 
+    @trace_method
+    def build_request_data(
+        self,
+        messages: List[PydanticMessage],
+        llm_config: LLMConfig,
+        tools: List[dict],
+        force_tool_call: Optional[str] = None,
+    ) -> dict:
+        request = super().build_request_data(messages, llm_config, tools, force_tool_call)
+        del request["config"]["thinking_config"]
+        return request
+
 
 def get_gemini_endpoint_and_headers(
     base_url: str, model: Optional[str], api_key: str, key_in_header: bool = True, generate_content: bool = False

letta/llm_api/google_vertex_client.py

@@ -244,11 +244,10 @@ class GoogleVertexClient(LLMClientBase):
         # Add thinking_config
         # If enable_reasoner is False, set thinking_budget to 0
         # Otherwise, use the value from max_reasoning_tokens
-        if llm_config.enable_reasoner:
-            thinking_config = ThinkingConfig(
-                thinking_budget=llm_config.max_reasoning_tokens,
-            )
-            request_data["config"]["thinking_config"] = thinking_config.model_dump()
+        thinking_config = ThinkingConfig(
+            thinking_budget=llm_config.max_reasoning_tokens if llm_config.enable_reasoner else 0,
+        )
+        request_data["config"]["thinking_config"] = thinking_config.model_dump()
 
         return request_data
 

letta/schemas/providers.py

@@ -54,7 +54,7 @@ class Provider(ProviderBase):
         return []
 
     async def list_embedding_models_async(self) -> List[EmbeddingConfig]:
-        return []
+        return self.list_embedding_models()
 
     def get_model_context_window(self, model_name: str) -> Optional[int]:
         raise NotImplementedError

letta/server/db.py

@@ -17,8 +17,6 @@ from letta.tracing import trace_method
 
 logger = get_logger(__name__)
 
-logger = get_logger(__name__)
-
 
 def print_sqlite_schema_error():
     """Print a formatted error message for SQLite schema issues"""

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

@@ -50,47 +50,46 @@ def count_blocks(
 
 
 @router.post("/", response_model=Block, operation_id="create_block")
-def create_block(
+async def create_block(
     create_block: CreateBlock = Body(...),
     server: SyncServer = Depends(get_letta_server),
     actor_id: Optional[str] = Header(None, alias="user_id"),
 ):
-    actor = server.user_manager.get_user_or_default(user_id=actor_id)
+    actor = await server.user_manager.get_actor_or_default_async(actor_id=actor_id)
     block = Block(**create_block.model_dump())
-    return server.block_manager.create_or_update_block(actor=actor, block=block)
+    return await server.block_manager.create_or_update_block_async(actor=actor, block=block)
 
 
 @router.patch("/{block_id}", response_model=Block, operation_id="modify_block")
-def modify_block(
+async def modify_block(
     block_id: str,
     block_update: BlockUpdate = Body(...),
     server: SyncServer = Depends(get_letta_server),
     actor_id: Optional[str] = Header(None, alias="user_id"),
 ):
-    actor = server.user_manager.get_user_or_default(user_id=actor_id)
-    return server.block_manager.update_block(block_id=block_id, block_update=block_update, actor=actor)
+    actor = await server.user_manager.get_actor_or_default_async(actor_id=actor_id)
+    return await server.block_manager.update_block_async(block_id=block_id, block_update=block_update, actor=actor)
 
 
 @router.delete("/{block_id}", response_model=Block, operation_id="delete_block")
-def delete_block(
+async def delete_block(
     block_id: str,
     server: SyncServer = Depends(get_letta_server),
     actor_id: Optional[str] = Header(None, alias="user_id"),
 ):
-    actor = server.user_manager.get_user_or_default(user_id=actor_id)
-    return server.block_manager.delete_block(block_id=block_id, actor=actor)
+    actor = await server.user_manager.get_actor_or_default_async(actor_id=actor_id)
+    return await server.block_manager.delete_block_async(block_id=block_id, actor=actor)
 
 
 @router.get("/{block_id}", response_model=Block, operation_id="retrieve_block")
-def retrieve_block(
+async def retrieve_block(
     block_id: str,
     server: SyncServer = Depends(get_letta_server),
     actor_id: Optional[str] = Header(None, alias="user_id"),
 ):
-    print("call get block", block_id)
-    actor = server.user_manager.get_user_or_default(user_id=actor_id)
+    actor = await server.user_manager.get_actor_or_default_async(actor_id=actor_id)
     try:
-        block = server.block_manager.get_block_by_id(block_id=block_id, actor=actor)
+        block = await server.block_manager.get_block_by_id_async(block_id=block_id, actor=actor)
         if block is None:
             raise HTTPException(status_code=404, detail="Block not found")
         return block

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

@@ -78,17 +78,6 @@ async def list_sources(
     return await server.source_manager.list_sources(actor=actor)
 
 
-@router.get("/count", response_model=int, operation_id="count_sources")
-def count_sources(
-    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
-):
-    """
-    Count all data sources created by a user.
-    """
-    return server.source_manager.size(actor=server.user_manager.get_user_or_default(user_id=actor_id))
-
-
 @router.post("/", response_model=Source, operation_id="create_source")
 async def create_source(
     source_create: SourceCreate,

letta/server/server.py

@@ -741,6 +741,13 @@ class SyncServer(Server):
             self._llm_config_cache[key] = self.get_llm_config_from_handle(actor=actor, **kwargs)
         return self._llm_config_cache[key]
 
+    @trace_method
+    async def get_cached_llm_config_async(self, actor: User, **kwargs):
+        key = make_key(**kwargs)
+        if key not in self._llm_config_cache:
+            self._llm_config_cache[key] = await self.get_llm_config_from_handle_async(actor=actor, **kwargs)
+        return self._llm_config_cache[key]
+
     @trace_method
     def get_cached_embedding_config(self, actor: User, **kwargs):
         key = make_key(**kwargs)
@@ -748,6 +755,13 @@ class SyncServer(Server):
             self._embedding_config_cache[key] = self.get_embedding_config_from_handle(actor=actor, **kwargs)
         return self._embedding_config_cache[key]
 
+    @trace_method
+    async def get_cached_embedding_config_async(self, actor: User, **kwargs):
+        key = make_key(**kwargs)
+        if key not in self._embedding_config_cache:
+            self._embedding_config_cache[key] = await self.get_embedding_config_from_handle_async(actor=actor, **kwargs)
+        return self._embedding_config_cache[key]
+
     @trace_method
     def create_agent(
         self,
@@ -815,7 +829,7 @@ class SyncServer(Server):
                 "enable_reasoner": request.enable_reasoner,
             }
             log_event(name="start get_cached_llm_config", attributes=config_params)
-            request.llm_config = self.get_cached_llm_config(actor=actor, **config_params)
+            request.llm_config = await self.get_cached_llm_config_async(actor=actor, **config_params)
             log_event(name="end get_cached_llm_config", attributes=config_params)
 
         if request.embedding_config is None:
@@ -826,7 +840,7 @@ class SyncServer(Server):
                 "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(actor=actor, **embedding_config_params)
+            request.embedding_config = await self.get_cached_embedding_config_async(actor=actor, **embedding_config_params)
             log_event(name="end get_cached_embedding_config", attributes=embedding_config_params)
 
         log_event(name="start create_agent db")
@@ -877,10 +891,10 @@ class SyncServer(Server):
         actor: User,
     ) -> AgentState:
         if request.model is not None:
-            request.llm_config = self.get_llm_config_from_handle(handle=request.model, actor=actor)
+            request.llm_config = await self.get_llm_config_from_handle_async(handle=request.model, actor=actor)
 
         if request.embedding is not None:
-            request.embedding_config = self.get_embedding_config_from_handle(handle=request.embedding, actor=actor)
+            request.embedding_config = await self.get_embedding_config_from_handle_async(handle=request.embedding, actor=actor)
 
         if request.enable_sleeptime:
             agent = self.agent_manager.get_agent_by_id(agent_id=agent_id, actor=actor)
@@ -1568,6 +1582,61 @@ class SyncServer(Server):
 
         return llm_config
 
+    @trace_method
+    async def get_llm_config_from_handle_async(
+        self,
+        actor: User,
+        handle: str,
+        context_window_limit: Optional[int] = None,
+        max_tokens: Optional[int] = None,
+        max_reasoning_tokens: Optional[int] = None,
+        enable_reasoner: Optional[bool] = None,
+    ) -> LLMConfig:
+        try:
+            provider_name, model_name = handle.split("/", 1)
+            provider = await self.get_provider_from_name_async(provider_name, actor)
+
+            all_llm_configs = await provider.list_llm_models_async()
+            llm_configs = [config for config in all_llm_configs if config.handle == handle]
+            if not llm_configs:
+                llm_configs = [config for config in all_llm_configs if config.model == model_name]
+            if not llm_configs:
+                available_handles = [config.handle for config in all_llm_configs]
+                raise HandleNotFoundError(handle, available_handles)
+        except ValueError as e:
+            llm_configs = [config for config in self.get_local_llm_configs() if config.handle == handle]
+            if not llm_configs:
+                llm_configs = [config for config in self.get_local_llm_configs() if config.model == model_name]
+            if not llm_configs:
+                raise e
+
+        if len(llm_configs) == 1:
+            llm_config = llm_configs[0]
+        elif len(llm_configs) > 1:
+            raise ValueError(f"Multiple LLM models with name {model_name} supported by {provider_name}")
+        else:
+            llm_config = llm_configs[0]
+
+        if context_window_limit is not None:
+            if context_window_limit > llm_config.context_window:
+                raise ValueError(f"Context window limit ({context_window_limit}) is greater than maximum of ({llm_config.context_window})")
+            llm_config.context_window = context_window_limit
+        else:
+            llm_config.context_window = min(llm_config.context_window, model_settings.global_max_context_window_limit)
+
+        if max_tokens is not None:
+            llm_config.max_tokens = max_tokens
+        if max_reasoning_tokens is not None:
+            if not max_tokens or max_reasoning_tokens > max_tokens:
+                raise ValueError(f"Max reasoning tokens ({max_reasoning_tokens}) must be less than max tokens ({max_tokens})")
+            llm_config.max_reasoning_tokens = max_reasoning_tokens
+        if enable_reasoner is not None:
+            llm_config.enable_reasoner = enable_reasoner
+            if enable_reasoner and llm_config.model_endpoint_type == "anthropic":
+                llm_config.put_inner_thoughts_in_kwargs = False
+
+        return llm_config
+
     @trace_method
     def get_embedding_config_from_handle(
         self, actor: User, handle: str, embedding_chunk_size: int = constants.DEFAULT_EMBEDDING_CHUNK_SIZE
@@ -1597,6 +1666,36 @@ class SyncServer(Server):
 
         return embedding_config
 
+    @trace_method
+    async def get_embedding_config_from_handle_async(
+        self, actor: User, handle: str, embedding_chunk_size: int = constants.DEFAULT_EMBEDDING_CHUNK_SIZE
+    ) -> EmbeddingConfig:
+        try:
+            provider_name, model_name = handle.split("/", 1)
+            provider = await self.get_provider_from_name_async(provider_name, actor)
+
+            all_embedding_configs = await provider.list_embedding_models_async()
+            embedding_configs = [config for config in all_embedding_configs if config.handle == handle]
+            if not embedding_configs:
+                raise ValueError(f"Embedding model {model_name} is not supported by {provider_name}")
+        except ValueError as e:
+            # search local configs
+            embedding_configs = [config for config in self.get_local_embedding_configs() if config.handle == handle]
+            if not embedding_configs:
+                raise e
+
+        if len(embedding_configs) == 1:
+            embedding_config = embedding_configs[0]
+        elif len(embedding_configs) > 1:
+            raise ValueError(f"Multiple embedding models with name {model_name} supported by {provider_name}")
+        else:
+            embedding_config = embedding_configs[0]
+
+        if embedding_chunk_size:
+            embedding_config.embedding_chunk_size = embedding_chunk_size
+
+        return embedding_config
+
     def get_provider_from_name(self, provider_name: str, actor: User) -> Provider:
         providers = [provider for provider in self.get_enabled_providers(actor) if provider.name == provider_name]
         if not providers:
@@ -1608,6 +1707,18 @@ class SyncServer(Server):
 
         return provider
 
+    async def get_provider_from_name_async(self, provider_name: str, actor: User) -> Provider:
+        all_providers = await self.get_enabled_providers_async(actor)
+        providers = [provider for provider in all_providers if provider.name == provider_name]
+        if not providers:
+            raise ValueError(f"Provider {provider_name} is not supported")
+        elif len(providers) > 1:
+            raise ValueError(f"Multiple providers with name {provider_name} supported")
+        else:
+            provider = providers[0]
+
+        return provider
+
     def get_local_llm_configs(self):
         llm_models = []
         try:

letta/services/agent_manager.py

@@ -1023,34 +1023,6 @@ class AgentManager:
             return await asyncio.gather(*[agent.to_pydantic_async(include_relationships=include_relationships) for agent in agents])
 
     @trace_method
-    @enforce_types
-    async def get_agent_by_id_async(
-        self,
-        agent_id: str,
-        actor: PydanticUser,
-        include_relationships: Optional[List[str]] = None,
-    ) -> PydanticAgentState:
-        """Fetch an agent by its ID."""
-        async with db_registry.async_session() as session:
-            agent = await AgentModel.read_async(db_session=session, identifier=agent_id, actor=actor)
-            return await agent.to_pydantic_async(include_relationships=include_relationships)
-
-    @enforce_types
-    async def get_agents_by_ids_async(
-        self,
-        agent_ids: list[str],
-        actor: PydanticUser,
-        include_relationships: Optional[List[str]] = None,
-    ) -> list[PydanticAgentState]:
-        """Fetch a list of agents by their IDs."""
-        async with db_registry.async_session() as session:
-            agents = await AgentModel.read_multiple_async(
-                db_session=session,
-                identifiers=agent_ids,
-                actor=actor,
-            )
-            return await asyncio.gather(*[agent.to_pydantic_async(include_relationships=include_relationships) for agent in agents])
-
     @enforce_types
     def get_agent_by_name(self, agent_name: str, actor: PydanticUser) -> PydanticAgentState:
         """Fetch an agent by its ID."""
@@ -1321,11 +1293,6 @@ class AgentManager:
         return await self.message_manager.get_messages_by_ids_async(message_ids=agent.message_ids, actor=actor)
 
     @trace_method
-    @enforce_types
-    async def get_in_context_messages_async(self, agent_id: str, actor: PydanticUser) -> List[PydanticMessage]:
-        agent = await self.get_agent_by_id_async(agent_id=agent_id, include_relationships=[], actor=actor)
-        return await self.message_manager.get_messages_by_ids_async(message_ids=agent.message_ids, actor=actor)
-
     @enforce_types
     def get_system_message(self, agent_id: str, actor: PydanticUser) -> PydanticMessage:
         message_ids = self.get_agent_by_id(agent_id=agent_id, actor=actor).message_ids
@@ -1475,73 +1442,6 @@ class AgentManager:
             return agent_state
 
     @trace_method
-    @enforce_types
-    async def rebuild_system_prompt_async(
-        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
-
-        Updates to core memory blocks should trigger a "rebuild", which itself will create a new message object
-
-        Updates to the memory header should *not* trigger a rebuild, since that will simply flood recall storage with excess messages
-        """
-        agent_state = await self.get_agent_by_id_async(agent_id=agent_id, include_relationships=["memory"], actor=actor)
-
-        curr_system_message = await self.get_system_message_async(
-            agent_id=agent_id, actor=actor
-        )  # this is the system + memory bank, not just the system prompt
-        curr_system_message_openai = curr_system_message.to_openai_dict()
-
-        # note: we only update the system prompt if the core memory is changed
-        # this means that the archival/recall memory statistics may be someout out of date
-        curr_memory_str = agent_state.memory.compile()
-        if curr_memory_str in curr_system_message_openai["content"] and not force:
-            # NOTE: could this cause issues if a block is removed? (substring match would still work)
-            logger.debug(
-                f"Memory hasn't changed for agent id={agent_id} and actor=({actor.id}, {actor.name}), skipping system prompt rebuild"
-            )
-            return agent_state
-
-        # If the memory didn't update, we probably don't want to update the timestamp inside
-        # For example, if we're doing a system prompt swap, this should probably be False
-        if update_timestamp:
-            memory_edit_timestamp = get_utc_time()
-        else:
-            # NOTE: a bit of a hack - we pull the timestamp from the message created_by
-            memory_edit_timestamp = curr_system_message.created_at
-
-        num_messages = await self.message_manager.size_async(actor=actor, agent_id=agent_id)
-        num_archival_memories = await self.passage_manager.size_async(actor=actor, agent_id=agent_id)
-
-        # update memory (TODO: potentially update recall/archival stats separately)
-        new_system_message_str = compile_system_message(
-            system_prompt=agent_state.system,
-            in_context_memory=agent_state.memory,
-            in_context_memory_last_edit=memory_edit_timestamp,
-            recent_passages=self.list_passages(actor=actor, agent_id=agent_id, ascending=False, limit=10),
-            previous_message_count=num_messages,
-            archival_memory_size=num_archival_memories,
-        )
-
-        diff = united_diff(curr_system_message_openai["content"], new_system_message_str)
-        if len(diff) > 0:  # there was a diff
-            logger.debug(f"Rebuilding system with new memory...\nDiff:\n{diff}")
-
-            # Swap the system message out (only if there is a diff)
-            message = PydanticMessage.dict_to_message(
-                agent_id=agent_id,
-                model=agent_state.llm_config.model,
-                openai_message_dict={"role": "system", "content": new_system_message_str},
-            )
-            message = await self.message_manager.update_message_by_id_async(
-                message_id=curr_system_message.id,
-                message_update=MessageUpdate(**message.model_dump()),
-                actor=actor,
-            )
-            return await self.set_in_context_messages_async(agent_id=agent_id, message_ids=agent_state.message_ids, actor=actor)
-        else:
-            return agent_state
-
     @enforce_types
     def set_in_context_messages(self, agent_id: str, message_ids: List[str], actor: PydanticUser) -> PydanticAgentState:
         return self.update_agent(agent_id=agent_id, agent_update=UpdateAgent(message_ids=message_ids), actor=actor)
@@ -1552,10 +1452,6 @@ class AgentManager:
         return await self.update_agent_async(agent_id=agent_id, agent_update=UpdateAgent(message_ids=message_ids), actor=actor)
 
     @trace_method
-    @enforce_types
-    async def set_in_context_messages_async(self, agent_id: str, message_ids: List[str], actor: PydanticUser) -> PydanticAgentState:
-        return await self.update_agent_async(agent_id=agent_id, agent_update=UpdateAgent(message_ids=message_ids), actor=actor)
-
     @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
@@ -1786,25 +1682,6 @@ class AgentManager:
             return [source.to_pydantic() for source in agent.sources]
 
     @trace_method
-    @enforce_types
-    async def list_attached_sources_async(self, agent_id: str, actor: PydanticUser) -> List[PydanticSource]:
-        """
-        Lists all sources attached to an agent.
-
-        Args:
-            agent_id: ID of the agent to list sources for
-            actor: User performing the action
-
-        Returns:
-            List[str]: List of source IDs attached to the agent
-        """
-        async with db_registry.async_session() as session:
-            # Verify agent exists and user has permission to access it
-            agent = await AgentModel.read_async(db_session=session, identifier=agent_id, actor=actor)
-
-            # Use the lazy-loaded relationship to get sources
-            return [source.to_pydantic() for source in agent.sources]
-
     @enforce_types
     def detach_source(self, agent_id: str, source_id: str, actor: PydanticUser) -> PydanticAgentState:
         """
@@ -1896,33 +1773,6 @@ class AgentManager:
             return block.to_pydantic()
 
     @trace_method
-    @enforce_types
-    async def modify_block_by_label_async(
-        self,
-        agent_id: str,
-        block_label: str,
-        block_update: BlockUpdate,
-        actor: PydanticUser,
-    ) -> PydanticBlock:
-        """Gets a block attached to an agent by its label."""
-        async with db_registry.async_session() as session:
-            block = None
-            agent = await AgentModel.read_async(db_session=session, identifier=agent_id, actor=actor)
-            for block in agent.core_memory:
-                if block.label == block_label:
-                    block = block
-                    break
-            if not block:
-                raise NoResultFound(f"No block with label '{block_label}' found for agent '{agent_id}'")
-
-            update_data = block_update.model_dump(to_orm=True, exclude_unset=True, exclude_none=True)
-
-            for key, value in update_data.items():
-                setattr(block, key, value)
-
-            await block.update_async(session, actor=actor)
-            return block.to_pydantic()
-
     @enforce_types
     def update_block_with_label(
         self,
@@ -2337,65 +2187,6 @@ class AgentManager:
             return [p.to_pydantic() for p in passages]
 
     @trace_method
-    @enforce_types
-    async def list_passages_async(
-        self,
-        actor: PydanticUser,
-        agent_id: Optional[str] = None,
-        file_id: Optional[str] = None,
-        limit: Optional[int] = 50,
-        query_text: Optional[str] = None,
-        start_date: Optional[datetime] = None,
-        end_date: Optional[datetime] = None,
-        before: Optional[str] = None,
-        after: Optional[str] = None,
-        source_id: Optional[str] = None,
-        embed_query: bool = False,
-        ascending: bool = True,
-        embedding_config: Optional[EmbeddingConfig] = None,
-        agent_only: bool = False,
-    ) -> List[PydanticPassage]:
-        """Lists all passages attached to an agent."""
-        async with db_registry.async_session() as session:
-            main_query = self._build_passage_query(
-                actor=actor,
-                agent_id=agent_id,
-                file_id=file_id,
-                query_text=query_text,
-                start_date=start_date,
-                end_date=end_date,
-                before=before,
-                after=after,
-                source_id=source_id,
-                embed_query=embed_query,
-                ascending=ascending,
-                embedding_config=embedding_config,
-                agent_only=agent_only,
-            )
-
-            # Add limit
-            if limit:
-                main_query = main_query.limit(limit)
-
-            # Execute query
-            result = await session.execute(main_query)
-
-            passages = []
-            for row in result:
-                data = dict(row._mapping)
-                if data["agent_id"] is not None:
-                    # This is an AgentPassage - remove source fields
-                    data.pop("source_id", None)
-                    data.pop("file_id", None)
-                    passage = AgentPassage(**data)
-                else:
-                    # This is a SourcePassage - remove agent field
-                    data.pop("agent_id", None)
-                    passage = SourcePassage(**data)
-                passages.append(passage)
-
-            return [p.to_pydantic() for p in passages]
-
     @enforce_types
     def passage_size(
         self,

letta/services/block_manager.py

@@ -38,6 +38,21 @@ class BlockManager:
                 block.create(session, actor=actor)
             return block.to_pydantic()
 
+    @trace_method
+    @enforce_types
+    async def create_or_update_block_async(self, block: PydanticBlock, actor: PydanticUser) -> PydanticBlock:
+        """Create a new block based on the Block schema."""
+        db_block = await self.get_block_by_id_async(block.id, actor)
+        if db_block:
+            update_data = BlockUpdate(**block.model_dump(to_orm=True, exclude_none=True))
+            return await self.update_block_async(block.id, update_data, actor)
+        else:
+            async with db_registry.async_session() as session:
+                data = block.model_dump(to_orm=True, exclude_none=True)
+                block = BlockModel(**data, organization_id=actor.organization_id)
+                await block.create_async(session, actor=actor)
+                return block.to_pydantic()
+
     @trace_method
     @enforce_types
     def batch_create_blocks(self, blocks: List[PydanticBlock], actor: PydanticUser) -> List[PydanticBlock]:
@@ -78,6 +93,22 @@ class BlockManager:
             block.update(db_session=session, actor=actor)
             return block.to_pydantic()
 
+    @trace_method
+    @enforce_types
+    async def update_block_async(self, block_id: str, block_update: BlockUpdate, actor: PydanticUser) -> PydanticBlock:
+        """Update a block by its ID with the given BlockUpdate object."""
+        # Safety check for block
+
+        async with db_registry.async_session() as session:
+            block = await BlockModel.read_async(db_session=session, identifier=block_id, actor=actor)
+            update_data = block_update.model_dump(to_orm=True, exclude_unset=True, exclude_none=True)
+
+            for key, value in update_data.items():
+                setattr(block, key, value)
+
+            await block.update_async(db_session=session, actor=actor)
+            return block.to_pydantic()
+
     @trace_method
     @enforce_types
     def delete_block(self, block_id: str, actor: PydanticUser) -> PydanticBlock:
@@ -87,6 +118,15 @@ class BlockManager:
             block.hard_delete(db_session=session, actor=actor)
             return block.to_pydantic()
 
+    @trace_method
+    @enforce_types
+    async def delete_block_async(self, block_id: str, actor: PydanticUser) -> PydanticBlock:
+        """Delete a block by its ID."""
+        async with db_registry.async_session() as session:
+            block = await BlockModel.read_async(db_session=session, identifier=block_id, actor=actor)
+            await block.hard_delete_async(db_session=session, actor=actor)
+            return block.to_pydantic()
+
     @trace_method
     @enforce_types
     async def get_blocks_async(
@@ -161,6 +201,17 @@ class BlockManager:
             except NoResultFound:
                 return None
 
+    @trace_method
+    @enforce_types
+    async def get_block_by_id_async(self, block_id: str, actor: Optional[PydanticUser] = None) -> Optional[PydanticBlock]:
+        """Retrieve a block by its name."""
+        async with db_registry.async_session() as session:
+            try:
+                block = await BlockModel.read_async(db_session=session, identifier=block_id, actor=actor)
+                return block.to_pydantic()
+            except NoResultFound:
+                return None
+
     @trace_method
     @enforce_types
     async def get_all_blocks_by_ids_async(self, block_ids: List[str], actor: Optional[PydanticUser] = None) -> List[PydanticBlock]:

{letta_nightly-0.7.22.dev20250523081403.dist-info → letta_nightly-0.7.23.dev20250523164139.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: letta-nightly
-Version: 0.7.22.dev20250523081403
+Version: 0.7.23.dev20250523164139
 Summary: Create LLM agents with long-term memory and custom tools
 License: Apache License
 Author: Letta Team

{letta_nightly-0.7.22.dev20250523081403.dist-info → letta_nightly-0.7.23.dev20250523164139.dist-info}/RECORD

@@ -1,4 +1,4 @@
-letta/__init__.py,sha256=AkQ-S44jf9AYGDZrBONaQfZis2Gxwo-wIMuyk9rGkyA,888
+letta/__init__.py,sha256=vzj6HtecPrKm7mPJweZmynwWQsIiHIWSopQMTD3u96E,888
 letta/agent.py,sha256=2r6xovRHeUnmWZ6WJoIP217ryse5Q3Bkco1JXiV599w,87459
 letta/agents/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 letta/agents/base_agent.py,sha256=mdFEpYBVyFjmt6BzO9YrpJnH99RkBWZ9gnP3Q_bnbBI,5505
@@ -76,9 +76,9 @@ letta/llm_api/azure_openai.py,sha256=YAkXwKyfnJFNhB45pkJVFsoxUNB_M74rQYchtw_CN6I
 letta/llm_api/azure_openai_constants.py,sha256=ZaR2IasJThijG0uhLKJThrixdAxLPD2IojfeaJ-KQMQ,294
 letta/llm_api/cohere.py,sha256=IZ6LXyOFMYjWHTeNG9lvFxCdV_NIl0hY2q9SPFYXNkQ,14849
 letta/llm_api/deepseek.py,sha256=b1mSW8gnBrpAI8d2GcBpDyLYDnuC-P1UP6xJPalfQS4,12456
-letta/llm_api/google_ai_client.py,sha256=yIP4lJ1sJoryS_76FjSyzOTCOEnXZoyoo-MarR9YzU8,9401
+letta/llm_api/google_ai_client.py,sha256=WSLTayAd7FQPilIZ7MxJnSCgw4JCl2vY_KE2aorvr5Q,9933
 letta/llm_api/google_constants.py,sha256=4PKWUNNbBHgHi4K5u9YaHr_8UC3fokfI6Qb6Dfpt4mU,693
-letta/llm_api/google_vertex_client.py,sha256=OCjEp0tTsTKkDVgY-3EwHSJRfyXvAv5ikYzNfIHACaU,22814
+letta/llm_api/google_vertex_client.py,sha256=XoGDmX_kbaRayHZMjiQuo96VpvisDikg8vYfez_rsNc,22796
 letta/llm_api/helpers.py,sha256=rpZInutKVKgoywreclisNSi2zVxwFinAzJIuxF6ll4I,17041
 letta/llm_api/llm_api_tools.py,sha256=gMYoEvs5vSyvjos2eYJN6_BpQ2aNpt3zvyF7D2phbqY,30044
 letta/llm_api/llm_client.py,sha256=sO9MwiSOJ_ycOFnYrQP0_g6cFkMSnrZqFDz1sUeBHD8,2098
@@ -229,7 +229,7 @@ letta/schemas/openai/openai.py,sha256=Hilo5BiLAGabzxCwnwfzK5QrWqwYD8epaEKFa4Pwnd
 letta/schemas/organization.py,sha256=TXrHN4IBQnX-mWvRuCOH57XZSLYCVOY0wWm2_UzDQIA,1279
 letta/schemas/passage.py,sha256=RG0vkaewEu4a_NAZM-FVyMammHjqpPP0RDYAdu27g6A,3723
 letta/schemas/provider_trace.py,sha256=gsgo1CdfTUFSnm1ep1tSZ0fZfGSx45EdPaVyVJREt_U,1958
-letta/schemas/providers.py,sha256=EfCT6NN41EP1IJwkqauHy2rD2_RyxWeE0HJMmWdPkkE,63037
+letta/schemas/providers.py,sha256=p9k2lTNT0qdFGgYAiNLYJpyfdrZrDBeWeU7v112WDl4,63063
 letta/schemas/response_format.py,sha256=pXNsjbtpA3Tf8HsDyIa40CSmoUbVR_7n2WOfQaX4aFs,2204
 letta/schemas/run.py,sha256=SRqPRziINIiPunjOhE_NlbnQYgxTvqmbauni_yfBQRA,2085
 letta/schemas/sandbox_config.py,sha256=Qfkzw422HCQUsE3GKry94oecQGziAzGXIyd6ke8W06M,5985
@@ -252,7 +252,7 @@ letta/serialize_schemas/marshmallow_tool.py,sha256=jwU69BDCakPlYPSk-ta21kuvsURKO
 letta/serialize_schemas/pydantic_agent_schema.py,sha256=NKq70niUVMI3_lxMKc3u3rOBUhm77bIFaPRj9aidMUQ,3006
 letta/server/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 letta/server/constants.py,sha256=yAdGbLkzlOU_dLTx0lKDmAnj0ZgRXCEaIcPJWO69eaE,92
-letta/server/db.py,sha256=Ob8_W7HXUduJS94a3d0jZ50EtSkYuv8kgOk6AjusyJ8,9985
+letta/server/db.py,sha256=Hj4DDGXu7J1t6Q4oJwvhpIB3IXgNCvU1cQbW6f1osWM,9954
 letta/server/generate_openapi_schema.sh,sha256=0OtBhkC1g6CobVmNEd_m2B6sTdppjbJLXaM95icejvE,371
 letta/server/rest_api/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 letta/server/rest_api/app.py,sha256=8Y5R_t_s4IAG7wRfdbmCeF5YT9pfGG4h6_kpUAaUwoQ,14771
@@ -267,7 +267,7 @@ letta/server/rest_api/routers/openai/chat_completions/__init__.py,sha256=47DEQpj
 letta/server/rest_api/routers/openai/chat_completions/chat_completions.py,sha256=QBWab1fn2LXVDMtc6li3gOzmrNzDiUw5WUJsMeeMZII,5076
 letta/server/rest_api/routers/v1/__init__.py,sha256=JfSSttkEWu0W18NVVDxl8AGnd8Qhj0BXJNxntOB7070,1768
 letta/server/rest_api/routers/v1/agents.py,sha256=evL3IHe5PR2Jmo3edT6hGv2BkHd7hB1EfC4Y4z3qOVc,38631
-letta/server/rest_api/routers/v1/blocks.py,sha256=am8VeLcpWtZ1V6c9hl0q141uogijGWPbI3rlEoVzBPA,4677
+letta/server/rest_api/routers/v1/blocks.py,sha256=2uCUK91hFFmiAJt0Mrj0wn0Q6UC6J7xcV1dbDLU44r0,4767
 letta/server/rest_api/routers/v1/embeddings.py,sha256=P-Dvt_HNKoTyjRwkScAMg1hlB3cNxMeAQwV7bSatsKI,957
 letta/server/rest_api/routers/v1/groups.py,sha256=DT2tc4wwiq_gzmxefltEIrFSoqOntzhvmgqQy23varA,10738
 letta/server/rest_api/routers/v1/health.py,sha256=MoOjkydhGcJXTiuJrKIB0etVXiRMdTa51S8RQ8-50DQ,399
@@ -279,7 +279,7 @@ letta/server/rest_api/routers/v1/organizations.py,sha256=r7rj-cA3shgAgM0b2JCMqjY
 letta/server/rest_api/routers/v1/providers.py,sha256=qp6XT20tcZac64XDGF2QUyLhselnShrRcTDQBHExEbQ,4322
 letta/server/rest_api/routers/v1/runs.py,sha256=rq-k5kYN0On7VBNSzoPJxZcBf13hZFaDx0IUJJ04_K8,8875
 letta/server/rest_api/routers/v1/sandbox_configs.py,sha256=g6JE1Xcl4vQPRduPdKZL04FexHttK0ZPJuTGds_Heig,8782
-letta/server/rest_api/routers/v1/sources.py,sha256=6qL59NYCTv8uJ7SBOPk09c8q90KghnehPB6NTYLVJ7Y,11896
+letta/server/rest_api/routers/v1/sources.py,sha256=ccdCdgCvdd1g81IPrnpoiQwqhh3eP5b7HuLfhrVYZhw,11457
 letta/server/rest_api/routers/v1/steps.py,sha256=ra7ttm7HDs3N52M6s80XdpwiSMTLyf776_SmEILWDvo,3276
 letta/server/rest_api/routers/v1/tags.py,sha256=ef94QitUSJ3NQVffWF1ZqANUZ2b2jRyGHp_I3UUjhno,912
 letta/server/rest_api/routers/v1/telemetry.py,sha256=z53BW3Pefi3eWy47FPJyGhFWbZicX9jPJUi5LC5c3sk,790
@@ -289,7 +289,7 @@ letta/server/rest_api/routers/v1/voice.py,sha256=NZa7ksEqXTWSqh7CqmbVMClO7wOmrql
 letta/server/rest_api/static_files.py,sha256=NG8sN4Z5EJ8JVQdj19tkFa9iQ1kBPTab9f_CUxd_u4Q,3143
 letta/server/rest_api/streaming_response.py,sha256=yYTuZHfuZ-DYYbA1Ta6axkBn5MvC6OHuVRHSiBqRNUk,3939
 letta/server/rest_api/utils.py,sha256=UVWlJI026oBB3uWxjhnA9DRlUiYtCoqBzmekI2JhvOQ,16612
-letta/server/server.py,sha256=g2C3Nv1_fer9vv_DpUXMVWva1F8KLWe5guj1vtIv52I,96158
+letta/server/server.py,sha256=iIt6AhxsSHoUEZylUci0-D5MUikIC0mA6NSTu2ky1dw,101509
 letta/server/startup.sh,sha256=MRXh1RKbS5lyA7XAsk7O6Q4LEKOqnv5B-dwe0SnTHeQ,2514
 letta/server/static_files/assets/index-048c9598.js,sha256=mR16XppvselwKCcNgONs4L7kZEVa4OEERm4lNZYtLSk,146819
 letta/server/static_files/assets/index-0e31b727.css,sha256=SBbja96uiQVLDhDOroHgM6NSl7tS4lpJRCREgSS_hA8,7672
@@ -303,8 +303,8 @@ letta/server/ws_api/interface.py,sha256=TWl9vkcMCnLsUtgsuENZ-ku2oMDA-OUTzLh_yNRo
 letta/server/ws_api/protocol.py,sha256=5mDgpfNZn_kNwHnpt5Dsuw8gdNH298sgxTGed3etzYg,1836
 letta/server/ws_api/server.py,sha256=cBSzf-V4zT1bL_0i54OTI3cMXhTIIxqjSRF8pYjk7fg,5835
 letta/services/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-letta/services/agent_manager.py,sha256=QQ-5Xfnjvbfm4MaP26yEhjWZ6WJtnmnOACAx92NTSaQ,131609
-letta/services/block_manager.py,sha256=lZewHLhG5QKAceE3LIh2ty9OmAzvNu4uDGUSln3JULo,19240
+letta/services/agent_manager.py,sha256=N2Wsi0zrwuhRjQyofSvC1aOPwiP3MUSamYSdJFyaslc,122236
+letta/services/block_manager.py,sha256=e4_VAHA5XzOLOdIE3uLqtnxykjEvfTgSJSRqNKDUsWM,21716
 letta/services/group_manager.py,sha256=zzxrPlk3FTUfiOMPwdjuVr9loxInjtXlJsO_TKReJqk,17267
 letta/services/helpers/agent_manager_helper.py,sha256=q7GfVgKI-e8k0BZS-V_PuUCjK-PYciZDoig_sYHi_Go,21334
 letta/services/helpers/noop_helper.py,sha256=OZ6wZLsdNEAg9Q2t5oFTOMK6jp-YUMBPdoyiR8M3T1c,272
@@ -346,8 +346,8 @@ letta/system.py,sha256=mKxmvvekuP8mdgsebRINGBoFbUdJhxLJ260crPBNVyk,8386
 letta/tracing.py,sha256=YMb9KgoBVz7nwCPwnErk2EJEKMiQ_ohctW1nOwhHd1Y,8458
 letta/types/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 letta/utils.py,sha256=W8J1FfhRADFqoyx3J8-Z1_aWyG433PBoEh_b5wdOZIg,32262
-letta_nightly-0.7.22.dev20250523081403.dist-info/LICENSE,sha256=mExtuZ_GYJgDEI38GWdiEYZizZS4KkVt2SF1g_GPNhI,10759
-letta_nightly-0.7.22.dev20250523081403.dist-info/METADATA,sha256=qgI9EsbdbgD3p9Glqav-C1wM30Bv1RvjHKkN2At1cIE,22321
-letta_nightly-0.7.22.dev20250523081403.dist-info/WHEEL,sha256=FMvqSimYX_P7y0a7UY-_Mc83r5zkBZsCYPm7Lr0Bsq4,88
-letta_nightly-0.7.22.dev20250523081403.dist-info/entry_points.txt,sha256=2zdiyGNEZGV5oYBuS-y2nAAgjDgcC9yM_mHJBFSRt5U,40
-letta_nightly-0.7.22.dev20250523081403.dist-info/RECORD,,
+letta_nightly-0.7.23.dev20250523164139.dist-info/LICENSE,sha256=mExtuZ_GYJgDEI38GWdiEYZizZS4KkVt2SF1g_GPNhI,10759
+letta_nightly-0.7.23.dev20250523164139.dist-info/METADATA,sha256=Ojwp8JmVzsZWA7ibbGOtjEWmOgEP6YMBToiSCgQcTww,22321
+letta_nightly-0.7.23.dev20250523164139.dist-info/WHEEL,sha256=FMvqSimYX_P7y0a7UY-_Mc83r5zkBZsCYPm7Lr0Bsq4,88
+letta_nightly-0.7.23.dev20250523164139.dist-info/entry_points.txt,sha256=2zdiyGNEZGV5oYBuS-y2nAAgjDgcC9yM_mHJBFSRt5U,40
+letta_nightly-0.7.23.dev20250523164139.dist-info/RECORD,,