Skip to content

armgit / letta

Public Imported from GitHub
0

Platform for stateful agents: AI with advanced memory that can learn and self-improve over time.

feat: Adjust ephemeral memory agent to become persisted sleeptime agent (#1943)

Matthew Zhoudf175890bda9
diff --git a/examples/swarm/swarm.py b/examples/swarm/swarm.py
index ef080806d..6e0958bf7 100644
--- a/examples/swarm/swarm.py
+++ b/examples/swarm/swarm.py
@@ -86,7 +86,7 @@ class Swarm:
# grab responses
messages = []
for message in response.messages:
- messages += message.to_letta_message()
+ messages += message.to_letta_messages()
# get new agent (see tool call)
# print(messages)
diff --git a/letta/agents/helpers.py b/letta/agents/helpers.py
index 9460a7ce0..66f79117b 100644
--- a/letta/agents/helpers.py
+++ b/letta/agents/helpers.py
@@ -15,7 +15,7 @@ def _create_letta_response(new_in_context_messages: list[Message], use_assistant
"""
response_messages = []
for msg in new_in_context_messages:
- response_messages.extend(msg.to_letta_message(use_assistant_message=use_assistant_message))
+ response_messages.extend(msg.to_letta_messages(use_assistant_message=use_assistant_message))
return LettaResponse(messages=response_messages, usage=LettaUsageStatistics())
diff --git a/letta/agents/voice_agent.py b/letta/agents/voice_agent.py
index 532399453..8d3077fc0 100644
--- a/letta/agents/voice_agent.py
+++ b/letta/agents/voice_agent.py
@@ -6,7 +6,7 @@ from typing import Any, AsyncGenerator, Dict, List, Optional, Tuple
import openai
from letta.agents.base_agent import BaseAgent
-from letta.agents.ephemeral_memory_agent import EphemeralMemoryAgent
+from letta.agents.voice_sleeptime_agent import VoiceSleeptimeAgent
from letta.constants import NON_USER_MSG_PREFIX
from letta.helpers.datetime_helpers import get_utc_time
from letta.helpers.tool_execution_helper import (
@@ -81,25 +81,38 @@ class VoiceAgent(BaseAgent):
# TODO: This is not guaranteed to exist!
self.summary_block_label = "human"
self.message_buffer_limit = message_buffer_limit
- self.summarizer = Summarizer(
+ self.message_buffer_min = message_buffer_min
+
+ # 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)
+
+ def init_summarizer(self, agent_state: AgentState) -> Summarizer:
+ if not agent_state.multi_agent_group:
+ raise ValueError("Low latency voice agent is not part of a multiagent group, missing sleeptime agent.")
+ if len(agent_state.multi_agent_group.agent_ids) != 1:
+ raise ValueError(
+ f"None or multiple participant agents found in voice sleeptime group: {agent_state.multi_agent_group.agent_ids}"
+ )
+ voice_sleeptime_agent_id = agent_state.multi_agent_group.agent_ids[0]
+ summarizer = Summarizer(
mode=SummarizationMode.STATIC_MESSAGE_BUFFER,
- summarizer_agent=EphemeralMemoryAgent(
- agent_id=agent_id,
- openai_client=openai_client,
- message_manager=message_manager,
- agent_manager=agent_manager,
- actor=actor,
- block_manager=block_manager,
+ summarizer_agent=VoiceSleeptimeAgent(
+ agent_id=voice_sleeptime_agent_id,
+ convo_agent_state=agent_state,
+ openai_client=self.openai_client,
+ message_manager=self.message_manager,
+ agent_manager=self.agent_manager,
+ actor=self.actor,
+ block_manager=self.block_manager,
target_block_label=self.summary_block_label,
message_transcripts=[],
),
- message_buffer_limit=message_buffer_limit,
- message_buffer_min=message_buffer_min,
+ message_buffer_limit=self.message_buffer_limit,
+ message_buffer_min=self.message_buffer_min,
)
- # 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)
+ return summarizer
async def step(self, input_messages: List[MessageCreate], max_steps: int = 10) -> LettaResponse:
raise NotImplementedError("VoiceAgent does not have a synchronous step implemented currently.")
@@ -114,6 +127,8 @@ class VoiceAgent(BaseAgent):
user_query = input_messages[0].content[0].text
agent_state = self.agent_manager.get_agent_by_id(self.agent_id, actor=self.actor)
+ summarizer = self.init_summarizer(agent_state=agent_state)
+
in_context_messages = self.message_manager.get_messages_by_ids(message_ids=agent_state.message_ids, actor=self.actor)
memory_edit_timestamp = get_utc_time()
in_context_messages[0].content[0].text = compile_system_message(
@@ -155,7 +170,7 @@ class VoiceAgent(BaseAgent):
break
# Rebuild context window if desired
- await self._rebuild_context_window(in_context_messages, letta_message_db_queue)
+ await self._rebuild_context_window(summarizer, in_context_messages, letta_message_db_queue)
# TODO: This may be out of sync, if in between steps users add files
self.num_messages = self.message_manager.size(actor=self.actor, agent_id=agent_state.id)
@@ -253,11 +268,13 @@ class VoiceAgent(BaseAgent):
# If we got here, there's no tool call. If finish_reason_stop => done
return not streaming_interface.finish_reason_stop
- async def _rebuild_context_window(self, in_context_messages: List[Message], letta_message_db_queue: List[Message]) -> None:
+ async def _rebuild_context_window(
+ self, summarizer: Summarizer, in_context_messages: List[Message], letta_message_db_queue: List[Message]
+ ) -> None:
new_letta_messages = self.message_manager.create_many_messages(letta_message_db_queue, actor=self.actor)
# TODO: Make this more general and configurable, less brittle
- new_in_context_messages, updated = self.summarizer.summarize(
+ new_in_context_messages, updated = summarizer.summarize(
in_context_messages=in_context_messages, new_letta_messages=new_letta_messages
)
diff --git a/letta/agents/ephemeral_memory_agent.py b/letta/agents/voice_sleeptime_agent.py
similarity index 74%
rename from letta/agents/ephemeral_memory_agent.py
rename to letta/agents/voice_sleeptime_agent.py
index 1e6e5ef5f..ca609aba5 100644
--- a/letta/agents/ephemeral_memory_agent.py
+++ b/letta/agents/voice_sleeptime_agent.py
@@ -1,6 +1,6 @@
import json
import xml.etree.ElementTree as ET
-from typing import AsyncGenerator, Dict, List, Tuple, Union
+from typing import AsyncGenerator, Dict, List, Optional, Tuple, Union
import openai
@@ -11,7 +11,7 @@ from letta.schemas.enums import MessageStreamStatus
from letta.schemas.letta_message import LegacyLettaMessage, LettaMessage
from letta.schemas.letta_message_content import TextContent
from letta.schemas.letta_response import LettaResponse
-from letta.schemas.message import MessageCreate
+from letta.schemas.message import Message, MessageCreate, ToolReturn
from letta.schemas.openai.chat_completion_request import ChatCompletionRequest, Tool, UserMessage
from letta.schemas.usage import LettaUsageStatistics
from letta.schemas.user import User
@@ -19,9 +19,11 @@ from letta.server.rest_api.utils import convert_in_context_letta_messages_to_ope
from letta.services.agent_manager import AgentManager
from letta.services.block_manager import BlockManager
from letta.services.message_manager import MessageManager
+from letta.system import package_function_response
-class EphemeralMemoryAgent(BaseAgent):
+# TODO: Move this to the new Letta Agent loop
+class VoiceSleeptimeAgent(BaseAgent):
"""
A stateless agent that helps with offline memory computations.
"""
@@ -29,6 +31,7 @@ class EphemeralMemoryAgent(BaseAgent):
def __init__(
self,
agent_id: str,
+ convo_agent_state: AgentState,
openai_client: openai.AsyncClient,
message_manager: MessageManager,
agent_manager: AgentManager,
@@ -45,6 +48,7 @@ class EphemeralMemoryAgent(BaseAgent):
actor=actor,
)
+ self.convo_agent_state = convo_agent_state
self.block_manager = block_manager
self.target_block_label = target_block_label
self.message_transcripts = message_transcripts
@@ -75,26 +79,50 @@ class EphemeralMemoryAgent(BaseAgent):
if function_name == "store_memories":
print("Called store_memories")
print(function_args)
- for chunk_args in function_args.get("chunks"):
- self.store_memory(agent_state=agent_state, **chunk_args)
- result = "Successfully stored memories"
+ chunks = function_args.get("chunks", [])
+ results = [self.store_memory(agent_state=self.convo_agent_state, **chunk_args) for chunk_args in chunks]
+
+ aggregated_result = next((res for res, _ in results if res is not None), None)
+ aggregated_success = all(success for _, success in results)
+
else:
raise ValueError("Error: Unknown tool function '{function_name}'")
- openai_messages.append(
- {
- "role": "assistant",
- "content": assistant_message.content,
- "tool_calls": [
- {
- "id": tool_call.id,
- "type": "function",
- "function": {"name": function_name, "arguments": tool_call.function.arguments},
- }
- ],
- }
+ assistant_message = {
+ "role": "assistant",
+ "content": assistant_message.content,
+ "tool_calls": [
+ {
+ "id": tool_call.id,
+ "type": "function",
+ "function": {"name": function_name, "arguments": tool_call.function.arguments},
+ }
+ ],
+ }
+ openai_messages.append(assistant_message)
+ in_context_messages.append(
+ Message.dict_to_message(
+ agent_id=self.agent_id,
+ openai_message_dict=assistant_message,
+ model=agent_state.llm_config.model,
+ name=function_name,
+ )
+ )
+ tool_call_message = {
+ "role": "tool",
+ "tool_call_id": tool_call.id,
+ "content": package_function_response(was_success=aggregated_success, response_string=str(aggregated_result)),
+ }
+ openai_messages.append(tool_call_message)
+ in_context_messages.append(
+ Message.dict_to_message(
+ agent_id=self.agent_id,
+ openai_message_dict=tool_call_message,
+ model=agent_state.llm_config.model,
+ name=function_name,
+ tool_returns=[ToolReturn(status="success" if aggregated_success else "error")],
+ )
)
- openai_messages.append({"role": "tool", "tool_call_id": tool_call.id, "content": str(result)})
# 2. Execute rethink block memory loop
human_block_content = self.agent_manager.get_block_with_label(
@@ -113,7 +141,7 @@ Please refine this block:
- Organize related information together (e.g., preferences, background, ongoing goals).
- Add any light, supportable inferences that deepen understanding—but do not invent unsupported details.
-Use `rethink_user_memor(new_memory)` as many times as you need to iteratively improve the text. When it’s fully polished and complete, call `finish_rethinking_memory()`.
+Use `rethink_user_memory(new_memory)` as many times as you need to iteratively improve the text. When it’s fully polished and complete, call `finish_rethinking_memory()`.
"""
rethink_command = UserMessage(content=rethink_command)
openai_messages.append(rethink_command.model_dump())
@@ -128,35 +156,59 @@ Use `rethink_user_memor(new_memory)` as many times as you need to iteratively im
function_name = tool_call.function.name
function_args = json.loads(tool_call.function.arguments)
- if function_name == "rethink_user_memor":
- print("Called rethink_user_memor")
+ if function_name == "rethink_user_memory":
+ print("Called rethink_user_memory")
print(function_args)
- result = self.rethink_user_memory(agent_state=agent_state, **function_args)
+ result, success = self.rethink_user_memory(agent_state=agent_state, **function_args)
elif function_name == "finish_rethinking_memory":
print("Called finish_rethinking_memory")
+ result, success = None, True
break
else:
- result = f"Error: Unknown tool function '{function_name}'"
- openai_messages.append(
- {
- "role": "assistant",
- "content": assistant_message.content,
- "tool_calls": [
- {
- "id": tool_call.id,
- "type": "function",
- "function": {"name": function_name, "arguments": tool_call.function.arguments},
- }
- ],
- }
+ print(f"Error: Unknown tool function '{function_name}'")
+ raise ValueError(f"Error: Unknown tool function '{function_name}'", False)
+ assistant_message = {
+ "role": "assistant",
+ "content": assistant_message.content,
+ "tool_calls": [
+ {
+ "id": tool_call.id,
+ "type": "function",
+ "function": {"name": function_name, "arguments": tool_call.function.arguments},
+ }
+ ],
+ }
+ openai_messages.append(assistant_message)
+ in_context_messages.append(
+ Message.dict_to_message(
+ agent_id=self.agent_id,
+ openai_message_dict=assistant_message,
+ model=agent_state.llm_config.model,
+ name=function_name,
+ )
+ )
+ tool_call_message = {
+ "role": "tool",
+ "tool_call_id": tool_call.id,
+ "content": package_function_response(was_success=success, response_string=str(result)),
+ }
+ openai_messages.append(tool_call_message)
+ in_context_messages.append(
+ Message.dict_to_message(
+ agent_id=self.agent_id,
+ openai_message_dict=tool_call_message,
+ model=agent_state.llm_config.model,
+ name=function_name,
+ tool_returns=[ToolReturn(status="success" if success else "error")],
+ )
)
- openai_messages.append({"role": "tool", "tool_call_id": tool_call.id, "content": str(result)})
# Actually save the memory:
target_block = agent_state.memory.get_block(self.target_block_label)
self.block_manager.update_block(block_id=target_block.id, block_update=BlockUpdate(value=target_block.value), actor=self.actor)
- return LettaResponse(messages=[], usage=LettaUsageStatistics())
+ self.message_manager.create_many_messages(pydantic_msgs=in_context_messages, actor=self.actor)
+ return LettaResponse(messages=[msg for m in in_context_messages for msg in m.to_letta_messages()], usage=LettaUsageStatistics())
def _format_messages_llm_friendly(self):
messages = self.message_manager.list_messages_for_agent(agent_id=self.agent_id, actor=self.actor)
@@ -166,7 +218,7 @@ Use `rethink_user_memor(new_memory)` as many times as you need to iteratively im
def _build_openai_request(self, openai_messages: List[Dict], agent_state: AgentState, tools: List[Tool]) -> ChatCompletionRequest:
openai_request = ChatCompletionRequest(
- model="gpt-4o", # agent_state.llm_config.model, # TODO: Separate config for summarizer?
+ model=agent_state.llm_config.model, # TODO: Separate config for summarizer?
messages=openai_messages,
tools=tools,
tool_choice="required",
@@ -261,14 +313,14 @@ Use `rethink_user_memor(new_memory)` as many times as you need to iteratively im
return tools
- def rethink_user_memory(self, new_memory: str, agent_state: AgentState) -> str:
+ def rethink_user_memory(self, new_memory: str, agent_state: AgentState) -> Tuple[Optional[str], bool]:
if agent_state.memory.get_block(self.target_block_label) is None:
agent_state.memory.create_block(label=self.target_block_label, value=new_memory)
agent_state.memory.update_block_value(label=self.target_block_label, value=new_memory)
- return "Successfully updated memory"
+ return None, True
- def store_memory(self, start_index: int, end_index: int, context: str, agent_state: AgentState) -> str:
+ def store_memory(self, start_index: int, end_index: int, context: str, agent_state: AgentState) -> Tuple[Optional[str], bool]:
"""
Store a memory.
"""
@@ -283,9 +335,9 @@ Use `rethink_user_memor(new_memory)` as many times as you need to iteratively im
)
self.agent_manager.rebuild_system_prompt(agent_id=agent_state.id, actor=self.actor, force=True)
- return "Sucessfully stored memory"
+ return None, True
except Exception as e:
- return f"Failed to store memory given start_index {start_index} and end_index {end_index}: {e}"
+ return f"Failed to store memory given start_index {start_index} and end_index {end_index}: {e}", False
def serialize(self, messages: List[str], context: str) -> str:
"""
@@ -344,4 +396,4 @@ Use `rethink_user_memor(new_memory)` as many times as you need to iteratively im
"""
This agent is synchronous-only. If called in an async context, raise an error.
"""
- raise NotImplementedError("EphemeralMemoryAgent does not support async step.")
+ raise NotImplementedError("VoiceSleeptimeAgent does not support async step.")
diff --git a/letta/client/client.py b/letta/client/client.py
index a9ba7b937..90dd2823a 100644
--- a/letta/client/client.py
+++ b/letta/client/client.py
@@ -1031,7 +1031,7 @@ class RESTClient(AbstractClient):
# messages = []
# for m in response.messages:
# assert isinstance(m, Message)
- # messages += m.to_letta_message()
+ # messages += m.to_letta_messages()
# response.messages = messages
return response
@@ -2725,14 +2725,14 @@ class LocalClient(AbstractClient):
# assert isinstance(m, Message), f"Expected Message object, got {type(m)}"
# letta_messages = []
# for m in messages:
- # letta_messages += m.to_letta_message()
+ # letta_messages += m.to_letta_messages()
# return LettaResponse(messages=letta_messages, usage=usage)
# format messages
messages = self.interface.to_list()
letta_messages = []
for m in messages:
- letta_messages += m.to_letta_message()
+ letta_messages += m.to_letta_messages()
return LettaResponse(messages=letta_messages, usage=usage)
diff --git a/letta/schemas/message.py b/letta/schemas/message.py
index b3cfc2558..2c273bb6e 100644
--- a/letta/schemas/message.py
+++ b/letta/schemas/message.py
@@ -219,7 +219,7 @@ class Message(BaseMessage):
return [
msg
for m in messages
- for msg in m.to_letta_message(
+ for msg in m.to_letta_messages(
use_assistant_message=use_assistant_message,
assistant_message_tool_name=assistant_message_tool_name,
assistant_message_tool_kwarg=assistant_message_tool_kwarg,
@@ -227,7 +227,7 @@ class Message(BaseMessage):
)
]
- def to_letta_message(
+ def to_letta_messages(
self,
use_assistant_message: bool = False,
assistant_message_tool_name: str = DEFAULT_MESSAGE_TOOL,
@@ -447,7 +447,7 @@ class Message(BaseMessage):
name: Optional[str] = None,
group_id: Optional[str] = None,
tool_returns: Optional[List[ToolReturn]] = None,
- ):
+ ) -> Message:
"""Convert a ChatCompletion message object into a Message object (synced to DB)"""
if not created_at:
# timestamp for creation
diff --git a/letta/server/rest_api/routers/v1/voice.py b/letta/server/rest_api/routers/v1/voice.py
index 4a0114872..561081c9e 100644
--- a/letta/server/rest_api/routers/v1/voice.py
+++ b/letta/server/rest_api/routers/v1/voice.py
@@ -56,8 +56,8 @@ async def create_voice_chat_completions(
block_manager=server.block_manager,
passage_manager=server.passage_manager,
actor=actor,
- message_buffer_limit=40,
- message_buffer_min=15,
+ message_buffer_limit=8,
+ message_buffer_min=4,
)
# Return the streaming generator
diff --git a/letta/services/message_manager.py b/letta/services/message_manager.py
index fb39b9550..bca133539 100644
--- a/letta/services/message_manager.py
+++ b/letta/services/message_manager.py
@@ -122,7 +122,7 @@ class MessageManager:
message = self.update_message_by_id(message_id=message_id, message_update=update_message, actor=actor)
# convert back to LettaMessage
- for letta_msg in message.to_letta_message(use_assistant_message=True):
+ for letta_msg in message.to_letta_messages(use_assistant_message=True):
if letta_msg.message_type == letta_message_update.message_type:
return letta_msg
@@ -160,7 +160,7 @@ class MessageManager:
message = self.update_message_by_id(message_id=message_id, message_update=update_message, actor=actor)
# convert back to LettaMessage
- for letta_msg in message.to_letta_message(use_assistant_message=True):
+ for letta_msg in message.to_letta_messages(use_assistant_message=True):
if letta_msg.message_type == letta_message_update.message_type:
return letta_msg
diff --git a/letta/services/summarizer/summarizer.py b/letta/services/summarizer/summarizer.py
index dbcd76dba..b138bd98e 100644
--- a/letta/services/summarizer/summarizer.py
+++ b/letta/services/summarizer/summarizer.py
@@ -3,7 +3,7 @@ import json
import traceback
from typing import List, Tuple
-from letta.agents.ephemeral_memory_agent import EphemeralMemoryAgent
+from letta.agents.voice_sleeptime_agent import VoiceSleeptimeAgent
from letta.log import get_logger
from letta.schemas.enums import MessageRole
from letta.schemas.letta_message_content import TextContent
@@ -21,7 +21,7 @@ class Summarizer:
"""
def __init__(
- self, mode: SummarizationMode, summarizer_agent: EphemeralMemoryAgent, message_buffer_limit: int = 10, message_buffer_min: int = 3
+ self, mode: SummarizationMode, summarizer_agent: VoiceSleeptimeAgent, message_buffer_limit: int = 10, message_buffer_min: int = 3
):
self.mode = mode
@@ -109,17 +109,14 @@ class Summarizer:
evicted_messages_str = "\n".join(formatted_evicted_messages)
in_context_messages_str = "\n".join(formatted_in_context_messages)
- summary_request_text = f"""You are a specialized memory recall agent assisting another AI agent by asynchronously reorganizing its memory storage. The LLM agent you are helping maintains a limited context window that retains only the most recent {self.message_buffer_min} messages from its conversations. The provided conversation history includes messages that are about to be evicted from its context window, as well as some additional recent messages for extra clarity and context.
+ summary_request_text = f"""You’re a memory-recall helper for an AI that can only keep the last {self.message_buffer_min} messages. Scan the conversation history, focusing on messages about to drop out of that window, and write crisp notes that capture any important facts or insights about the human so they aren’t lost.
-Your task is to carefully review the provided conversation history and proactively generate detailed, relevant memories about the human participant, specifically targeting information contained in messages that are about to be evicted from the context window. Your notes will help preserve critical insights, events, or facts that would otherwise be forgotten.
-
-(Older) Evicted Messages:
+(Older) Evicted Messages:\n
{evicted_messages_str}
-(Newer) In-Context Messages:
+(Newer) In-Context Messages:\n
{in_context_messages_str}
"""
-
# Fire-and-forget the summarization task
self.fire_and_forget(
self.summarizer_agent.step([MessageCreate(role=MessageRole.user, content=[TextContent(text=summary_request_text)])])
diff --git a/tests/integration_test_chat_completions.py b/tests/integration_test_chat_completions.py
index 46c555819..1c17b4e40 100644
--- a/tests/integration_test_chat_completions.py
+++ b/tests/integration_test_chat_completions.py
@@ -1,6 +1,5 @@
import os
import threading
-import time
import uuid
import pytest
@@ -9,20 +8,15 @@ from letta_client import Letta
from openai import AsyncOpenAI
from openai.types.chat.chat_completion_chunk import ChatCompletionChunk
-from letta.agents.ephemeral_memory_agent import EphemeralMemoryAgent
from letta.schemas.embedding_config import EmbeddingConfig
-from letta.schemas.enums import MessageRole, MessageStreamStatus
-from letta.schemas.letta_message_content import TextContent
+from letta.schemas.enums import MessageStreamStatus
from letta.schemas.llm_config import LLMConfig
-from letta.schemas.message import MessageCreate
-from letta.schemas.openai.chat_completion_request import ChatCompletionRequest, UserMessage
+from letta.schemas.openai.chat_completion_request import ChatCompletionRequest
+from letta.schemas.openai.chat_completion_request import UserMessage as OpenAIUserMessage
from letta.schemas.tool import ToolCreate
from letta.schemas.usage import LettaUsageStatistics
-from letta.services.agent_manager import AgentManager
-from letta.services.block_manager import BlockManager
-from letta.services.message_manager import MessageManager
from letta.services.tool_manager import ToolManager
-from letta.services.user_manager import UserManager
+from tests.utils import wait_for_server
# --- Server Management --- #
@@ -43,7 +37,7 @@ def server_url():
if not os.getenv("LETTA_SERVER_URL"):
thread = threading.Thread(target=_run_server, daemon=True)
thread.start()
- time.sleep(5) # Allow server startup time
+ wait_for_server(url) # Allow server startup time
return url
@@ -137,7 +131,7 @@ def _get_chat_request(message, stream=True):
"""Returns a chat completion request with streaming enabled."""
return ChatCompletionRequest(
model="gpt-4o-mini",
- messages=[UserMessage(content=message)],
+ messages=[OpenAIUserMessage(content=message)],
stream=stream,
)
@@ -164,150 +158,9 @@ def _assert_valid_chunk(chunk, idx, chunks):
# --- Test Cases --- #
[email protected]("message", ["How are you?"])
[email protected]("endpoint", ["v1/voice-beta"])
-async def test_latency(disable_e2b_api_key, client, agent, message, endpoint):
- """Tests chat completion streaming using the Async OpenAI client."""
- request = _get_chat_request(message)
-
- async_client = AsyncOpenAI(base_url=f"http://localhost:8283/{endpoint}/{agent.id}", max_retries=0)
- import time
-
- print(f"SENT OFF REQUEST {time.perf_counter()}")
- first = True
- stream = await async_client.chat.completions.create(**request.model_dump(exclude_none=True))
- async with stream:
- async for chunk in stream:
- print(chunk)
- if first:
- print(f"FIRST RECEIVED FROM REQUEST{time.perf_counter()}")
- first = False
- continue
-
-
[email protected]("endpoint", ["v1/voice-beta"])
-async def test_multiple_messages(disable_e2b_api_key, client, agent, endpoint):
- """Tests chat completion streaming using the Async OpenAI client."""
- request = _get_chat_request("How are you?")
- async_client = AsyncOpenAI(base_url=f"http://localhost:8283/{endpoint}/{agent.id}", max_retries=0)
-
- stream = await async_client.chat.completions.create(**request.model_dump(exclude_none=True))
- async with stream:
- async for chunk in stream:
- if chunk.choices and chunk.choices[0].delta.content:
- print(chunk.choices[0].delta.content)
- print("============================================")
- request = _get_chat_request("What are you up to?")
- stream = await async_client.chat.completions.create(**request.model_dump(exclude_none=True))
- async with stream:
- async for chunk in stream:
- if chunk.choices and chunk.choices[0].delta.content:
- print(chunk.choices[0].delta.content)
-
-
-async def test_ephemeral_memory_agent(disable_e2b_api_key, agent):
- """Tests chat completion streaming using the Async OpenAI client."""
- async_client = AsyncOpenAI()
- message_transcripts = [
- "user: Hey, I’ve been thinking about planning a road trip up the California coast next month.",
- "assistant: That sounds amazing! Do you have any particular cities or sights in mind?",
- "user: I definitely want to stop in Big Sur and maybe Santa Barbara. Also, I love craft coffee shops.",
- "assistant: Great choices. Would you like recommendations for top-rated coffee spots along the way?",
- "user: Yes, please. Also, I prefer independent cafés over chains, and I’m vegan.",
- "assistant: Noted—independent, vegan-friendly cafés. Anything else?",
- "user: I’d also like to listen to something upbeat, maybe a podcast or playlist suggestion.",
- "assistant: Sure—perhaps an indie rock playlist or a travel podcast like “Zero To Travel.”",
- "user: Perfect. By the way, my birthday is June 12th, so I’ll be turning 30 on the trip.",
- "assistant: Happy early birthday! Would you like gift ideas or celebration tips?",
- "user: Maybe just a recommendation for a nice vegan bakery to grab a birthday treat.",
- "assistant: How about Vegan Treats in Santa Barbara? They’re highly rated.",
- "user: Sounds good. Also, I work remotely as a UX designer, usually on a MacBook Pro.",
- "user: I want to make sure my itinerary isn’t too tight—aiming for 3–4 days total.",
- "assistant: Understood. I can draft a relaxed 4-day schedule with driving and stops.",
- "user: Yes, let’s do that.",
- "assistant: I’ll put together a day-by-day plan now.",
- ]
-
- memory_agent = EphemeralMemoryAgent(
- agent_id=agent.id,
- openai_client=async_client,
- message_manager=MessageManager(),
- agent_manager=AgentManager(),
- actor=UserManager().get_user_or_default(),
- block_manager=BlockManager(),
- target_block_label="human",
- message_transcripts=message_transcripts,
- )
-
- summary_request_text = """
-Here is the conversation history. Lines marked (Older) are about to be evicted; lines marked (Newer) are still in context for clarity:
-
-(Older)
-0. user: Hey, I’ve been thinking about planning a road trip up the California coast next month.
-1. assistant: That sounds amazing! Do you have any particular cities or sights in mind?
-2. user: I definitely want to stop in Big Sur and maybe Santa Barbara. Also, I love craft coffee shops.
-3. assistant: Great choices. Would you like recommendations for top-rated coffee spots along the way?
-4. user: Yes, please. Also, I prefer independent cafés over chains, and I’m vegan.
-5. assistant: Noted—independent, vegan-friendly cafés. Anything else?
-6. user: I’d also like to listen to something upbeat, maybe a podcast or playlist suggestion.
-7. assistant: Sure—perhaps an indie rock playlist or a travel podcast like “Zero To Travel.”
-8. user: Perfect. By the way, my birthday is June 12th, so I’ll be turning 30 on the trip.
-9. assistant: Happy early birthday! Would you like gift ideas or celebration tips?
-10. user: Maybe just a recommendation for a nice vegan bakery to grab a birthday treat.
-11. assistant: How about Vegan Treats in Santa Barbara? They’re highly rated.
-12. user: Sounds good. Also, I work remotely as a UX designer, usually on a MacBook Pro.
-
-(Newer)
-13. user: I want to make sure my itinerary isn’t too tight—aiming for 3–4 days total.
-14. assistant: Understood. I can draft a relaxed 4-day schedule with driving and stops.
-15. user: Yes, let’s do that.
-16. assistant: I’ll put together a day-by-day plan now.
-
-Please segment the (Older) portion into coherent chunks and—using **only** the `store_memory` tool—output a JSON call that lists each chunk’s `start_index`, `end_index`, and a one-sentence `contextual_description`.
- """
-
- results = await memory_agent.step([MessageCreate(role=MessageRole.user, content=[TextContent(text=summary_request_text)])])
- print(results)
-
-
[email protected]("message", ["Use search memory tool to recall what my name is."])
[email protected]("endpoint", ["v1/voice-beta"])
-async def test_voice_recall_memory(disable_e2b_api_key, client, agent, message, endpoint):
- """Tests chat completion streaming using the Async OpenAI client."""
- request = _get_chat_request(message)
-
- # Insert some messages about my name
- client.agents.messages.create(
- agent.id,
- messages=[
- MessageCreate(
- role=MessageRole.user,
- content=[
- TextContent(text="My name is Matt, don't do anything with this information other than call send_message right after.")
- ],
- )
- ],
- )
-
- # Wipe the in context messages
- actor = UserManager().get_default_user()
- AgentManager().set_in_context_messages(agent_id=agent.id, message_ids=[agent.message_ids[0]], actor=actor)
-
- async_client = AsyncOpenAI(base_url=f"http://localhost:8283/{endpoint}/{agent.id}", max_retries=0)
- stream = await async_client.chat.completions.create(**request.model_dump(exclude_none=True))
- async with stream:
- async for chunk in stream:
- if chunk.choices and chunk.choices[0].delta.content:
- print(chunk.choices[0].delta.content)
-
-
@pytest.mark.asyncio
@pytest.mark.parametrize("message", ["Tell me something interesting about bananas.", "What's the weather in SF?"])
[email protected]("endpoint", ["openai/v1"]) # , "v1/voice-beta"])
[email protected]("endpoint", ["openai/v1"])
async def test_chat_completions_streaming_openai_client(disable_e2b_api_key, client, agent, message, endpoint):
"""Tests chat completion streaming using the Async OpenAI client."""
request = _get_chat_request(message)
diff --git a/tests/integration_test_send_message.py b/tests/integration_test_send_message.py
index 3aff0b43f..c9ee862a4 100644
--- a/tests/integration_test_send_message.py
+++ b/tests/integration_test_send_message.py
@@ -79,9 +79,13 @@ def agent_state(client: Letta) -> AgentState:
Creates and returns an agent state for testing with a pre-configured agent.
The agent is named 'supervisor' and is configured with base tools and the roll_dice tool.
"""
+ client.tools.upsert_base_tools()
+
+ send_message_tool = client.tools.list(name="send_message")[0]
agent_state_instance = client.agents.create(
name="supervisor",
- include_base_tools=True,
+ include_base_tools=False,
+ tool_ids=[send_message_tool.id],
model="openai/gpt-4o",
embedding="letta/letta-free",
tags=["supervisor"],
diff --git a/tests/integration_test_voice_agent.py b/tests/integration_test_voice_agent.py
index 1ca6f698c..271091165 100644
--- a/tests/integration_test_voice_agent.py
+++ b/tests/integration_test_voice_agent.py
@@ -1,15 +1,87 @@
+import os
+import threading
+
import pytest
+from dotenv import load_dotenv
+from letta_client import Letta
+from openai import AsyncOpenAI
+from openai.types.chat import ChatCompletionChunk
from sqlalchemy import delete
+from letta.agents.voice_sleeptime_agent import VoiceSleeptimeAgent
from letta.config import LettaConfig
from letta.orm import Provider, Step
from letta.orm.errors import NoResultFound
from letta.schemas.agent import AgentType, CreateAgent
from letta.schemas.block import CreateBlock
+from letta.schemas.embedding_config import EmbeddingConfig
+from letta.schemas.enums import MessageRole, MessageStreamStatus
from letta.schemas.group import ManagerType
-from letta.schemas.letta_message import AssistantMessage, ReasoningMessage
+from letta.schemas.letta_message import AssistantMessage, ReasoningMessage, ToolCallMessage, ToolReturnMessage, UserMessage
+from letta.schemas.letta_message_content import TextContent
+from letta.schemas.llm_config import LLMConfig
from letta.schemas.message import MessageCreate
+from letta.schemas.openai.chat_completion_request import ChatCompletionRequest
+from letta.schemas.openai.chat_completion_request import UserMessage as OpenAIUserMessage
+from letta.schemas.tool import ToolCreate
+from letta.schemas.usage import LettaUsageStatistics
from letta.server.server import SyncServer
+from letta.services.agent_manager import AgentManager
+from letta.services.block_manager import BlockManager
+from letta.services.message_manager import MessageManager
+from letta.services.tool_manager import ToolManager
+from letta.services.user_manager import UserManager
+from letta.utils import get_persona_text
+from tests.utils import wait_for_server
+
+MESSAGE_TRANSCRIPTS = [
+ "user: Hey, I’ve been thinking about planning a road trip up the California coast next month.",
+ "assistant: That sounds amazing! Do you have any particular cities or sights in mind?",
+ "user: I definitely want to stop in Big Sur and maybe Santa Barbara. Also, I love craft coffee shops.",
+ "assistant: Great choices. Would you like recommendations for top-rated coffee spots along the way?",
+ "user: Yes, please. Also, I prefer independent cafés over chains, and I’m vegan.",
+ "assistant: Noted—independent, vegan-friendly cafés. Anything else?",
+ "user: I’d also like to listen to something upbeat, maybe a podcast or playlist suggestion.",
+ "assistant: Sure—perhaps an indie rock playlist or a travel podcast like “Zero To Travel.”",
+ "user: Perfect. By the way, my birthday is June 12th, so I’ll be turning 30 on the trip.",
+ "assistant: Happy early birthday! Would you like gift ideas or celebration tips?",
+ "user: Maybe just a recommendation for a nice vegan bakery to grab a birthday treat.",
+ "assistant: How about Vegan Treats in Santa Barbara? They’re highly rated.",
+ "user: Sounds good. Also, I work remotely as a UX designer, usually on a MacBook Pro.",
+ "user: I want to make sure my itinerary isn’t too tight—aiming for 3–4 days total.",
+ "assistant: Understood. I can draft a relaxed 4-day schedule with driving and stops.",
+ "user: Yes, let’s do that.",
+ "assistant: I’ll put together a day-by-day plan now.",
+]
+
+SUMMARY_REQ_TEXT = """
+Here is the conversation history. Lines marked (Older) are about to be evicted; lines marked (Newer) are still in context for clarity:
+
+(Older)
+0. user: Hey, I’ve been thinking about planning a road trip up the California coast next month.
+1. assistant: That sounds amazing! Do you have any particular cities or sights in mind?
+2. user: I definitely want to stop in Big Sur and maybe Santa Barbara. Also, I love craft coffee shops.
+3. assistant: Great choices. Would you like recommendations for top-rated coffee spots along the way?
+4. user: Yes, please. Also, I prefer independent cafés over chains, and I’m vegan.
+5. assistant: Noted—independent, vegan-friendly cafés. Anything else?
+6. user: I’d also like to listen to something upbeat, maybe a podcast or playlist suggestion.
+7. assistant: Sure—perhaps an indie rock playlist or a travel podcast like “Zero To Travel.”
+8. user: Perfect. By the way, my birthday is June 12th, so I’ll be turning 30 on the trip.
+9. assistant: Happy early birthday! Would you like gift ideas or celebration tips?
+10. user: Maybe just a recommendation for a nice vegan bakery to grab a birthday treat.
+11. assistant: How about Vegan Treats in Santa Barbara? They’re highly rated.
+12. user: Sounds good. Also, I work remotely as a UX designer, usually on a MacBook Pro.
+
+(Newer)
+13. user: I want to make sure my itinerary isn’t too tight—aiming for 3–4 days total.
+14. assistant: Understood. I can draft a relaxed 4-day schedule with driving and stops.
+15. user: Yes, let’s do that.
+16. assistant: I’ll put together a day-by-day plan now.
+
+Please segment the (Older) portion into coherent chunks and—using **only** the `store_memory` tool—output a JSON call that lists each chunk’s `start_index`, `end_index`, and a one-sentence `contextual_description`.
+ """
+
+# --- Server Management --- #
@pytest.fixture(scope="module")
@@ -23,35 +95,95 @@ def server():
return server
[email protected](scope="module")
-def org_id(server):
- org = server.organization_manager.create_default_organization()
+def _run_server():
+ """Starts the Letta server in a background thread."""
+ load_dotenv()
+ from letta.server.rest_api.app import start_server
- yield org.id
+ start_server(debug=True)
- # cleanup
- with server.organization_manager.session_maker() as session:
- session.execute(delete(Step))
- session.execute(delete(Provider))
- session.commit()
- server.organization_manager.delete_organization_by_id(org.id)
[email protected](scope="session")
+def server_url():
+ """Ensures a server is running and returns its base URL."""
+ url = os.getenv("LETTA_SERVER_URL", "http://localhost:8283")
[email protected](scope="module")
-def actor(server, org_id):
- user = server.user_manager.create_default_user()
- yield user
+ if not os.getenv("LETTA_SERVER_URL"):
+ thread = threading.Thread(target=_run_server, daemon=True)
+ thread.start()
+ wait_for_server(url) # Allow server startup time
- # cleanup
- server.user_manager.delete_user_by_id(user.id)
+ return url
-async def test_init_voice_convo_agent(server, actor):
- # 0. Refresh base tools
+# --- Client Setup --- #
+
+
[email protected](scope="session")
+def client(server_url):
+ """Creates a REST client for testing."""
+ client = Letta(base_url=server_url)
+ yield client
+
+
[email protected](scope="function")
+def roll_dice_tool(client):
+ def roll_dice():
+ """
+ Rolls a 6 sided die.
+
+ Returns:
+ str: The roll result.
+ """
+ return "Rolled a 10!"
+
+ tool = client.tools.upsert_from_function(func=roll_dice)
+ # Yield the created tool
+ yield tool
+
+
[email protected](scope="function")
+def weather_tool(client):
+ def get_weather(location: str) -> str:
+ """
+ Fetches the current weather for a given location.
+
+ Parameters:
+ location (str): The location to get the weather for.
+
+ Returns:
+ str: A formatted string describing the weather in the given location.
+
+ Raises:
+ RuntimeError: If the request to fetch weather data fails.
+ """
+ import requests
+
+ url = f"https://wttr.in/{location}?format=%C+%t"
+
+ response = requests.get(url)
+ if response.status_code == 200:
+ weather_data = response.text
+ return f"The weather in {location} is {weather_data}."
+ else:
+ raise RuntimeError(f"Failed to get weather data, status code: {response.status_code}")
+
+ tool = client.tools.upsert_from_function(func=get_weather)
+ # Yield the created tool
+ yield tool
+
+
[email protected](scope="function")
+def composio_gmail_get_profile_tool(default_user):
+ tool_create = ToolCreate.from_composio(action_name="GMAIL_GET_PROFILE")
+ tool = ToolManager().create_or_update_composio_tool(tool_create=tool_create, actor=default_user)
+ yield tool
+
+
[email protected](scope="function")
+def voice_agent(server, actor):
server.tool_manager.upsert_base_tools(actor=actor)
- # 1. Create sleeptime agent
main_agent = server.create_agent(
request=CreateAgent(
agent_type=AgentType.voice_convo_agent,
@@ -73,8 +205,173 @@ async def test_init_voice_convo_agent(server, actor):
actor=actor,
)
- assert main_agent.enable_sleeptime == True
- main_agent_tools = [tool.name for tool in main_agent.tools]
+ return main_agent
+
+
[email protected](scope="module")
+def org_id(server):
+ org = server.organization_manager.create_default_organization()
+
+ yield org.id
+
+ # cleanup
+ with server.organization_manager.session_maker() as session:
+ session.execute(delete(Step))
+ session.execute(delete(Provider))
+ session.commit()
+ server.organization_manager.delete_organization_by_id(org.id)
+
+
[email protected](scope="module")
+def actor(server, org_id):
+ user = server.user_manager.create_default_user()
+ yield user
+
+ # cleanup
+ server.user_manager.delete_user_by_id(user.id)
+
+
+# --- Helper Functions --- #
+
+
+def _get_chat_request(message, stream=True):
+ """Returns a chat completion request with streaming enabled."""
+ return ChatCompletionRequest(
+ model="gpt-4o-mini",
+ messages=[OpenAIUserMessage(content=message)],
+ stream=stream,
+ )
+
+
+def _assert_valid_chunk(chunk, idx, chunks):
+ """Validates the structure of each streaming chunk."""
+ if isinstance(chunk, ChatCompletionChunk):
+ assert chunk.choices, "Each ChatCompletionChunk should have at least one choice."
+
+ elif isinstance(chunk, LettaUsageStatistics):
+ assert chunk.completion_tokens > 0, "Completion tokens must be > 0."
+ assert chunk.prompt_tokens > 0, "Prompt tokens must be > 0."
+ assert chunk.total_tokens > 0, "Total tokens must be > 0."
+ assert chunk.step_count == 1, "Step count must be 1."
+
+ elif isinstance(chunk, MessageStreamStatus):
+ assert chunk == MessageStreamStatus.done, "Stream should end with 'done' status."
+ assert idx == len(chunks) - 1, "The last chunk must be 'done'."
+
+ else:
+ pytest.fail(f"Unexpected chunk type: {chunk}")
+
+
+# --- Tests --- #
+
+
[email protected]("message", ["Use search memory tool to recall what my name is."])
[email protected]("endpoint", ["v1/voice-beta"])
+async def test_voice_recall_memory(disable_e2b_api_key, client, voice_agent, message, endpoint):
+ """Tests chat completion streaming using the Async OpenAI client."""
+ request = _get_chat_request(message)
+
+ async_client = AsyncOpenAI(base_url=f"http://localhost:8283/{endpoint}/{voice_agent.id}", max_retries=0)
+ stream = await async_client.chat.completions.create(**request.model_dump(exclude_none=True))
+ async with stream:
+ async for chunk in stream:
+ if chunk.choices and chunk.choices[0].delta.content:
+ print(chunk.choices[0].delta.content)
+
+
[email protected]("endpoint", ["v1/voice-beta"])
+async def test_multiple_messages(disable_e2b_api_key, client, voice_agent, endpoint):
+ """Tests chat completion streaming using the Async OpenAI client."""
+ request = _get_chat_request("How are you?")
+ async_client = AsyncOpenAI(base_url=f"http://localhost:8283/{endpoint}/{voice_agent.id}", max_retries=0)
+
+ stream = await async_client.chat.completions.create(**request.model_dump(exclude_none=True))
+ async with stream:
+ async for chunk in stream:
+ if chunk.choices and chunk.choices[0].delta.content:
+ print(chunk.choices[0].delta.content)
+ print("============================================")
+ request = _get_chat_request("What are you up to?")
+ stream = await async_client.chat.completions.create(**request.model_dump(exclude_none=True))
+ async with stream:
+ async for chunk in stream:
+ if chunk.choices and chunk.choices[0].delta.content:
+ print(chunk.choices[0].delta.content)
+
+
+async def test_voice_sleeptime_agent(disable_e2b_api_key, voice_agent):
+ """Tests chat completion streaming using the Async OpenAI client."""
+ agent_manager = AgentManager()
+ user_manager = UserManager()
+ actor = user_manager.get_default_user()
+
+ request = CreateAgent(
+ name=voice_agent.name + "-sleeptime",
+ agent_type=AgentType.voice_sleeptime_agent,
+ block_ids=[block.id for block in voice_agent.memory.blocks],
+ memory_blocks=[
+ CreateBlock(
+ label="memory_persona",
+ value=get_persona_text("voice_memory_persona"),
+ ),
+ ],
+ llm_config=LLMConfig.default_config(model_name="gpt-4o-mini"),
+ embedding_config=EmbeddingConfig.default_config(provider="openai"),
+ project_id=voice_agent.project_id,
+ )
+ sleeptime_agent = agent_manager.create_agent(request, actor=actor)
+
+ async_client = AsyncOpenAI()
+
+ memory_agent = VoiceSleeptimeAgent(
+ agent_id=sleeptime_agent.id,
+ convo_agent_state=sleeptime_agent, # In reality, this will be the main convo agent
+ openai_client=async_client,
+ message_manager=MessageManager(),
+ agent_manager=agent_manager,
+ actor=actor,
+ block_manager=BlockManager(),
+ target_block_label="human",
+ message_transcripts=MESSAGE_TRANSCRIPTS,
+ )
+
+ results = await memory_agent.step([MessageCreate(role=MessageRole.user, content=[TextContent(text=SUMMARY_REQ_TEXT)])])
+
+ messages = results.messages
+ # --- Basic structural check ---
+ assert isinstance(messages, list)
+ assert len(messages) >= 5, "Expected at least 5 messages in the sequence"
+
+ # --- Message 0: initial UserMessage ---
+ assert isinstance(messages[0], UserMessage), "First message should be a UserMessage"
+
+ # --- Message 1: store_memories ToolCall ---
+ assert isinstance(messages[1], ToolCallMessage), "Second message should be ToolCallMessage"
+ assert messages[1].name == "store_memories", "Expected store_memories tool call"
+
+ # --- Message 2: store_memories ToolReturn ---
+ assert isinstance(messages[2], ToolReturnMessage), "Third message should be ToolReturnMessage"
+ assert messages[2].name == "store_memories", "Expected store_memories tool return"
+ assert messages[2].status == "success", "store_memories tool return should be successful"
+
+ # --- Message 3: rethink_user_memory ToolCall ---
+ assert isinstance(messages[3], ToolCallMessage), "Fourth message should be ToolCallMessage"
+ assert messages[3].name == "rethink_user_memory", "Expected rethink_user_memory tool call"
+
+ # --- Message 4: rethink_user_memory ToolReturn ---
+ assert isinstance(messages[4], ToolReturnMessage), "Fifth message should be ToolReturnMessage"
+ assert messages[4].name == "rethink_user_memory", "Expected rethink_user_memory tool return"
+ assert messages[4].status == "success", "rethink_user_memory tool return should be successful"
+
+
+async def test_init_voice_convo_agent(voice_agent, server, actor):
+
+ assert voice_agent.enable_sleeptime == True
+ main_agent_tools = [tool.name for tool in voice_agent.tools]
assert len(main_agent_tools) == 2
assert "send_message" in main_agent_tools
assert "search_memory" in main_agent_tools
@@ -84,7 +381,7 @@ async def test_init_voice_convo_agent(server, actor):
# 2. Check that a group was created
group = server.group_manager.retrieve_group(
- group_id=main_agent.multi_agent_group.id,
+ group_id=voice_agent.multi_agent_group.id,
actor=actor,
)
assert group.manager_type == ManagerType.voice_sleeptime
@@ -92,11 +389,11 @@ async def test_init_voice_convo_agent(server, actor):
# 3. Verify shared blocks
sleeptime_agent_id = group.agent_ids[0]
- shared_block = server.agent_manager.get_block_with_label(agent_id=main_agent.id, block_label="human", actor=actor)
+ shared_block = server.agent_manager.get_block_with_label(agent_id=voice_agent.id, block_label="human", actor=actor)
agents = server.block_manager.get_agents_for_block(block_id=shared_block.id, actor=actor)
assert len(agents) == 2
assert sleeptime_agent_id in [agent.id for agent in agents]
- assert main_agent.id in [agent.id for agent in agents]
+ assert voice_agent.id in [agent.id for agent in agents]
# 4 Verify sleeptime agent tools
sleeptime_agent = server.agent_manager.get_agent_by_id(agent_id=sleeptime_agent_id, actor=actor)
@@ -107,7 +404,7 @@ async def test_init_voice_convo_agent(server, actor):
# 5. Send a message as a sanity check
response = await server.send_message_to_agent(
- agent_id=main_agent.id,
+ agent_id=voice_agent.id,
actor=actor,
input_messages=[
MessageCreate(
@@ -124,7 +421,7 @@ async def test_init_voice_convo_agent(server, actor):
assert AssistantMessage in message_types
# 6. Delete agent
- server.agent_manager.delete_agent(agent_id=main_agent.id, actor=actor)
+ server.agent_manager.delete_agent(agent_id=voice_agent.id, actor=actor)
with pytest.raises(NoResultFound):
server.group_manager.retrieve_group(group_id=group.id, actor=actor)