Fimeg/letta-server
1
0
Fork 0
Code Issues Pull Requests Actions 2 Packages Projects Releases Wiki Activity

Revert "feat: bring back use message packing for timezone [LET-6846]" (#9302)

Browse Source 
Revert "feat: bring back use message packing for timezone [LET-6846] (#9256)"

This reverts commit c5017cccdef95b84fc585b26a0ddc5b7e44eb7c9.
This commit is contained in:
Ari Webb
2026-02-05 11:14:08 -08:00
committed by Caren Thomas
parent 644f7b9d5d
commit 5c6ca705f1
7 changed files with 12 additions and 194 deletions
Download Patch File Download Diff File Expand all files Collapse all files

103
tests/managers/test_agent_manager.py
View File

@@ -699,109 +699,6 @@ async def test_update_agent(server: SyncServer, comprehensive_test_agent_fixture
assert updated_agent.updated_at > last_updated_timestamp
@pytest.mark.asyncio
async def test_create_agent_without_timezone_no_message_packing(server: SyncServer, default_user, default_block):
"""Test that agent created without timezone has raw user messages (not JSON wrapped)."""
test_message = "hello world without timezone"
memory_blocks = [CreateBlock(label="human", value="TestUser"), CreateBlock(label="persona", value="I am a helpful assistant")]
create_agent_request = CreateAgent(
agent_type="memgpt_v2_agent",
system="test system",
memory_blocks=memory_blocks,
llm_config=LLMConfig.default_config("gpt-4o-mini"),
embedding_config=EmbeddingConfig.default_config(provider="openai"),
block_ids=[default_block.id],
initial_message_sequence=[MessageCreate(role=MessageRole.user, content=test_message)],
include_base_tools=False,
# No timezone specified - should be None
)
agent_state = await server.agent_manager.create_agent_async(
create_agent_request,
actor=default_user,
)
try:
# Verify timezone is None
assert agent_state.timezone is None, f"Expected timezone to be None, got {agent_state.timezone}"
# Get the messages
init_messages = await server.message_manager.get_messages_by_ids_async(message_ids=agent_state.message_ids, actor=default_user)
# Find the user message
user_messages = [m for m in init_messages if m.role == MessageRole.user]
assert len(user_messages) == 1, f"Expected 1 user message, got {len(user_messages)}"
# Check that the raw content is the plain text (not JSON wrapped)
raw_content = user_messages[0].content[0].text
assert raw_content == test_message, f"Expected raw message '{test_message}', got '{raw_content}'"
# Verify it's NOT JSON
try:
parsed = json.loads(raw_content)
# If we get here, the content is JSON - that's wrong for no-timezone case
assert False, f"Expected raw text but got JSON: {parsed}"
except json.JSONDecodeError:
# Expected - the content should not be valid JSON
pass
finally:
await server.agent_manager.delete_agent_async(agent_id=agent_state.id, actor=default_user)
@pytest.mark.asyncio
async def test_create_agent_with_timezone_message_packing(server: SyncServer, default_user, default_block):
"""Test that agent created with timezone has JSON wrapped user messages with timestamp."""
test_message = "hello world with timezone"
memory_blocks = [CreateBlock(label="human", value="TestUser"), CreateBlock(label="persona", value="I am a helpful assistant")]
create_agent_request = CreateAgent(
agent_type="memgpt_v2_agent",
system="test system",
memory_blocks=memory_blocks,
llm_config=LLMConfig.default_config("gpt-4o-mini"),
embedding_config=EmbeddingConfig.default_config(provider="openai"),
block_ids=[default_block.id],
initial_message_sequence=[MessageCreate(role=MessageRole.user, content=test_message)],
include_base_tools=False,
timezone="America/Los_Angeles",
)
agent_state = await server.agent_manager.create_agent_async(
create_agent_request,
actor=default_user,
)
try:
# Verify timezone is set
assert agent_state.timezone == "America/Los_Angeles", f"Expected timezone 'America/Los_Angeles', got {agent_state.timezone}"
# Get the messages
init_messages = await server.message_manager.get_messages_by_ids_async(message_ids=agent_state.message_ids, actor=default_user)
# Find the user message
user_messages = [m for m in init_messages if m.role == MessageRole.user]
assert len(user_messages) == 1, f"Expected 1 user message, got {len(user_messages)}"
# Check that the raw content is JSON wrapped
raw_content = user_messages[0].content[0].text
# Verify it IS valid JSON with expected structure
parsed = json.loads(raw_content)
assert isinstance(parsed, dict), f"Expected JSON object, got {type(parsed)}"
assert "type" in parsed, "Expected 'type' field in packed message"
assert "message" in parsed, "Expected 'message' field in packed message"
assert "time" in parsed, "Expected 'time' field in packed message"
# Verify the inner message content
assert parsed["type"] == "user_message", f"Expected type 'user_message', got '{parsed['type']}'"
assert parsed["message"] == test_message, f"Expected inner message '{test_message}', got '{parsed['message']}'"
# Verify the time contains timezone info (PST or PDT for America/Los_Angeles)
time_str = parsed["time"]
assert any(tz in time_str for tz in ["PST", "PDT", "-0800", "-0700"]), (
f"Expected Pacific timezone indicator in time string '{time_str}'"
)
finally:
await server.agent_manager.delete_agent_async(agent_id=agent_state.id, actor=default_user)
@pytest.mark.asyncio
async def test_create_agent_with_compaction_settings(server: SyncServer, default_user, default_block):
"""Test that agents can be created with custom compaction_settings"""

75
tests/test_client.py
View File

@@ -790,81 +790,6 @@ def test_initial_sequence(client: Letta):
# assert agent.timezone == "America/New_York"
def test_agent_timezone_none_no_message_packing(client: Letta):
"""Test that agent created without timezone has timezone=None and messages are not JSON wrapped."""
agent = client.agents.create(
memory_blocks=[{"label": "human", "value": ""}, {"label": "persona", "value": ""}],
model="anthropic/claude-haiku-4-5-20251001",
embedding="openai/text-embedding-3-small",
# No timezone specified
)
try:
# Verify timezone is None
retrieved_agent = client.agents.retrieve(agent_id=agent.id)
assert retrieved_agent.timezone is None, f"Expected timezone to be None, got {retrieved_agent.timezone}"
# Send a message
test_message = "Hello, this is a test message without timezone"
client.agents.messages.create(
agent_id=agent.id,
messages=[MessageCreateParam(role="user", content=test_message)],
)
# List messages and find the user message
messages = client.agents.messages.list(agent_id=agent.id).items
user_messages = [m for m in messages if m.message_type == "user_message"]
assert len(user_messages) > 0, "Expected at least one user message"
# The user message content should be the raw text (not JSON wrapped)
# When timezone is None, the message is stored as-is and retrieved as-is
latest_user_message = user_messages[0]
assert latest_user_message.content == test_message, f"Expected raw message '{test_message}', got '{latest_user_message.content}'"
finally:
client.agents.delete(agent_id=agent.id)
def test_agent_timezone_set_message_packing(client: Letta):
"""Test that agent created with timezone has messages JSON wrapped with timestamp."""
agent = client.agents.create(
memory_blocks=[{"label": "human", "value": ""}, {"label": "persona", "value": ""}],
model="anthropic/claude-haiku-4-5-20251001",
embedding="openai/text-embedding-3-small",
timezone="America/Los_Angeles",
)
try:
# Verify timezone is set
retrieved_agent = client.agents.retrieve(agent_id=agent.id)
assert retrieved_agent.timezone == "America/Los_Angeles", f"Expected timezone 'America/Los_Angeles', got {retrieved_agent.timezone}"
# Send a message
test_message = "Hello, this is a test message with timezone"
client.agents.messages.create(
agent_id=agent.id,
messages=[MessageCreateParam(role="user", content=test_message)],
)
# List messages and find the user message
messages = client.agents.messages.list(agent_id=agent.id).items
user_messages = [m for m in messages if m.message_type == "user_message"]
assert len(user_messages) > 0, "Expected at least one user message"
# The user message content should be unpacked to just the message text
# (The API unpacks the JSON wrapper before returning)
latest_user_message = user_messages[0]
assert latest_user_message.content == test_message, (
f"Expected unpacked message '{test_message}', got '{latest_user_message.content}'"
)
# Test that updating timezone works
client.agents.update(agent_id=agent.id, timezone="America/New_York")
updated_agent = client.agents.retrieve(agent_id=agent.id)
assert updated_agent.timezone == "America/New_York", f"Expected updated timezone 'America/New_York', got {updated_agent.timezone}"
finally:
client.agents.delete(agent_id=agent.id)
def test_attach_sleeptime_block(client: Letta):
agent = client.agents.create(
memory_blocks=[{"label": "human", "value": ""}, {"label": "persona", "value": ""}],