Make your computer a home for your AI partner. Avibe is the local-first Agent OS: Vibey, its built-in AI partner, works out of the box, and Claude Code, Codex & OpenCode run unchanged beside it — reach them from your browser, phone, or any chat app.
Python agentagent-osaiai-agentsai-partnerchatopsclaudeclaude-codecodexdevtoolsdiscord-botlark-botllmlocal-firstlong-term-memoryopencodeslack-botvibe-codingvibeywechat
import base64
import importlib.util
import os
import sys
import tempfile
import unittest
from pathlib import Path
from types import SimpleNamespace
from unittest.mock import ANY, AsyncMock, Mock, patch
sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
_EVENT_HANDLER_PATH = Path(__file__).resolve().parents[1] / "modules/agents/codex/event_handler.py"
_SPEC = importlib.util.spec_from_file_location("test_codex_event_handler_module", _EVENT_HANDLER_PATH)
assert _SPEC is not None and _SPEC.loader is not None
_MODULE = importlib.util.module_from_spec(_SPEC)
_SPEC.loader.exec_module(_MODULE)
CodexEventHandler = _MODULE.CodexEventHandler
STOPPED_REACTION_EMOJI = _MODULE.STOPPED_REACTION_EMOJI
class _TurnState:
def __init__(self, turn_id: str, request):
self.turn_id = turn_id
self.request = request
self.pending_assistant = None
self.pending_assistant_phase = None
self.pending_assistant_id = None
self.pending_narration = []
self.terminal_error = None
self.terminal_error_notified = False
self.visible_to_user = True
self.indicator_cleanup_claimed = False
class _StubTurnRegistry:
def __init__(self):
self._turns = {}
self._active_turns = {}
def register_turn(self, turn_id: str, request):
state = self._turns.get(turn_id)
if state is None:
state = _TurnState(turn_id, request)
self._turns[turn_id] = state
else:
state.request = request
self._active_turns[request.base_session_id] = turn_id
return state
def get_turn(self, turn_id: str):
return self._turns.get(turn_id)
def pop_turn(self, turn_id: str):
state = self._turns.pop(turn_id, None)
if state and self._active_turns.get(state.request.base_session_id) == turn_id:
self._active_turns.pop(state.request.base_session_id, None)
return state
def claim_indicator_cleanup(self, turn_id: str):
state = self._turns.get(turn_id)
if state is None or state.indicator_cleanup_claimed:
return None
state.indicator_cleanup_claimed = True
return state.request
def hide_turn(self, turn_id: str):
state = self._turns.get(turn_id)
if not state:
return None
state.visible_to_user = False
state.pending_assistant = None
state.pending_narration = []
state.terminal_error = None
state.terminal_error_notified = False
if self._active_turns.get(state.request.base_session_id) == turn_id:
self._active_turns.pop(state.request.base_session_id, None)
return state
def should_emit_progress(self, turn_id: str) -> bool:
return self.should_emit_result(turn_id)
def should_emit_terminal_error(self, turn_id: str) -> bool:
return self.should_emit_result(turn_id)
def should_emit_result(self, turn_id: str) -> bool:
state = self._turns.get(turn_id)
if not state:
return False
return state.visible_to_user and self._active_turns.get(state.request.base_session_id) == turn_id
def is_active_turn(self, turn_id: str) -> bool:
state = self._turns.get(turn_id)
if not state:
return False
return self._active_turns.get(state.request.base_session_id) == turn_id
class _StubAgent:
def __init__(self):
self._turn_registry = _StubTurnRegistry()
self._session_mgr = SimpleNamespace(set_thread_id=Mock(), get_thread_id=Mock(return_value=None))
self.controller = SimpleNamespace(
config=SimpleNamespace(reply_enhancements=True),
emit_agent_message=AsyncMock(),
agent_auth_service=SimpleNamespace(maybe_emit_auth_recovery_message=AsyncMock(return_value=False)),
)
self.emit_result_message = AsyncMock()
self._remove_ack_reaction = AsyncMock()
self._maybe_backfill_session_title = Mock()
self._user_stopped_turn_ids: set[str] = set()
def consume_user_stop_intent(self, turn_id):
if turn_id not in self._user_stopped_turn_ids:
return False
self._user_stopped_turn_ids.discard(turn_id)
return True
def bind_agent_session_id(self, request, native_session_id):
payload = dict(request.context.platform_specific or {})
payload["agent_session_id"] = "sesk8m4q2p7x"
request.context.platform_specific = payload
return "sesk8m4q2p7x"
def _get_formatter(self, context):
return SimpleNamespace(format_system_message=lambda *args: "system message")
class CodexEventHandlerTests(unittest.IsolatedAsyncioTestCase):
async def test_thread_started_binds_native_session_through_shared_lifecycle(self):
agent = _StubAgent()
agent.bind_agent_session_id = Mock(wraps=agent.bind_agent_session_id)
handler = CodexEventHandler(agent)
request = SimpleNamespace(
base_session_id="session-1",
session_key="slack::channel::C1",
working_path="/repo",
context=SimpleNamespace(platform_specific={}),
)
await handler._on_thread_started({"thread": {"id": "thread-1"}}, request)
agent._session_mgr.set_thread_id.assert_called_once_with("session-1", "thread-1")
agent.bind_agent_session_id.assert_called_once_with(request, "thread-1")
self.assertEqual(request.context.platform_specific["agent_session_id"], "sesk8m4q2p7x")
agent.controller.emit_agent_message.assert_not_awaited()
async def test_thread_started_does_not_bind_while_fork_correction_is_pending(self):
agent = _StubAgent()
agent.is_fork_correction_pending = Mock(return_value=True)
agent.bind_agent_session_id = Mock(wraps=agent.bind_agent_session_id)
handler = CodexEventHandler(agent)
request = SimpleNamespace(
base_session_id="session-1",
session_key="slack::channel::C1",
working_path="/repo",
context=SimpleNamespace(platform_specific={}),
)
await handler._on_thread_started({"thread": {"id": "thread-1"}}, request)
agent.is_fork_correction_pending.assert_called_once_with("session-1")
agent._session_mgr.set_thread_id.assert_not_called()
agent.bind_agent_session_id.assert_not_called()
self.assertNotIn("agent_session_id", request.context.platform_specific)
async def test_retrying_error_is_suppressed(self):
agent = _StubAgent()
handler = CodexEventHandler(agent)
request = SimpleNamespace(base_session_id="session-1", context=object(), started_at=0)
agent._turn_registry.register_turn("turn-1", request)
await handler._on_error(
{
"error": {"message": "Reconnecting... 5/5"},
"willRetry": True,
"turnId": "turn-1",
},
request,
)
agent.controller.emit_agent_message.assert_not_awaited()
async def test_terminal_turn_error_is_emitted_immediately_and_not_duplicated_on_completion(self):
agent = _StubAgent()
handler = CodexEventHandler(agent)
request = SimpleNamespace(base_session_id="session-1", context=object(), started_at=0)
agent._turn_registry.register_turn("turn-1", request)
await handler._on_error(
{
"error": {"message": "unexpected status 401 Unauthorized:"},
"willRetry": False,
"turnId": "turn-1",
},
request,
)
agent.controller.agent_auth_service.maybe_emit_auth_recovery_message.assert_awaited_once_with(
request.context,
"codex",
"❌ Codex turn failed: unexpected status 401 Unauthorized:",
output=ANY,
terminal_error="unexpected status 401 Unauthorized:",
)
self.assertEqual(agent.controller.emit_agent_message.await_count, 2)
notify_call, terminal_call = agent.controller.emit_agent_message.await_args_list
self.assertEqual(
notify_call.args[:3],
(request.context, "notify", "❌ Codex turn failed: unexpected status 401 Unauthorized:"),
)
self.assertEqual(terminal_call.args[:3], (request.context, "result", ""))
self.assertTrue(terminal_call.kwargs["is_error"])
self.assertEqual(terminal_call.kwargs["level"], "silent")
self.assertEqual(terminal_call.kwargs["terminal_error"], "unexpected status 401 Unauthorized:")
await handler._on_turn_completed(
{
"turn": {
"id": "turn-1",
"status": "failed",
"error": {"message": "fallback message"},
}
},
request,
)
assert agent.controller.emit_agent_message.await_count == 2
agent._remove_ack_reaction.assert_awaited_once_with(request)
async def test_turn_failure_falls_back_to_completion_error_when_no_error_notification_arrives(self):
agent = _StubAgent()
handler = CodexEventHandler(agent)
request = SimpleNamespace(base_session_id="session-1", context=object(), started_at=0)
agent._turn_registry.register_turn("turn-1", request)
await handler._on_turn_completed(
{
"turn": {
"id": "turn-1",
"status": "failed",
"error": {"message": "fallback message"},
}
},
request,
)
agent.controller.agent_auth_service.maybe_emit_auth_recovery_message.assert_awaited_once_with(
request.context,
"codex",
"❌ Codex turn failed: fallback message",
output=ANY,
terminal_error="fallback message",
)
self.assertEqual(agent.controller.emit_agent_message.await_count, 2)
notify_call, terminal_call = agent.controller.emit_agent_message.await_args_list
self.assertEqual(
notify_call.args[:3],
(request.context, "notify", "❌ Codex turn failed: fallback message"),
)
self.assertEqual(terminal_call.args[:3], (request.context, "result", ""))
self.assertEqual(terminal_call.kwargs["terminal_error"], "fallback message")
agent._remove_ack_reaction.assert_awaited_once_with(request)
async def test_unknown_turn_error_is_logged_without_emitting(self):
agent = _StubAgent()
handler = CodexEventHandler(agent)
request = SimpleNamespace(base_session_id="session-1", context=object(), started_at=0)
await handler._on_error(
{
"error": {"message": "old turn failed"},
"willRetry": False,
"turnId": "turn-old",
},
request,
)
agent.controller.emit_agent_message.assert_not_awaited()
def test_clear_pending_hides_turn_and_returns_request(self):
agent = _StubAgent()
handler = CodexEventHandler(agent)
request = SimpleNamespace(base_session_id="session-1", context=object(), started_at=0)
agent._turn_registry.register_turn("turn-1", request)
cleared_request = handler.clear_pending("turn-1")
assert cleared_request is request
turn_state = agent._turn_registry.get_turn("turn-1")
assert turn_state is not None
assert turn_state.visible_to_user is False
async def test_hidden_turn_error_is_logged_without_emitting(self):
agent = _StubAgent()
handler = CodexEventHandler(agent)
request = SimpleNamespace(base_session_id="session-1", context=object(), started_at=0)
agent._turn_registry.register_turn("turn-1", request)
handler.clear_pending("turn-1")
await handler._on_error(
{
"error": {"message": "interrupted turn failed"},
"willRetry": False,
"turnId": "turn-1",
},
request,
)
agent.controller.emit_agent_message.assert_not_awaited()
async def test_hidden_turn_failure_completion_does_not_clear_reaction_without_user_message(self):
agent = _StubAgent()
handler = CodexEventHandler(agent)
request = SimpleNamespace(base_session_id="session-1", context=object(), started_at=0)
agent._turn_registry.register_turn("turn-1", request)
handler.clear_pending("turn-1")
await handler._on_turn_completed(
{
"turn": {
"id": "turn-1",
"status": "failed",
"error": {"message": "hidden failure"},
}
},
request,
)
agent.controller.emit_agent_message.assert_not_awaited()
agent._remove_ack_reaction.assert_not_awaited()
async def test_inactive_completion_does_not_clear_reaction_without_result_message(self):
agent = _StubAgent()
handler = CodexEventHandler(agent)
stale_request = SimpleNamespace(base_session_id="session-1", context=object(), started_at=0)
active_request = SimpleNamespace(base_session_id="session-1", context=object(), started_at=0)
agent._turn_registry.register_turn("turn-1", stale_request)
agent._turn_registry.register_turn("turn-2", active_request)
await handler._on_turn_completed(
{
"turn": {
"id": "turn-1",
"status": "completed",
}
},
stale_request,
)
agent.emit_result_message.assert_not_awaited()
agent._remove_ack_reaction.assert_not_awaited()
async def test_interrupted_completion_releases_runtime_gate_without_result(self):
agent = _StubAgent()
release_runtime_turn = Mock()
agent.controller.agent_service = SimpleNamespace(release_runtime_turn=release_runtime_turn)
handler = CodexEventHandler(agent)
context = SimpleNamespace(
platform_specific={
"agent_runtime_turn_key": "session-1:/repo",
"agent_runtime_turn_token": "R1",
}
)
request = SimpleNamespace(base_session_id="session-1", context=context, started_at=0)
agent._turn_registry.register_turn("turn-1", request)
await handler._on_turn_completed(
{
"turn": {
"id": "turn-1",
"status": "interrupted",
}
},
request,
)
agent.emit_result_message.assert_not_awaited()
release_runtime_turn.assert_called_once_with(context)
# Superseded by a newer turn, not stopped by the user: no receipt.
agent._remove_ack_reaction.assert_awaited_once_with(request, terminal_emoji=None)
async def test_user_stopped_completion_stamps_the_receipt(self):
# The completion notification can beat handle_stop's own RPC back. When
# it does, it inherits the duty to trade the 👀 for a ⏹️ — otherwise the
# silent stop leaves the message showing nothing at all.
agent = _StubAgent()
agent.controller.agent_service = SimpleNamespace(release_runtime_turn=Mock())
handler = CodexEventHandler(agent)
context = SimpleNamespace(platform_specific={})
request = SimpleNamespace(base_session_id="session-1", context=context, started_at=0)
agent._turn_registry.register_turn("turn-1", request)
agent._user_stopped_turn_ids.add("turn-1")
await handler._on_turn_completed(
{"turn": {"id": "turn-1", "status": "interrupted"}}, request
)
agent._remove_ack_reaction.assert_awaited_once_with(
request, terminal_emoji=STOPPED_REACTION_EMOJI
)
# Consumed: handle_stop must not stamp a second one behind it.
self.assertEqual(agent._user_stopped_turn_ids, set())
async def test_hidden_turn_completion_cannot_compete_with_claimed_cleanup(self):
agent = _StubAgent()
agent.controller.agent_service = SimpleNamespace(release_runtime_turn=Mock())
handler = CodexEventHandler(agent)
context = SimpleNamespace(platform_specific={})
request = SimpleNamespace(base_session_id="session-1", context=context, started_at=0)
agent._turn_registry.register_turn("turn-1", request)
claimed_request = handler.clear_pending("turn-1")
await handler._on_turn_completed(
{"turn": {"id": "turn-1", "status": "interrupted"}}, request
)
self.assertIs(claimed_request, request)
agent._remove_ack_reaction.assert_not_awaited()
async def test_auth_recovery_message_suppresses_plain_notify(self):
agent = _StubAgent()
agent.controller.agent_auth_service.maybe_emit_auth_recovery_message = AsyncMock(return_value=True)
handler = CodexEventHandler(agent)
request = SimpleNamespace(base_session_id="session-1", context=object(), started_at=0)
agent._turn_registry.register_turn("turn-1", request)
await handler._on_error(
{
"error": {"message": "unexpected status 401 Unauthorized:"},
"willRetry": False,
"turnId": "turn-1",
},
request,
)
agent.controller.emit_agent_message.assert_not_awaited()
async def test_auth_recovery_completion_still_clears_reaction(self):
agent = _StubAgent()
agent.controller.agent_auth_service.maybe_emit_auth_recovery_message = AsyncMock(return_value=True)
handler = CodexEventHandler(agent)
request = SimpleNamespace(base_session_id="session-1", context=object(), started_at=0)
agent._turn_registry.register_turn("turn-1", request)
await handler._on_turn_completed(
{
"turn": {
"id": "turn-1",
"status": "failed",
"error": {"message": "unexpected status 401 Unauthorized:"},
}
},
request,
)
agent.controller.emit_agent_message.assert_not_awaited()
agent._remove_ack_reaction.assert_awaited_once_with(request)
async def test_inactive_turn_item_is_ignored(self):
agent = _StubAgent()
handler = CodexEventHandler(agent)
request = SimpleNamespace(base_session_id="session-1", context=object(), started_at=0)
stale_request = SimpleNamespace(base_session_id="session-1", context=object(), started_at=0)
agent._turn_registry.register_turn("turn-1", stale_request)
agent._turn_registry.register_turn("turn-2", request)
await handler._on_item_completed(
{
"turnId": "turn-1",
"item": {"type": "agentMessage", "text": "old output"},
},
stale_request,
)
agent.controller.emit_agent_message.assert_not_awaited()
async def test_silent_followup_preserves_visible_result_candidate(self):
agent = _StubAgent()
handler = CodexEventHandler(agent)
request = SimpleNamespace(base_session_id="session-1", context=object(), started_at=0)
agent._turn_registry.register_turn("turn-1", request)
await handler._on_item_completed(
{
"turnId": "turn-1",
"item": {"type": "agentMessage", "text": "Regression report"},
},
request,
)
await handler._on_item_completed(
{
"turnId": "turn-1",
"item": {"type": "agentMessage", "text": "<silent>Watch acknowledged</silent>"},
},
request,
)
await handler._on_turn_completed(
{"turn": {"id": "turn-1", "status": "completed"}},
request,
)
agent.controller.emit_agent_message.assert_not_awaited()
agent.emit_result_message.assert_awaited_once()
assert agent.emit_result_message.await_args.args[1] == "Regression report"
async def test_visible_followup_replaces_silent_candidate_without_activity(self):
agent = _StubAgent()
handler = CodexEventHandler(agent)
request = SimpleNamespace(base_session_id="session-1", context=object(), started_at=0)
agent._turn_registry.register_turn("turn-1", request)
await handler._on_item_completed(
{
"turnId": "turn-1",
"item": {"type": "agentMessage", "text": "<silent>Waiting</silent>"},
},
request,
)
await handler._on_item_completed(
{
"turnId": "turn-1",
"item": {"type": "agentMessage", "text": "Final answer"},
},
request,
)
await handler._on_turn_completed(
{"turn": {"id": "turn-1", "status": "completed"}},
request,
)
agent.controller.emit_agent_message.assert_not_awaited()
agent.emit_result_message.assert_awaited_once()
assert agent.emit_result_message.await_args.args[1] == "Final answer"
async def test_silent_only_turn_still_emits_terminal_result(self):
agent = _StubAgent()
handler = CodexEventHandler(agent)
request = SimpleNamespace(base_session_id="session-1", context=object(), started_at=0)
agent._turn_registry.register_turn("turn-1", request)
silent_result = "<silent>No user-facing response needed</silent>"
await handler._on_item_completed(
{
"turnId": "turn-1",
"item": {"type": "agentMessage", "text": silent_result},
},
request,
)
await handler._on_turn_completed(
{"turn": {"id": "turn-1", "status": "completed"}},
request,
)
agent.controller.emit_agent_message.assert_not_awaited()
agent.emit_result_message.assert_awaited_once()
assert agent.emit_result_message.await_args.args[1] == silent_result
async def test_visible_followup_keeps_prior_visible_message_as_activity(self):
agent = _StubAgent()
handler = CodexEventHandler(agent)
request = SimpleNamespace(base_session_id="session-1", context=object(), started_at=0)
agent._turn_registry.register_turn("turn-1", request)
await handler._on_item_completed(
{
"turnId": "turn-1",
"item": {"type": "agentMessage", "text": "Progress update"},
},
request,
)
await handler._on_item_completed(
{
"turnId": "turn-1",
"item": {"type": "agentMessage", "text": "Final answer"},
},
request,
)
await handler._on_turn_completed(
{"turn": {"id": "turn-1", "status": "completed"}},
request,
)
agent.controller.emit_agent_message.assert_awaited_once_with(
request.context,
"assistant",
"Progress update",
parse_mode="markdown",
)
agent.emit_result_message.assert_awaited_once()
assert agent.emit_result_message.await_args.args[1] == "Final answer"
async def test_an_answer_a_steer_follows_stays_a_reply_in_turn_order(self):
"""Scenario: MESSAGE-DELIVERY-335.
Codex declares each answer with ``agentMessage.phase``. An answer that more
output follows (here: the steered input's commentary, a tool call, and its
own answer) is still a reply: a ``result`` that does not end the Turn,
delivered before what follows it. ``commentary`` is narration, and the last
answer rides the Turn end.
"""
agent = _StubAgent()
handler = CodexEventHandler(agent)
request = SimpleNamespace(base_session_id="session-1", context=object(), started_at=0)
agent._turn_registry.register_turn("turn-1", request)
agent._get_formatter = lambda _context: SimpleNamespace(
format_toolcall=lambda name, payload, **_kwargs: f"tool {payload['command']}"
)
for item in (
{"type": "agentMessage", "id": "msg_1", "text": "Looking at the cache.", "phase": "commentary"},
{"type": "agentMessage", "id": "msg_2", "text": "The cache is safe.", "phase": "final_answer"},
# The steered input: "and the lock?"
{"type": "agentMessage", "id": "msg_3", "text": "Checking the lock.", "phase": "commentary"},
{"type": "commandExecution", "command": "rg lock", "status": "completed", "exitCode": 0},
{"type": "agentMessage", "id": "msg_4", "text": "The cache is safe.", "phase": "partial_answer"},
{"type": "agentMessage", "id": "msg_5", "text": "The lock is fine too.", "phase": "final_answer"},
):
await handler._on_item_completed({"turnId": "turn-1", "item": item}, request)
await handler._on_turn_completed({"turn": {"id": "turn-1", "status": "completed"}}, request)
emitted = [
(call.args[1], call.args[2], call.kwargs.get("output"))
for call in agent.controller.emit_agent_message.await_args_list
]
assert [(role, text) for role, text, _ in emitted] == [
("assistant", "Looking at the cache."),
("result", "The cache is safe."),
("assistant", "Checking the lock."),
("toolcall", "tool rg lock"),
("result", "The cache is safe."),
]
for role, _, output in emitted:
if role == "result":
assert output is not None and not output.completes_turn and not output.settles_run
else:
assert output is None
# Each reply is identified by its item, so the same text twice stays two replies.
assert [output.idempotency_key for role, _, output in emitted if role == "result"] == ["msg_2", "msg_4"]
agent.emit_result_message.assert_awaited_once()
assert agent.emit_result_message.await_args.args[1] == "The lock is fine too."
async def test_a_message_without_a_phase_goes_out_before_what_follows_it(self):
"""Scenario: MESSAGE-DELIVERY-335.
A message with no phase is the reply only while it is the last visible item:
commentary or a tool call after it makes it narration, delivered first, in
the provider's order; a Turn that then completes has no reply of its own.
"""
agent = _StubAgent()
handler = CodexEventHandler(agent)
request = SimpleNamespace(base_session_id="session-1", context=object(), started_at=0)
agent._turn_registry.register_turn("turn-1", request)
agent._get_formatter = lambda _context: SimpleNamespace(
format_toolcall=lambda name, payload, **_kwargs: f"tool {payload['command']}"
)
for item in (
{"type": "agentMessage", "id": "msg_1", "text": "The cache is safe."},
{"type": "agentMessage", "id": "msg_2", "text": "Checking the lock.", "phase": "commentary"},
{"type": "agentMessage", "id": "msg_3", "text": "One writer holds it."},
{"type": "commandExecution", "command": "rg lock", "status": "completed", "exitCode": 0},
):
await handler._on_item_completed({"turnId": "turn-1", "item": item}, request)
await handler._on_turn_completed({"turn": {"id": "turn-1", "status": "completed"}}, request)
assert [
(call.args[1], call.args[2], call.kwargs.get("output"))
for call in agent.controller.emit_agent_message.await_args_list
] == [
("assistant", "The cache is safe.", None),
("assistant", "Checking the lock.", None),
("assistant", "One writer holds it.", None),
("toolcall", "tool rg lock", None),
]
agent.emit_result_message.assert_awaited_once()
assert not agent.emit_result_message.await_args.args[1]
async def test_a_silent_answer_keeps_the_declared_answer_as_the_turns_reply(self):
"""Scenario: MESSAGE-DELIVERY-335: a silent answer after a declared one shows nothing
and does not demote it; that answer rides the Turn end."""
agent = _StubAgent()
handler = CodexEventHandler(agent)
request = SimpleNamespace(base_session_id="session-1", context=object(), started_at=0)
agent._turn_registry.register_turn("turn-1", request)
for item in (
{"type": "agentMessage", "text": "Regression report", "phase": "final_answer"},
{"type": "agentMessage", "text": "<silent>Watch acknowledged</silent>", "phase": "final_answer"},
):
await handler._on_item_completed({"turnId": "turn-1", "item": item}, request)
await handler._on_turn_completed({"turn": {"id": "turn-1", "status": "completed"}}, request)
agent.controller.emit_agent_message.assert_not_awaited()
assert agent.emit_result_message.await_args.args[1] == "Regression report"
async def test_reasoning_summary_stays_process_only(self):
agent = _StubAgent()
handler = CodexEventHandler(agent)
request = SimpleNamespace(base_session_id="session-1", context=object(), started_at=0)
agent._turn_registry.register_turn("turn-1", request)
await handler._on_item_completed(
{
"turnId": "turn-1",
"item": {"type": "reasoning", "summary": ["Weighing the options"]},
},
request,
)
agent.controller.emit_agent_message.assert_awaited_once_with(
request.context,
"assistant",
"_🧠 Weighing the options_",
parse_mode="markdown",
level="process",
)
async def test_empty_success_result_falls_back_to_new_thread_generated_images(self):
agent = _StubAgent()
handler = CodexEventHandler(agent)
request = SimpleNamespace(base_session_id="session-1", context=object(), started_at=0)
agent._turn_registry.register_turn("turn-1", request)
with tempfile.TemporaryDirectory() as tmpdir, patch.dict(os.environ, {"CODEX_HOME": tmpdir}):
thread_dir = Path(tmpdir) / "generated_images" / "thread-1"
thread_dir.mkdir(parents=True)
old_image = thread_dir / "old.png"
old_image.write_bytes(b"old")
handler.snapshot_generated_images("thread-1", "session-1")
handler.bind_generated_image_snapshot("thread-1", "turn-1", "session-1")
new_image = thread_dir / "new image.png"
new_image.write_bytes(b"new")
await handler._on_turn_completed(
{
"threadId": "thread-1",
"turn": {"id": "turn-1", "status": "completed"},
},
request,
)
agent.emit_result_message.assert_awaited_once()
result_text = agent.emit_result_message.await_args.args[1]
assert "Generated image:" in result_text
assert f".as_uri()})" in result_text
assert str(old_image.resolve()) not in result_text
agent._maybe_backfill_session_title.assert_called_once_with(request, "thread-1")
async def test_empty_success_result_falls_back_when_generated_image_path_is_reused(self):
agent = _StubAgent()
handler = CodexEventHandler(agent)
request = SimpleNamespace(base_session_id="session-1", context=object(), started_at=0)
agent._turn_registry.register_turn("turn-1", request)
with tempfile.TemporaryDirectory() as tmpdir, patch.dict(os.environ, {"CODEX_HOME": tmpdir}):
thread_dir = Path(tmpdir) / "generated_images" / "thread-1"
thread_dir.mkdir(parents=True)
image = thread_dir / "image.png"
image.write_bytes(b"old")
handler.snapshot_generated_images("thread-1", "session-1")
handler.bind_generated_image_snapshot("thread-1", "turn-1", "session-1")
image.write_bytes(b"new-content")
await handler._on_turn_completed(
{
"threadId": "thread-1",
"turn": {"id": "turn-1", "status": "completed"},
},
request,
)
agent.emit_result_message.assert_awaited_once()
result_text = agent.emit_result_message.await_args.args[1]
assert f".as_uri()})" in result_text
async def test_stale_interrupted_turn_does_not_clear_new_turn_image_snapshot(self):
agent = _StubAgent()
handler = CodexEventHandler(agent)
request = SimpleNamespace(base_session_id="session-1", context=object(), started_at=0)
agent._turn_registry.register_turn("turn-1", request)
with tempfile.TemporaryDirectory() as tmpdir, patch.dict(os.environ, {"CODEX_HOME": tmpdir}):
thread_dir = Path(tmpdir) / "generated_images" / "thread-1"
thread_dir.mkdir(parents=True)
before_second_turn = thread_dir / "before-second-turn.png"
before_second_turn.write_bytes(b"old")
handler.snapshot_generated_images("thread-1", "session-1")
handler.bind_generated_image_snapshot("thread-1", "turn-1", "session-1")
agent._turn_registry.register_turn("turn-2", request)
handler.snapshot_generated_images("thread-1", "session-1")
await handler._on_turn_completed(
{
"threadId": "thread-1",
"turn": {"id": "turn-1", "status": "interrupted"},
},
request,
)
new_image = thread_dir / "new-for-turn-2.png"
new_image.write_bytes(b"new")
handler.bind_generated_image_snapshot("thread-1", "turn-2", "session-1")
await handler._on_turn_completed(
{
"threadId": "thread-1",
"turn": {"id": "turn-2", "status": "completed"},
},
request,
)
result_text = agent.emit_result_message.await_args.args[1]
assert f".as_uri()})" in result_text
assert str(before_second_turn.resolve()) not in result_text
async def test_stale_turn_started_does_not_steal_pending_image_snapshot(self):
agent = _StubAgent()
handler = CodexEventHandler(agent)
request = SimpleNamespace(base_session_id="session-1", context=object(), started_at=0)
agent._turn_registry.register_turn("turn-1", request)
handler.clear_pending("turn-1")
agent._turn_registry.register_turn("turn-2", request)
with tempfile.TemporaryDirectory() as tmpdir, patch.dict(os.environ, {"CODEX_HOME": tmpdir}):
thread_dir = Path(tmpdir) / "generated_images" / "thread-1"
thread_dir.mkdir(parents=True)
handler.snapshot_generated_images("thread-1", "session-1")
await handler._on_turn_started(
{
"threadId": "thread-1",
"turn": {"id": "turn-1"},
},
request,
)
new_image = thread_dir / "new-for-turn-2.png"
new_image.write_bytes(b"new")
handler.bind_generated_image_snapshot("thread-1", "turn-2", "session-1")
await handler._on_turn_completed(
{
"threadId": "thread-1",
"turn": {"id": "turn-2", "status": "completed"},
},
request,
)
result_text = agent.emit_result_message.await_args.args[1]
assert f".as_uri()})" in result_text
async def test_empty_success_result_does_not_guess_without_image_snapshot(self):
agent = _StubAgent()
handler = CodexEventHandler(agent)
request = SimpleNamespace(base_session_id="session-1", context=object(), started_at=0)
agent._turn_registry.register_turn("turn-1", request)
with tempfile.TemporaryDirectory() as tmpdir, patch.dict(os.environ, {"CODEX_HOME": tmpdir}):
thread_dir = Path(tmpdir) / "generated_images" / "thread-1"
thread_dir.mkdir(parents=True)
image = thread_dir / "new.png"
image.write_bytes(b"new")
await handler._on_turn_completed(
{
"threadId": "thread-1",
"turn": {"id": "turn-1", "status": "completed"},
},
request,
)
agent.emit_result_message.assert_awaited_once()
assert agent.emit_result_message.await_args.args[1] is None
assert handler._image_snapshots_by_turn == {}
async def test_generated_image_fallback_ignores_quick_reply_button_setting(self):
agent = _StubAgent()
agent.controller.config.reply_enhancements = False
handler = CodexEventHandler(agent)
request = SimpleNamespace(base_session_id="session-1", context=object(), started_at=0)
agent._turn_registry.register_turn("turn-1", request)
with tempfile.TemporaryDirectory() as tmpdir, patch.dict(os.environ, {"CODEX_HOME": tmpdir}):
thread_dir = Path(tmpdir) / "generated_images" / "thread-1"
thread_dir.mkdir(parents=True)
handler.snapshot_generated_images("thread-1", "session-1")
handler.bind_generated_image_snapshot("thread-1", "turn-1", "session-1")
image = thread_dir / "new.png"
image.write_bytes(b"new")
await handler._on_turn_completed(
{
"threadId": "thread-1",
"turn": {"id": "turn-1", "status": "completed"},
},
request,
)
agent.emit_result_message.assert_awaited_once()
result = agent.emit_result_message.await_args.args[1]
assert ":
agent = _StubAgent()
handler = CodexEventHandler(agent)
request = SimpleNamespace(base_session_id="session-1", context=object(), started_at=0)
state = agent._turn_registry.register_turn("turn-1", request)
state.pending_assistant = ("Image ready.", "markdown")
image = base64.b64decode(
"iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mNk"
"+A8AAQUBAScY42YAAAAASUVORK5CYII="
)
with tempfile.TemporaryDirectory() as tmpdir, patch.dict(os.environ, {"CODEX_HOME": tmpdir}):
handler.snapshot_generated_images("thread-1", "session-1")
handler.bind_generated_image_snapshot("thread-1", "turn-1", "session-1")
items = []
for item_id in ("image-call-1", "image-call-2"):
item = {
"id": item_id,
"type": "imageGeneration",
"status": "completed",
"result": base64.b64encode(image).decode(),
}
items.append(item)
await handler._on_item_completed(
{
"threadId": "thread-1",
"turnId": "turn-1",
"item": item,
},
request,
)
await handler._on_turn_completed(
{
"threadId": "thread-1",
"turn": {
"id": "turn-1",
"status": "completed",
"items": items,
},
},
request,
)
generated = list((Path(tmpdir) / "generated_images" / "thread-1").glob("*.png"))
assert len(generated) == 2
assert all(path.read_bytes() == image for path in generated)
result = agent.emit_result_message.await_args.args[1]
assert result.startswith("Image ready.\n\n
assert result.count(" == 2
async def test_terminal_turn_snapshot_persists_image_without_item_notification(self):
agent = _StubAgent()
handler = CodexEventHandler(agent)
request = SimpleNamespace(base_session_id="session-1", context=object(), started_at=0)
state = agent._turn_registry.register_turn("turn-1", request)
state.pending_assistant = ("Image ready.", "markdown")
image = base64.b64decode(
"iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mNk"
"+A8AAQUBAScY42YAAAAASUVORK5CYII="
)
item = {
"id": "image-call-1",
"type": "imageGeneration",
"status": "completed",
"result": base64.b64encode(image).decode(),
}
with tempfile.TemporaryDirectory() as tmpdir, patch.dict(os.environ, {"CODEX_HOME": tmpdir}):
handler.snapshot_generated_images("thread-1", "session-1")
handler.bind_generated_image_snapshot("thread-1", "turn-1", "session-1")
await handler._on_turn_completed(
{
"threadId": "thread-1",
"turn": {
"id": "turn-1",
"status": "completed",
"items": [item],
},
},
request,
)
generated = list((Path(tmpdir) / "generated_images" / "thread-1").glob("*.png"))
assert len(generated) == 1
assert generated[0].read_bytes() == image
result = agent.emit_result_message.await_args.args[1]
assert result.startswith("Image ready.\n\n
async def test_terminal_turn_snapshot_replaces_attachment_placeholder(self):
agent = _StubAgent()
handler = CodexEventHandler(agent)
request = SimpleNamespace(base_session_id="session-1", context=object(), started_at=0)
state = agent._turn_registry.register_turn("turn-1", request)
state.pending_assistant = (
"",
"markdown",
)
image = base64.b64decode(
"iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mNk"
"+A8AAQUBAScY42YAAAAASUVORK5CYII="
)
with tempfile.TemporaryDirectory() as tmpdir, patch.dict(os.environ, {"CODEX_HOME": tmpdir}):
handler.snapshot_generated_images("thread-1", "session-1")
handler.bind_generated_image_snapshot("thread-1", "turn-1", "session-1")
await handler._on_turn_completed(
{
"threadId": "thread-1",
"turn": {
"id": "turn-1",
"status": "completed",
"items": [
{
"id": "image-call-1",
"type": "imageGeneration",
"status": "completed",
"result": base64.b64encode(image).decode(),
}
],
},
},
request,
)
result = agent.emit_result_message.await_args.args[1]
assert result.startswith("
assert "attachment://" not in result
assert result.count("![") == 1
async def test_inline_image_rejects_invalid_or_unsupported_payloads(self):
agent = _StubAgent()
handler = CodexEventHandler(agent)
request = SimpleNamespace(base_session_id="session-1", context=object(), started_at=0)
agent._turn_registry.register_turn("turn-1", request)
with tempfile.TemporaryDirectory() as tmpdir, patch.dict(os.environ, {"CODEX_HOME": tmpdir}):
handler.snapshot_generated_images("thread-1", "session-1")
handler.bind_generated_image_snapshot("thread-1", "turn-1", "session-1")
for result in ("not-base64", base64.b64encode(b"plain text").decode()):
await handler._on_item_completed(
{
"threadId": "thread-1",
"turnId": "turn-1",
"item": {
"type": "imageGeneration",
"status": "completed",
"result": result,
},
},
request,
)
assert not (Path(tmpdir) / "generated_images" / "thread-1").exists()
def test_generated_images_dir_rejects_dot_segment_thread_ids(self):
agent = _StubAgent()
handler = CodexEventHandler(agent)
assert handler._generated_images_dir(".") is None
assert handler._generated_images_dir("..") is None
assert handler._generated_images_dir("../other") is None
if __name__ == "__main__":
unittest.main()