Platform for stateful agents: AI with advanced memory that can learn and self-improve over time.
chore: bump version v0.7.15 (#2622)
cthomasf2ff6717af08
diff --git a/letta/__init__.py b/letta/__init__.pyindex ab800d9a5..19cdb6f6b 100644--- a/letta/__init__.py+++ b/letta/__init__.py@@ -1,4 +1,4 @@-__version__ = "0.7.14"+__version__ = "0.7.15"# import clientsfrom letta.client.client import LocalClient, RESTClient, create_clientdiff --git a/letta/agents/base_agent.py b/letta/agents/base_agent.pyindex bae5d07ec..018d6300f 100644--- a/letta/agents/base_agent.py+++ b/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:]diff --git a/letta/agents/letta_agent.py b/letta/agents/letta_agent.pyindex 1b65da60d..2b20cfaf9 100644--- a/letta/agents/letta_agent.py+++ b/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_methodasync 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 SSEyield 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")diff --git a/letta/llm_api/openai.py b/letta/llm_api/openai.pyindex 4b8d3cb5d..f08462f7a 100644--- a/letta/llm_api/openai.py+++ b/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.idif 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.nameif 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.argumentsif message_delta.function_call is not None:raise NotImplementedError(f"Old function_call style not support with stream=True")diff --git a/letta/server/db.py b/letta/server/db.pyindex 57fbdd530..32dbb13ef 100644--- a/letta/server/db.py+++ b/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,diff --git a/letta/server/rest_api/routers/v1/blocks.py b/letta/server/rest_api/routers/v1/blocks.pyindex ef43d9b66..4a9ea8dad 100644--- a/letta/server/rest_api/routers/v1/blocks.py+++ b/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 parameterslabel: 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,)diff --git a/letta/services/block_manager.py b/letta/services/block_manager.pyindex 63e950600..30450f018 100644--- a/letta/services/block_manager.py+++ b/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_typesdef get_block_by_id(self, block_id: str, actor: Optional[PydanticUser] = None) -> Optional[PydanticBlock]:"""Retrieve a block by its name."""diff --git a/pyproject.toml b/pyproject.tomlindex f35439170..6e29dc644 100644--- a/pyproject.toml+++ b/pyproject.toml@@ -1,6 +1,6 @@[tool.poetry]name = "letta"-version = "0.7.14"+version = "0.7.15"packages = [{include = "letta"},]diff --git a/tests/test_managers.py b/tests/test_managers.pyindex a2e0f2588..ab539879e 100644--- a/tests/test_managers.py+++ b/tests/test_managers.py@@ -1,3 +1,4 @@+import asyncioimport loggingimport osimport random@@ -628,6 +629,14 @@ def letta_batch_job(server: SyncServer, default_user) -> Job:return server.job_manager.create_job(BatchJob(user_id=default_user.id), actor=default_user)[email protected](scope="session")+def event_loop(request):+ """Create an instance of the default event loop for each test case."""+ loop = asyncio.get_event_loop_policy().new_event_loop()+ yield loop+ loop.close()++# ======================================================================================================================# AgentManager Tests - Basic# ======================================================================================================================@@ -1757,7 +1766,8 @@ def test_refresh_memory(server: SyncServer, default_user):assert len(agent.memory.blocks) == 0-async def test_refresh_memory_async(server: SyncServer, default_user):+async def test_refresh_memory_async(server: SyncServer, default_user, event_loop):block = server.block_manager.create_or_update_block(PydanticBlock(label="test",@@ -1766,13 +1776,21 @@ async def test_refresh_memory_async(server: SyncServer, default_user):),actor=default_user,)+ block_human = server.block_manager.create_or_update_block(+ PydanticBlock(+ label="human",+ value="name: caren",+ limit=1000,+ ),+ actor=default_user,+ )agent = server.agent_manager.create_agent(CreateAgent(name="test",llm_config=LLMConfig.default_config("gpt-4o-mini"),embedding_config=EmbeddingConfig.default_config(provider="openai"),include_base_tools=False,- block_ids=[block.id],+ block_ids=[block.id, block_human.id],),actor=default_user,)@@ -1783,10 +1801,10 @@ async def test_refresh_memory_async(server: SyncServer, default_user):),actor=default_user,)- assert len(agent.memory.blocks) == 1+ assert len(agent.memory.blocks) == 2agent = await server.agent_manager.refresh_memory_async(agent_state=agent, actor=default_user)- assert len(agent.memory.blocks) == 1- assert agent.memory.blocks[0].value == "test2"+ assert len(agent.memory.blocks) == 2+ assert any([block.value == "test2" for block in agent.memory.blocks])# ======================================================================================================================@@ -2623,7 +2641,8 @@ def test_create_block(server: SyncServer, default_user):assert block.organization_id == default_user.organization_id-def test_get_blocks(server, default_user):+async def test_get_blocks(server, default_user, event_loop):block_manager = BlockManager()# Create blocks to retrieve later@@ -2631,19 +2650,20 @@ def test_get_blocks(server, default_user):block_manager.create_or_update_block(PydanticBlock(label="persona", value="Block 2"), actor=default_user)# Retrieve blocks by different filters- all_blocks = block_manager.get_blocks(actor=default_user)+ all_blocks = await block_manager.get_blocks_async(actor=default_user)assert len(all_blocks) == 2- human_blocks = block_manager.get_blocks(actor=default_user, label="human")+ human_blocks = await block_manager.get_blocks_async(actor=default_user, label="human")assert len(human_blocks) == 1assert human_blocks[0].label == "human"- persona_blocks = block_manager.get_blocks(actor=default_user, label="persona")+ persona_blocks = await block_manager.get_blocks_async(actor=default_user, label="persona")assert len(persona_blocks) == 1assert persona_blocks[0].label == "persona"-def test_get_blocks_comprehensive(server, default_user, other_user_different_org):+async def test_get_blocks_comprehensive(server, default_user, other_user_different_org, event_loop):def random_label(prefix="label"):return f"{prefix}_{''.join(random.choices(string.ascii_lowercase, k=6))}"@@ -2669,7 +2689,7 @@ def test_get_blocks_comprehensive(server, default_user, other_user_different_orgother_user_blocks.append((label, value))# Check default_user sees only their blocks- retrieved_default_blocks = block_manager.get_blocks(actor=default_user)+ retrieved_default_blocks = await block_manager.get_blocks_async(actor=default_user)assert len(retrieved_default_blocks) == 10retrieved_labels = {b.label for b in retrieved_default_blocks}for label, value in default_user_blocks:@@ -2677,13 +2697,13 @@ def test_get_blocks_comprehensive(server, default_user, other_user_different_org# Check individual filtering for default_userfor label, value in default_user_blocks:- filtered = block_manager.get_blocks(actor=default_user, label=label)+ filtered = await block_manager.get_blocks_async(actor=default_user, label=label)assert len(filtered) == 1assert filtered[0].label == labelassert filtered[0].value == value# Check other_user sees only their blocks- retrieved_other_blocks = block_manager.get_blocks(actor=other_user_different_org)+ retrieved_other_blocks = await block_manager.get_blocks_async(actor=other_user_different_org)assert len(retrieved_other_blocks) == 3retrieved_labels = {b.label for b in retrieved_other_blocks}for label, value in other_user_blocks:@@ -2691,11 +2711,11 @@ def test_get_blocks_comprehensive(server, default_user, other_user_different_org# Other user shouldn't see default_user's blocksfor label, _ in default_user_blocks:- assert block_manager.get_blocks(actor=other_user_different_org, label=label) == []+ assert (await block_manager.get_blocks_async(actor=other_user_different_org, label=label)) == []# Default user shouldn't see other_user's blocksfor label, _ in other_user_blocks:- assert block_manager.get_blocks(actor=default_user, label=label) == []+ assert (await block_manager.get_blocks_async(actor=default_user, label=label)) == []def test_update_block(server: SyncServer, default_user):@@ -2707,7 +2727,7 @@ def test_update_block(server: SyncServer, default_user):block_manager.update_block(block_id=block.id, block_update=update_data, actor=default_user)# Retrieve the updated block- updated_block = block_manager.get_blocks(actor=default_user, id=block.id)[0]+ updated_block = block_manager.get_block_by_id(actor=default_user, block_id=block.id)# Assertions to verify the updateassert updated_block.value == "Updated Content"@@ -2730,7 +2750,7 @@ def test_update_block_limit(server: SyncServer, default_user):block_manager.update_block(block_id=block.id, block_update=update_data, actor=default_user)# Retrieve the updated block and validate the update- updated_block = block_manager.get_blocks(actor=default_user, id=block.id)[0]+ updated_block = block_manager.get_block_by_id(actor=default_user, block_id=block.id)assert updated_block.value == "Updated Content" * 2000assert updated_block.description == "Updated description"@@ -2747,11 +2767,12 @@ def test_update_block_limit_does_not_reset(server: SyncServer, default_user):block_manager.update_block(block_id=block.id, block_update=update_data, actor=default_user)# Retrieve the updated block and validate the update- updated_block = block_manager.get_blocks(actor=default_user, id=block.id)[0]+ updated_block = block_manager.get_block_by_id(actor=default_user, block_id=block.id)assert updated_block.value == new_content-def test_delete_block(server: SyncServer, default_user):+async def test_delete_block(server: SyncServer, default_user, event_loop):block_manager = BlockManager()# Create and delete a block@@ -2759,11 +2780,12 @@ def test_delete_block(server: SyncServer, default_user):block_manager.delete_block(block_id=block.id, actor=default_user)# Verify that the block was deleted- blocks = block_manager.get_blocks(actor=default_user)+ blocks = await block_manager.get_blocks_async(actor=default_user)assert len(blocks) == 0-def test_delete_block_detaches_from_agent(server: SyncServer, sarah_agent, default_user):+async def test_delete_block_detaches_from_agent(server: SyncServer, sarah_agent, default_user, event_loop):# Create and delete a blockblock = server.block_manager.create_or_update_block(PydanticBlock(label="human", value="Sample content"), actor=default_user)agent_state = server.agent_manager.attach_block(agent_id=sarah_agent.id, block_id=block.id, actor=default_user)@@ -2775,7 +2797,7 @@ def test_delete_block_detaches_from_agent(server: SyncServer, sarah_agent, defauserver.block_manager.delete_block(block_id=block.id, actor=default_user)# Verify that the block was deleted- blocks = server.block_manager.get_blocks(actor=default_user)+ blocks = await server.block_manager.get_blocks_async(actor=default_user)assert len(blocks) == 0# Check that block has been detached too@@ -2803,7 +2825,8 @@ def test_get_agents_for_block(server: SyncServer, sarah_agent, charles_agent, deassert charles_agent.id in agent_state_ids-def test_batch_create_multiple_blocks(server: SyncServer, default_user):+async def test_batch_create_multiple_blocks(server: SyncServer, default_user, event_loop):block_manager = BlockManager()num_blocks = 10@@ -2828,7 +2851,7 @@ def test_batch_create_multiple_blocks(server: SyncServer, default_user):assert blk.id is not None# Confirm all created blocks exist in the full list from get_blocks- all_labels = {blk.label for blk in block_manager.get_blocks(actor=default_user)}+ all_labels = {blk.label for blk in await block_manager.get_blocks_async(actor=default_user)}expected_labels = {f"batch_label_{i}" for i in range(num_blocks)}assert expected_labels.issubset(all_labels)@@ -2859,7 +2882,7 @@ def test_bulk_update_skips_missing_and_truncates_then_returns_none(server: SyncSassert "truncating" in caplog.text# confirm the value was truncated to `limit` characters- reloaded = mgr.get_blocks(actor=default_user, id=b.id)[0]+ reloaded = mgr.get_block_by_id(actor=default_user, block_id=b.id)assert len(reloaded.value) == 5assert reloaded.value == long_val[:5]@@ -2904,11 +2927,11 @@ def test_bulk_update_respects_org_scoping(server: SyncServer, default_user: Pydamgr.bulk_update_block_values(updates, actor=default_user)# mine should be updated...- reloaded_mine = mgr.get_blocks(actor=default_user, id=mine.id)[0]+ reloaded_mine = mgr.get_block_by_id(actor=default_user, block_id=mine.id)assert reloaded_mine.value == "updated-mine"# ...theirs should remain untouched- reloaded_theirs = mgr.get_blocks(actor=other_user_different_org, id=theirs.id)[0]+ reloaded_theirs = mgr.get_block_by_id(actor=other_user_different_org, block_id=theirs.id)assert reloaded_theirs.value == "theirs"# warning should mention skipping the other-org ID@@ -3665,7 +3688,8 @@ def test_get_set_agents_for_identities(server: SyncServer, sarah_agent, charles_server.identity_manager.delete_identity(identity_id=identity.id, actor=default_user)-def test_attach_detach_identity_from_block(server: SyncServer, default_block, default_user):+async def test_attach_detach_identity_from_block(server: SyncServer, default_block, default_user, event_loop):# Create an identityidentity = server.identity_manager.create_identity(IdentityCreate(name="caren", identifier_key="1234", identity_type=IdentityType.user, block_ids=[default_block.id]),@@ -3673,7 +3697,7 @@ def test_attach_detach_identity_from_block(server: SyncServer, default_block, de)# Check that identity has been attached- blocks = server.block_manager.get_blocks(identity_id=identity.id, actor=default_user)+ blocks = await server.block_manager.get_blocks_async(identity_id=identity.id, actor=default_user)assert len(blocks) == 1 and blocks[0].id == default_block.id# Now attempt to delete the identity@@ -3684,11 +3708,12 @@ def test_attach_detach_identity_from_block(server: SyncServer, default_block, deassert len(identities) == 0# Check that block has been detached too- blocks = server.block_manager.get_blocks(identity_id=identity.id, actor=default_user)+ blocks = await server.block_manager.get_blocks_async(identity_id=identity.id, actor=default_user)assert len(blocks) == 0-def test_get_set_blocks_for_identities(server: SyncServer, default_block, default_user):+async def test_get_set_blocks_for_identities(server: SyncServer, default_block, default_user, event_loop):block_manager = BlockManager()block_with_identity = block_manager.create_or_update_block(PydanticBlock(label="persona", value="Original Content"), actor=default_user)block_without_identity = block_manager.create_or_update_block(PydanticBlock(label="user", value="Original Content"), actor=default_user)@@ -3700,7 +3725,7 @@ def test_get_set_blocks_for_identities(server: SyncServer, default_block, defaul)# Get the blocks for identity id- blocks = server.block_manager.get_blocks(identity_id=identity.id, actor=default_user)+ blocks = await server.block_manager.get_blocks_async(identity_id=identity.id, actor=default_user)assert len(blocks) == 2# Check blocks are in the list@@ -3710,7 +3735,7 @@ def test_get_set_blocks_for_identities(server: SyncServer, default_block, defaulassert not block_without_identity.id in block_ids# Get the blocks for identifier key- blocks = server.block_manager.get_blocks(identifier_keys=[identity.identifier_key], actor=default_user)+ blocks = await server.block_manager.get_blocks_async(identifier_keys=[identity.identifier_key], actor=default_user)assert len(blocks) == 2# Check blocks are in the list@@ -3724,7 +3749,7 @@ def test_get_set_blocks_for_identities(server: SyncServer, default_block, defaulserver.block_manager.delete_block(block_id=block_without_identity.id, actor=default_user)# Get the blocks for identity id- blocks = server.block_manager.get_blocks(identity_id=identity.id, actor=default_user)+ blocks = await server.block_manager.get_blocks_async(identity_id=identity.id, actor=default_user)assert len(blocks) == 1# Check only initial block in the list