JiuwenSwarm is an intelligent AI Agent built on openJiuwen. It extends the powerful capabilities of large language models directly to your fingertips through various communication apps you use daily.
Python
from __future__ import annotations
import json
import time
from pathlib import Path
from unittest.mock import patch
import pytest
# ---------------------------------------------------------------------------
# helpers
# ---------------------------------------------------------------------------
def _write_history(path: Path, records: list[dict]) -> None:
path.parent.mkdir(parents=True, exist_ok=True)
if path.suffix == ".jsonl":
payload = "\n".join(json.dumps(record, ensure_ascii=False) for record in records)
if payload:
payload += "\n"
path.write_text(payload, encoding="utf-8")
return
path.write_text(json.dumps(records, ensure_ascii=False, indent=2), encoding="utf-8")
def _read_history(path: Path) -> list[dict]:
deadline = time.time() + 5
while time.time() < deadline:
if path.exists():
if path.suffix == ".jsonl":
data = [
json.loads(line)
for line in path.read_text(encoding="utf-8").splitlines()
if line.strip()
]
else:
data = json.loads(path.read_text(encoding="utf-8"))
if data:
return data
time.sleep(0.05)
if not path.exists():
return []
if path.suffix == ".jsonl":
return [
json.loads(line)
for line in path.read_text(encoding="utf-8").splitlines()
if line.strip()
]
return json.loads(path.read_text(encoding="utf-8"))
def _make_user_record(index: int, content: str | None = None, ts: float | None = None) -> dict:
content = content or f"user message {index}"
return {
"id": f"u{index}",
"role": "user",
"content": content,
"request_id": f"r{index}",
"timestamp": ts if ts is not None else float(index),
}
def _make_assistant_record(
index: int,
content: str | None = None,
event_type: str | None = None,
ts: float | None = None,
) -> dict:
content = content or f"assistant response {index}"
return {
"id": f"a{index}",
"role": "assistant",
"content": content,
"request_id": f"r{index}",
"timestamp": ts if ts is not None else float(index) + 0.5,
"event_type": event_type,
}
# ---------------------------------------------------------------------------
# compact_partial_session tests
# ---------------------------------------------------------------------------
def _setup_compact_patches(monkeypatch, tmp_path):
monkeypatch.setattr(
"jiuwenswarm.agents.harness.common.session_ops_service.get_agent_sessions_dir",
lambda: tmp_path,
)
monkeypatch.setattr(
"jiuwenswarm.server.runtime.session.session_history.get_agent_sessions_dir",
lambda: tmp_path,
)
monkeypatch.setattr(
"jiuwenswarm.server.runtime.session.session_metadata.get_agent_sessions_dir",
lambda: tmp_path,
)
monkeypatch.setattr(
"jiuwenswarm.server.runtime.session.session_metadata._enqueue_write",
lambda *args, **kwargs: None,
)
# ---------------------------------------------------------------------------
# compact_partial_session tests
# ---------------------------------------------------------------------------
class TestCompactPartialSessionFrom:
@staticmethod
def test_compact_from_direction_truncates_history(tmp_path, monkeypatch):
_setup_compact_patches(monkeypatch, tmp_path)
records = [
_make_user_record(1, "first question"),
_make_assistant_record(1, "first answer"),
_make_user_record(2, "second question"),
_make_assistant_record(2, "second answer"),
_make_user_record(3, "third question"),
_make_assistant_record(3, "third answer"),
]
_write_history((tmp_path / "s1" / "history.jsonl"), records)
from jiuwenswarm.agents.harness.common.session_ops_service import compact_partial_session
result = compact_partial_session(session_id="s1", turn_index=2, direction="from")
assert result["direction"] == "from"
assert result["turn_index"] == 2
assert result["summarized_messages"] == 4
assert result["removed_records"] == 4
assert "second question" in result["content"]
final_history = _read_history(tmp_path / "s1" / "history.jsonl")
event_types = [r.get("event_type") for r in final_history]
assert "context.compact_boundary" in event_types
assert "context.rewind_summary" in event_types
@staticmethod
def test_compact_from_with_llm_summary(tmp_path, monkeypatch):
_setup_compact_patches(monkeypatch, tmp_path)
records = [
_make_user_record(1, "hello"),
_make_assistant_record(1, "hi there"),
]
_write_history((tmp_path / "s2" / "history.jsonl"), records)
from jiuwenswarm.agents.harness.common.session_ops_service import compact_partial_session
result = compact_partial_session(
session_id="s2",
turn_index=1,
direction="from",
llm_summary="LLM generated summary text",
)
final_history = _read_history(tmp_path / "s2" / "history.jsonl")
event_types = [r.get("event_type") for r in final_history]
assert event_types == [
"context.compact_boundary",
"context.rewind_summary",
"context.compact_summary",
]
compact_entry = final_history[2]
assert compact_entry["content"] == "LLM generated summary text"
assert compact_entry["is_compact_summary"] is True
assert compact_entry["transcript_only"] is True
class TestCompactPartialSessionUpTo:
@staticmethod
def test_compact_up_to_direction_keeps_later_turns(tmp_path, monkeypatch):
_setup_compact_patches(monkeypatch, tmp_path)
records = [
_make_user_record(1, "first question"),
_make_assistant_record(1, "first answer"),
_make_user_record(2, "second question"),
_make_assistant_record(2, "second answer"),
_make_user_record(3, "third question"),
_make_assistant_record(3, "third answer"),
]
_write_history((tmp_path / "s3" / "history.jsonl"), records)
from jiuwenswarm.agents.harness.common.session_ops_service import compact_partial_session
result = compact_partial_session(session_id="s3", turn_index=3, direction="up_to")
assert result["direction"] == "up_to"
assert result["removed_records"] == 4
assert result["summarized_messages"] == 4
assert "third question" in result["content"]
final_history = _read_history(tmp_path / "s3" / "history.jsonl")
event_types = [r.get("event_type") for r in final_history]
assert "context.compact_boundary" in event_types
assert "context.rewind_summary" in event_types
class TestCompactPartialSessionErrors:
@staticmethod
def test_raises_on_invalid_turn_index(tmp_path, monkeypatch):
monkeypatch.setattr(
"jiuwenswarm.agents.harness.common.session_ops_service.get_agent_sessions_dir",
lambda: tmp_path,
)
monkeypatch.setattr(
"jiuwenswarm.server.runtime.session.session_history.get_agent_sessions_dir",
lambda: tmp_path,
)
records = [
_make_user_record(1, "hello"),
_make_assistant_record(1, "hi"),
]
_write_history((tmp_path / "s4" / "history.jsonl"), records)
from jiuwenswarm.agents.harness.common.session_ops_service import compact_partial_session
with pytest.raises(ValueError, match="turn_index must be >= 1"):
compact_partial_session(session_id="s4", turn_index=0, direction="from")
with pytest.raises(ValueError, match="exceeds total turns"):
compact_partial_session(session_id="s4", turn_index=99, direction="from")
@staticmethod
def test_raises_on_missing_history(tmp_path, monkeypatch):
monkeypatch.setattr(
"jiuwenswarm.agents.harness.common.session_ops_service.get_agent_sessions_dir",
lambda: tmp_path,
)
monkeypatch.setattr(
"jiuwenswarm.server.runtime.session.session_history.get_agent_sessions_dir",
lambda: tmp_path,
)
from jiuwenswarm.agents.harness.common.session_ops_service import compact_partial_session
with pytest.raises(ValueError, match="session history not found"):
compact_partial_session(session_id="no_such", turn_index=1, direction="from")
@staticmethod
def test_raises_on_no_user_messages(tmp_path, monkeypatch):
monkeypatch.setattr(
"jiuwenswarm.agents.harness.common.session_ops_service.get_agent_sessions_dir",
lambda: tmp_path,
)
monkeypatch.setattr(
"jiuwenswarm.server.runtime.session.session_history.get_agent_sessions_dir",
lambda: tmp_path,
)
records = [
{
"id": "a1",
"role": "assistant",
"content": "only assistant",
"request_id": "r1",
"timestamp": 1.0,
},
]
_write_history((tmp_path / "s5" / "history.jsonl"), records)
from jiuwenswarm.agents.harness.common.session_ops_service import compact_partial_session
with pytest.raises(ValueError, match="no user messages"):
compact_partial_session(session_id="s5", turn_index=1, direction="from")
@staticmethod
def test_raises_on_unknown_direction(tmp_path, monkeypatch):
monkeypatch.setattr(
"jiuwenswarm.agents.harness.common.session_ops_service.get_agent_sessions_dir",
lambda: tmp_path,
)
monkeypatch.setattr(
"jiuwenswarm.server.runtime.session.session_history.get_agent_sessions_dir",
lambda: tmp_path,
)
records = [
_make_user_record(1, "hello"),
_make_assistant_record(1, "hi"),
]
_write_history((tmp_path / "s6" / "history.jsonl"), records)
from jiuwenswarm.agents.harness.common.session_ops_service import compact_partial_session
with pytest.raises(ValueError, match="unknown direction"):
compact_partial_session(session_id="s6", turn_index=1, direction="bad")
# ---------------------------------------------------------------------------
# _build_messages_for_model tests
# ---------------------------------------------------------------------------
class TestBuildMessagesForModel:
@staticmethod
def test_filters_system_and_tool_records():
records = [
{"role": "system", "content": "system prompt"},
{"role": "user", "content": "user query"},
{"role": "assistant", "content": "assistant reply", "event_type": "chat.final"},
{"role": "tool", "content": '{"result": "ok"}'},
]
result = _build_model_messages(records)
assert len(result) == 2
assert result[0].content == "user query"
assert result[1].content == "assistant reply"
@staticmethod
def test_skips_tool_call_event_types():
records = [
{"role": "user", "content": "do something"},
{"role": "assistant", "content": "calling tool", "event_type": "chat.tool_call"},
{"role": "assistant", "content": "final answer", "event_type": "chat.final"},
]
result = _build_model_messages(records)
assert len(result) == 2
assert result[0].content == "do something"
assert result[1].content == "final answer"
@staticmethod
def test_strips_file_content_blocks():
records = [
{
"role": "user",
"content": "Look at this file\n<file-content path='x.py'>code here</file-content>\nWhat do you think?",
},
]
result = _build_model_messages(records)
assert len(result) == 1
assert "<file-content" not in result[0].content
assert "Look at this file" in result[0].content
assert "What do you think?" in result[0].content
@staticmethod
def test_skips_empty_content():
records = [
{"role": "user", "content": ""},
{"role": "user", "content": " "},
{"role": "user", "content": "actual message"},
]
result = _build_model_messages(records)
assert len(result) == 1
assert result[0].content == "actual message"
@staticmethod
def test_includes_compact_and_rewind_summary_events():
records = [
{"role": "user", "content": "start"},
{"role": "assistant", "content": "compact summary", "event_type": "context.compact_summary"},
{"role": "assistant", "content": "rewind summary", "event_type": "context.rewind_summary"},
]
result = _build_model_messages(records)
assert len(result) == 3
assert result[1].content == "compact summary"
assert result[2].content == "rewind summary"
@staticmethod
def test_skips_compact_boundary_events():
records = [
{"role": "user", "content": "before compact"},
{"role": "assistant", "content": "Conversation compacted", "event_type": "context.compact_boundary"},
{"role": "user", "content": "after compact"},
]
result = _build_model_messages(records)
assert len(result) == 2
contents = [m.content for m in result]
assert "Conversation compacted" not in contents
@staticmethod
def test_skips_non_dict_records():
records = [
"not a dict",
{"role": "user", "content": "valid message"},
]
result = _build_model_messages(records)
assert len(result) == 1
assert result[0].content == "valid message"
def _build_model_messages(records):
from openjiuwen.core.foundation.llm.schema.message import UserMessage, AssistantMessage
messages = []
for rec in records:
if not isinstance(rec, dict):
continue
role = rec.get("role")
content = rec.get("content")
if not isinstance(content, str) or not content.strip():
continue
event_type = rec.get("event_type")
if role == "user":
import re
cleaned = re.sub(r"<file-content[^>]*>.*?</file-content>", "", content, flags=re.DOTALL).strip()
if cleaned:
messages.append(UserMessage(content=cleaned))
elif role == "assistant":
if event_type in ("chat.final", "context.compact_summary", "context.rewind_summary") or not event_type:
if event_type in ("context.compact_boundary",):
continue
messages.append(AssistantMessage(content=content))
return messages
# ---------------------------------------------------------------------------
# compact_partial_prompts tests
# ---------------------------------------------------------------------------
class TestCompactPartialPrompts:
@staticmethod
def test_no_tools_preamble_contains_critical():
from jiuwenswarm.server.runtime.agent_adapter.compact_partial_prompts import NO_TOOLS_PREAMBLE
assert "CRITICAL" in NO_TOOLS_PREAMBLE
assert "Do NOT call any tools" in NO_TOOLS_PREAMBLE
assert "<analysis>" in NO_TOOLS_PREAMBLE
@staticmethod
def test_partial_compact_prompt_has_required_sections():
from jiuwenswarm.server.runtime.agent_adapter.compact_partial_prompts import PARTIAL_COMPACT_PROMPT
assert "Primary Request and Intent" in PARTIAL_COMPACT_PROMPT
assert "Key Technical Concepts" in PARTIAL_COMPACT_PROMPT
assert "Files and Code Sections" in PARTIAL_COMPACT_PROMPT
assert "Errors and fixes" in PARTIAL_COMPACT_PROMPT
assert "Problem Solving" in PARTIAL_COMPACT_PROMPT
assert "All user messages" in PARTIAL_COMPACT_PROMPT
assert "Pending Tasks" in PARTIAL_COMPACT_PROMPT
assert "Current Work" in PARTIAL_COMPACT_PROMPT
assert "Optional Next Step" in PARTIAL_COMPACT_PROMPT
@staticmethod
def test_partial_compact_up_to_prompt_has_required_sections():
from jiuwenswarm.server.runtime.agent_adapter.compact_partial_prompts import PARTIAL_COMPACT_UP_TO_PROMPT
assert "Primary Request and Intent" in PARTIAL_COMPACT_UP_TO_PROMPT
assert "Key Technical Concepts" in PARTIAL_COMPACT_UP_TO_PROMPT
assert "Files and Code Sections" in PARTIAL_COMPACT_UP_TO_PROMPT
assert "Errors and fixes" in PARTIAL_COMPACT_UP_TO_PROMPT
assert "Problem Solving" in PARTIAL_COMPACT_UP_TO_PROMPT
assert "All user messages" in PARTIAL_COMPACT_UP_TO_PROMPT
assert "Pending Tasks" in PARTIAL_COMPACT_UP_TO_PROMPT
assert "Work Completed" in PARTIAL_COMPACT_UP_TO_PROMPT
assert "Context for Continuing Work" in PARTIAL_COMPACT_UP_TO_PROMPT
@staticmethod
def test_prompt_strings_are_not_empty():
from jiuwenswarm.server.runtime.agent_adapter.compact_partial_prompts import (
NO_TOOLS_PREAMBLE,
PARTIAL_COMPACT_PROMPT,
PARTIAL_COMPACT_UP_TO_PROMPT,
)
assert len(NO_TOOLS_PREAMBLE.strip()) > 0
assert len(PARTIAL_COMPACT_PROMPT.strip()) > 0
assert len(PARTIAL_COMPACT_UP_TO_PROMPT.strip()) > 0
# ---------------------------------------------------------------------------
# rewind_session_context with compact_summary / rewind_summary injection
# ---------------------------------------------------------------------------
class TestRewindSessionContextInjectsSummaries:
@pytest.mark.asyncio
async def test_compact_summary_injected_as_user_message(self, tmp_path, monkeypatch):
sessions_dir = tmp_path / "sessions"
sessions_dir.mkdir()
history = [
{
"role": "user", "id": "u1", "request_id": "r1",
"content": "first question", "timestamp": 1.0,
},
{
"role": "assistant", "content": "first answer",
"event_type": "chat.final", "timestamp": 1.5,
},
{
"role": "assistant", "content": "Conversation compacted",
"event_type": "context.compact_boundary", "timestamp": 2.0,
},
{
"role": "assistant",
"content": "Summarized 2 messages from this point.",
"event_type": "context.rewind_summary", "timestamp": 2.001,
},
{
"role": "assistant",
"content": "LLM summary: user asked a question and got an answer.",
"event_type": "context.compact_summary", "timestamp": 2.002,
},
]
_write_history((sessions_dir / "s1" / "history.jsonl"), history)
monkeypatch.setattr(
"jiuwenswarm.agents.harness.common.session_ops_service.get_agent_sessions_dir",
lambda: sessions_dir,
)
monkeypatch.setattr(
"jiuwenswarm.server.runtime.session.session_history.get_agent_sessions_dir",
lambda: sessions_dir,
)
from unittest.mock import AsyncMock, MagicMock
mock_context_engine = MagicMock()
mock_context_engine.get_context.return_value = None
mock_context_engine.clear_context = AsyncMock()
mock_context_engine.create_context = AsyncMock()
mock_context_engine.save_contexts = AsyncMock()
mock_react_agent = MagicMock()
mock_react_agent.context_engine = mock_context_engine
mock_session = MagicMock()
mock_session.pre_run = AsyncMock()
mock_session.post_run = AsyncMock()
mock_session.update_state = MagicMock()
mock_deep_agent = MagicMock()
mock_deep_agent.react_agent = mock_react_agent
mock_deep_agent.card = MagicMock()
mock_deep_agent.save_state = MagicMock()
with patch(
"openjiuwen.core.single_agent.create_agent_session",
return_value=mock_session,
):
from jiuwenswarm.agents.harness.common.session_ops_service import rewind_session_context
result = await rewind_session_context(
deep_agent=mock_deep_agent,
session_id="s1",
turn_index=1,
)
assert result is True
mock_context_engine.create_context.assert_called_once()
_, kwargs = mock_context_engine.create_context.call_args
history_messages = kwargs["history_messages"]
from openjiuwen.core.foundation.llm.schema.message import UserMessage
user_contents = [m.content for m in history_messages if isinstance(m, UserMessage)]
assert "LLM summary: user asked a question and got an answer." in user_contents
assert "Summarized 2 messages from this point." in user_contents
@pytest.mark.asyncio
async def test_rewind_summary_without_compact_summary(self, tmp_path, monkeypatch):
sessions_dir = tmp_path / "sessions"
sessions_dir.mkdir()
history = [
{
"role": "user", "id": "u1", "request_id": "r1",
"content": "hello world", "timestamp": 1.0,
},
{
"role": "assistant", "content": "hi there",
"event_type": "chat.final", "timestamp": 1.5,
},
{
"role": "assistant",
"content": "Summarized 2 messages up to this point.",
"event_type": "context.rewind_summary", "timestamp": 2.0,
},
]
_write_history((sessions_dir / "s2" / "history.jsonl"), history)
monkeypatch.setattr(
"jiuwenswarm.agents.harness.common.session_ops_service.get_agent_sessions_dir",
lambda: sessions_dir,
)
monkeypatch.setattr(
"jiuwenswarm.server.runtime.session.session_history.get_agent_sessions_dir",
lambda: sessions_dir,
)
from unittest.mock import AsyncMock, MagicMock
mock_context_engine = MagicMock()
mock_context_engine.get_context.return_value = None
mock_context_engine.clear_context = AsyncMock()
mock_context_engine.create_context = AsyncMock()
mock_context_engine.save_contexts = AsyncMock()
mock_react_agent = MagicMock()
mock_react_agent.context_engine = mock_context_engine
mock_session = MagicMock()
mock_session.pre_run = AsyncMock()
mock_session.post_run = AsyncMock()
mock_session.update_state = MagicMock()
mock_deep_agent = MagicMock()
mock_deep_agent.react_agent = mock_react_agent
mock_deep_agent.card = MagicMock()
mock_deep_agent.save_state = MagicMock()
with patch(
"openjiuwen.core.single_agent.create_agent_session",
return_value=mock_session,
):
from jiuwenswarm.agents.harness.common.session_ops_service import rewind_session_context
result = await rewind_session_context(
deep_agent=mock_deep_agent,
session_id="s2",
turn_index=1,
)
assert result is True
mock_context_engine.create_context.assert_called_once()
_, kwargs = mock_context_engine.create_context.call_args
history_messages = kwargs["history_messages"]
from openjiuwen.core.foundation.llm.schema.message import UserMessage
user_contents = [m.content for m in history_messages if isinstance(m, UserMessage)]
assert "Summarized 2 messages up to this point." in user_contents
class TestRewindSessionContextLiveSession:
@pytest.mark.asyncio
async def test_reuses_interaction_session_and_commits(self, tmp_path, monkeypatch):
"""Live DeepAgent session must be updated in-place (commit, not post_run)."""
sessions_dir = tmp_path / "sessions"
sessions_dir.mkdir()
history = [
{
"role": "user", "id": "u1", "request_id": "r1",
"content": "10以内最大的质数", "timestamp": 1.0,
},
{
"role": "assistant", "content": "7",
"event_type": "chat.final", "timestamp": 1.5,
},
]
_write_history((sessions_dir / "live1" / "history.jsonl"), history)
monkeypatch.setattr(
"jiuwenswarm.agents.harness.common.session_ops_service.get_agent_sessions_dir",
lambda: sessions_dir,
)
monkeypatch.setattr(
"jiuwenswarm.server.runtime.session.session_history.get_agent_sessions_dir",
lambda: sessions_dir,
)
from unittest.mock import AsyncMock, MagicMock
mock_context_engine = MagicMock()
mock_context_engine.get_context.return_value = None
mock_context_engine.clear_context = AsyncMock()
mock_context_engine.create_context = AsyncMock()
mock_context_engine.save_contexts = AsyncMock()
mock_react_agent = MagicMock()
mock_react_agent.context_engine = mock_context_engine
live_session = MagicMock()
live_session.get_session_id.return_value = "live1"
live_session.pre_run = AsyncMock()
live_session.post_run = AsyncMock()
live_session.commit = AsyncMock()
live_session.update_state = MagicMock()
mock_deep_agent = MagicMock()
mock_deep_agent.react_agent = mock_react_agent
mock_deep_agent.card = MagicMock()
mock_deep_agent.save_state = MagicMock()
mock_deep_agent._interaction_session = live_session
mock_deep_agent._loop_session = live_session
create_session = MagicMock()
with patch(
"openjiuwen.core.single_agent.create_agent_session",
create_session,
):
from jiuwenswarm.agents.harness.common.session_ops_service import rewind_session_context
result = await rewind_session_context(
deep_agent=mock_deep_agent,
session_id="live1",
turn_index=2,
)
assert result is True
create_session.assert_not_called()
live_session.pre_run.assert_not_called()
live_session.post_run.assert_not_called()
live_session.commit.assert_awaited()
mock_context_engine.create_context.assert_called_once()
_, kwargs = mock_context_engine.create_context.call_args
assert kwargs["session"] is live_session
history_messages = kwargs["history_messages"]
from openjiuwen.core.foundation.llm.schema.message import UserMessage, AssistantMessage
assert any(isinstance(m, UserMessage) and "质数" in m.content for m in history_messages)
assert any(isinstance(m, AssistantMessage) and m.content == "7" for m in history_messages)
@pytest.mark.asyncio
async def test_empty_history_still_clears_live_context(self, tmp_path, monkeypatch):
sessions_dir = tmp_path / "sessions"
sessions_dir.mkdir()
(sessions_dir / "empty1").mkdir()
(sessions_dir / "empty1" / "history.jsonl").write_text("", encoding="utf-8")
monkeypatch.setattr(
"jiuwenswarm.agents.harness.common.session_ops_service.get_agent_sessions_dir",
lambda: sessions_dir,
)
monkeypatch.setattr(
"jiuwenswarm.server.runtime.session.session_history.get_agent_sessions_dir",
lambda: sessions_dir,
)
from unittest.mock import AsyncMock, MagicMock
mock_context_engine = MagicMock()
mock_context_engine.get_context.return_value = None
mock_context_engine.clear_context = AsyncMock()
mock_context_engine.create_context = AsyncMock()
mock_context_engine.save_contexts = AsyncMock()
mock_react_agent = MagicMock()
mock_react_agent.context_engine = mock_context_engine
live_session = MagicMock()
live_session.get_session_id.return_value = "empty1"
live_session.commit = AsyncMock()
live_session.post_run = AsyncMock()
live_session.update_state = MagicMock()
mock_deep_agent = MagicMock()
mock_deep_agent.react_agent = mock_react_agent
mock_deep_agent.card = MagicMock()
mock_deep_agent.save_state = MagicMock()
mock_deep_agent._interaction_session = live_session
from jiuwenswarm.agents.harness.common.session_ops_service import rewind_session_context
result = await rewind_session_context(
deep_agent=mock_deep_agent,
session_id="empty1",
turn_index=1,
)
assert result is True
mock_context_engine.clear_context.assert_awaited()
mock_context_engine.create_context.assert_called_once()
_, kwargs = mock_context_engine.create_context.call_args
assert kwargs["history_messages"] == []
live_session.commit.assert_awaited()
live_session.post_run.assert_not_called()