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
"""OpenCode's /stop must leave a ⏹️ receipt like the other two backends.
OpenCode has no interrupt RPC: a stop cancels the in-flight request task, and
the cancellation lands inside the request coroutine, which is what owns the 👀.
That coroutine cannot tell a user stop from a shutdown or a ``clear_sessions``
sweep on its own, so ``handle_stop`` publishes the intent for the duration of
the cancellation. Without it, an OpenCode stop clears the reaction and emits a
silent result — a turn that ends with no trace at all.
"""
from __future__ import annotations
import asyncio
import sys
import unittest
from pathlib import Path
from types import SimpleNamespace
from unittest.mock import AsyncMock, Mock
import pytest
sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
from config.v2_sessions import ActivePollInfo
from core.native_dispatch_phase import mark_prewrite_user_stop
from core.processing_indicator import STOPPED_REACTION_EMOJI, ProcessingIndicatorService
from modules.agents.base import AgentRequest
from modules.agents.opencode.agent import OpenCodeAgent
from modules.agents.opencode.poll_loop import OpenCodePollLoop
from modules.agents.opencode.session import OpenCodeSessionManager
from modules.im.base import MessageContext
from tests.opencode_generation_fakes import serve_opencode_agent
def _agent():
agent = object.__new__(OpenCodeAgent)
agent._active_requests = {}
agent._user_stopped_sessions = set()
agent._session_generations = {}
session_lock = asyncio.Lock()
agent._session_manager = SimpleNamespace(
get_request_session=lambda _base: None,
get_session_lock=lambda _base: session_lock,
)
async def _abort(_base, task, _request_session, *, cancel_before_abort=False):
if cancel_before_abort and not task.done():
task.cancel()
return True
agent._abort_active_request = AsyncMock(side_effect=_abort)
agent.sessions = SimpleNamespace(remove_active_poll=Mock())
agent.controller = SimpleNamespace(emit_agent_message=AsyncMock())
return agent
def _request(session_id="session-1"):
return SimpleNamespace(
base_session_id=session_id,
working_path="/tmp",
context=SimpleNamespace(platform_specific={}),
output=None,
)
class OpenCodeStopIntentTests(unittest.IsolatedAsyncioTestCase):
async def test_native_abort_settles_before_request_releases_turn_ownership(self):
agent = _agent()
request = _request()
request_started = asyncio.Event()
abort_started = asyncio.Event()
release_abort = asyncio.Event()
agent.controller.mark_turn_complete = Mock()
async def in_flight(_request):
request_started.set()
await asyncio.Event().wait()
async def abort(_base, task, _request_session, *, cancel_before_abort=False):
self.assertTrue(cancel_before_abort)
task.cancel()
abort_started.set()
await release_abort.wait()
return True
agent._process_message = in_flight
agent._abort_active_request = abort
agent._session_manager.pop_request_session = Mock()
message_task = asyncio.create_task(agent.handle_message(request))
await request_started.wait()
stop_task = asyncio.create_task(agent.handle_stop(request))
await abort_started.wait()
await asyncio.sleep(0)
self.assertFalse(message_task.done())
agent.controller.mark_turn_complete.assert_not_called()
release_abort.set()
self.assertTrue(await stop_task)
await message_task
agent.controller.mark_turn_complete.assert_called_once_with(request.context)
async def test_cancelled_request_sees_the_user_stop_intent(self):
agent = _agent()
observed: list[bool] = []
entered = asyncio.Event()
async def in_flight():
try:
entered.set()
await asyncio.sleep(3600)
except asyncio.CancelledError:
# This is the branch that decides between a plain removal and
# the receipt; it must be able to see the intent from here.
observed.append("session-1" in agent._user_stopped_sessions)
raise
task = asyncio.create_task(in_flight())
agent._active_requests["session-1"] = task
await entered.wait()
result = await agent.handle_stop(_request())
self.assertTrue(result)
self.assertEqual(observed, [True])
# Cleared afterwards: a later shutdown of the same session is not a stop.
self.assertEqual(agent._user_stopped_sessions, set())
async def test_intent_is_released_even_when_the_abort_fails(self):
agent = _agent()
async def in_flight():
await asyncio.sleep(3600)
task = asyncio.create_task(in_flight())
agent._active_requests["session-1"] = task
await asyncio.sleep(0)
async def abort_then_fail(*_args, cancel_before_abort=False, **_kwargs):
self.assertTrue(cancel_before_abort)
task.cancel()
raise RuntimeError("server gone")
agent._abort_active_request = AsyncMock(side_effect=abort_then_fail)
result = await agent.handle_stop(_request())
self.assertTrue(result)
self.assertEqual(agent._user_stopped_sessions, set())
async def test_stop_cancels_before_native_abort_can_release_normal_completion(self):
"""Once stop accepts an active task, normal completion cannot win."""
agent = _agent()
release_normal_completion = asyncio.Event()
outcomes: list[str] = []
abort_observed_cancelling: list[bool] = []
async def in_flight():
try:
await release_normal_completion.wait()
outcomes.append("result")
except asyncio.CancelledError:
outcomes.append("stopped")
self.assertTrue(agent.consume_user_stop_intent("session-1"))
raise
task = asyncio.create_task(in_flight())
agent._active_requests["session-1"] = task
await asyncio.sleep(0)
async def abort(*_args, cancel_before_abort=False, **_kwargs):
self.assertTrue(cancel_before_abort)
task.cancel()
abort_observed_cancelling.append(task.cancelling() > 0)
release_normal_completion.set()
await asyncio.sleep(0)
return True
agent._abort_active_request = abort
self.assertTrue(await agent.handle_stop(_request()))
self.assertEqual(abort_observed_cancelling, [True])
self.assertEqual(outcomes, ["stopped"])
self.assertEqual(agent._user_stopped_sessions, set())
async def test_result_that_wins_while_stop_waits_for_steering_is_authoritative(self):
agent = _agent()
release_result = asyncio.Event()
outcomes: list[str] = []
async def in_flight():
await release_result.wait()
outcomes.append("result")
task = asyncio.create_task(in_flight())
agent._active_requests["session-1"] = task
await asyncio.sleep(0)
async def abort(*_args, cancel_before_abort=False, **_kwargs):
self.assertTrue(cancel_before_abort)
release_result.set()
await task
return False
agent._abort_active_request = abort
self.assertTrue(await agent.handle_stop(_request()))
self.assertEqual(outcomes, ["result"])
agent.controller.emit_agent_message.assert_not_awaited()
self.assertEqual(agent._user_stopped_sessions, set())
async def test_the_intent_is_claimed_once(self):
# The request coroutine may encounter nested cancellation cleanup, but
# only its first claim may stamp the terminal receipt.
agent = _agent()
agent._user_stopped_sessions.add("session-1")
self.assertTrue(agent.consume_user_stop_intent("session-1"))
self.assertFalse(agent.consume_user_stop_intent("session-1"))
self.assertFalse(agent.consume_user_stop_intent(""))
async def test_stop_of_an_idle_session_publishes_no_intent(self):
agent = _agent()
result = await agent.handle_stop(_request())
self.assertFalse(result)
self.assertEqual(agent._user_stopped_sessions, set())
async def test_prestart_cancellation_stamps_stop_receipt(self):
agent = _agent()
request = _request()
agent._remove_ack_reaction = AsyncMock()
mark_prewrite_user_stop(request.context)
await agent._finish_prestart_cancellation(request)
agent._remove_ack_reaction.assert_awaited_once_with(
request,
terminal_emoji=STOPPED_REACTION_EMOJI,
)
self.assertEqual(agent._user_stopped_sessions, set())
async def test_restored_poll_cancellation_stamps_its_retained_request(self):
entered = asyncio.Event()
cleanups: list[tuple[object, object]] = []
class _Controller:
def __init__(self):
self.config = SimpleNamespace(
platform="slack",
ack_mode="reaction",
language="en",
)
self.processing_indicator = ProcessingIndicatorService(self)
async def emit_agent_message(self, *_args, **_kwargs):
return None
class _Server:
async def list_messages(self, **_kwargs):
entered.set()
await asyncio.Event().wait()
agent = SimpleNamespace(
controller=_Controller(),
opencode_config=SimpleNamespace(active_turn_timeout_seconds=60),
sessions=SimpleNamespace(remove_active_poll=Mock()),
_user_stopped_sessions={"session-1"},
)
async def _remove_ack_reaction(request, *, terminal_emoji=None):
cleanups.append((request, terminal_emoji))
def _consume(session_id):
return OpenCodeAgent.consume_user_stop_intent(agent, session_id)
agent._remove_ack_reaction = _remove_ack_reaction
agent.consume_user_stop_intent = _consume
poll = ActivePollInfo(
opencode_session_id="oc-1",
base_session_id="session-1",
channel_id="c1",
thread_id="t1",
settings_key="c1",
working_path="/tmp/work",
processing_indicator={
"platform": "slack",
"user_id": "u1",
"channel_id": "c1",
"message_id": "m1",
},
)
task = asyncio.create_task(OpenCodePollLoop(agent).run_restored_poll_loop(poll, _Server()))
await entered.wait()
task.cancel()
with pytest.raises(asyncio.CancelledError):
await task
self.assertEqual(len(cleanups), 1)
self.assertEqual(cleanups[0][0].base_session_id, poll.base_session_id)
self.assertEqual(cleanups[0][0].terminal_reaction_message_id, "m1")
self.assertEqual(cleanups[0][1], STOPPED_REACTION_EMOJI)
self.assertEqual(agent._user_stopped_sessions, set())
class _StubOpenCodeServer:
def __init__(self, *, block_start: bool = False):
self.block_start = block_start
self.start_entered = asyncio.Event()
self.aborted: list[tuple[str, str]] = []
async def ensure_directory_ready(self, _directory):
return None
async def list_messages(self, **_kwargs):
return []
async def prompt_async(self, **_kwargs):
return None
async def mark_run_active(self, _session_id):
return None
async def mark_run_inactive(self, _session_id):
return None
async def abort_session(self, session_id, directory):
self.aborted.append((session_id, directory))
def get_default_agent_from_config(self):
return None
def get_agent_reasoning_effort_from_config(self, _agent):
return None
class _BlockingPollLoop:
def __init__(self):
self.entered = asyncio.Event()
async def run_prompt_poll(self, *_args, **_kwargs):
self.entered.set()
await asyncio.Event().wait()
class _StubSessionManager(OpenCodeSessionManager):
async def ensure_working_dir(self, _path):
return None
async def get_or_create_session_id(self, _request, _server):
return "oc-session"
def _process_message_agent(server, poll_loop=None):
"""An OpenCode agent whose real ``handle_message``/``handle_stop`` pair
drives the real ``_process_message`` against a stub server."""
polls: dict[str, object] = {}
sessions = SimpleNamespace(
add_active_poll=lambda **kwargs: polls.__setitem__(kwargs["opencode_session_id"], kwargs),
remove_active_poll=lambda session_id: polls.pop(session_id, None),
get_all_active_polls=lambda: dict(polls),
)
agent = OpenCodeAgent.__new__(OpenCodeAgent)
agent.controller = SimpleNamespace(
config=SimpleNamespace(platform="slack", reply_enhancements=False, remote_access=None, language="en"),
processing_indicator=SimpleNamespace(snapshot_request=lambda _request: {}),
get_opencode_overrides=lambda _context: (None, None, None),
emit_agent_message=AsyncMock(),
)
agent.config = agent.controller.config
agent.sessions = sessions
agent.opencode_config = SimpleNamespace(error_retry_limit=0)
agent._session_manager = _StubSessionManager(None, "opencode")
agent._poll_loop = poll_loop or _BlockingPollLoop()
agent._steering_states = {}
agent._active_requests = {}
agent._user_stopped_sessions = set()
agent._delete_ack = AsyncMock()
agent._remove_ack_reaction = AsyncMock()
runtime = serve_opencode_agent(agent, server)
if server.block_start:
# The generation this turn needs is still starting.
async def _starting(_spec):
server.start_entered.set()
await asyncio.Event().wait()
runtime.acquire = _starting
return agent
def _process_message_request():
return AgentRequest(
context=MessageContext(
user_id="u",
channel_id="c",
platform="slack",
platform_specific={"agent_session_id": "ses_test"},
),
message="hello",
user_message="hello",
working_path="/tmp/work",
base_session_id="base",
composite_session_id="base:/tmp/work",
session_key="slack::c",
vibe_agent_model="fixture-provider/fixture-model",
)
class OpenCodeProcessMessageStopReceiptTests(unittest.IsolatedAsyncioTestCase):
"""A /stop must reach the request coroutine's own cancellation branch.
``handle_stop`` only publishes the intent; ``_process_message`` owns the 👀
and is the only place that trades it for the ⏹️ receipt, whether the stop
lands before the server has started or while the poll loop is running.
"""
async def _stop_while(self, agent, server, entered: asyncio.Event):
request = _process_message_request()
message_task = asyncio.create_task(agent.handle_message(request))
await asyncio.wait(
{message_task, asyncio.create_task(entered.wait())},
timeout=5,
return_when=asyncio.FIRST_COMPLETED,
)
self.assertTrue(entered.is_set(), "the request never reached the stop point")
self.assertTrue(await agent.handle_stop(_process_message_request()))
await message_task
return request
async def test_stop_during_the_poll_loop_leaves_the_stopped_receipt(self):
server = _StubOpenCodeServer()
poll_loop = _BlockingPollLoop()
agent = _process_message_agent(server, poll_loop)
request = await self._stop_while(agent, server, poll_loop.entered)
agent._remove_ack_reaction.assert_awaited_once_with(
request,
terminal_emoji=STOPPED_REACTION_EMOJI,
)
self.assertEqual(server.aborted, [("oc-session", "/tmp/work")])
self.assertEqual(agent.sessions.get_all_active_polls(), {})
self.assertEqual(agent._user_stopped_sessions, set())
# The stopped turn no longer pins its generation.
await asyncio.gather(*agent._lifecycle_tasks)
self.assertEqual([binding.released for binding in agent._runtime.bindings], [True])
async def test_stop_before_the_server_starts_leaves_the_stopped_receipt(self):
server = _StubOpenCodeServer(block_start=True)
agent = _process_message_agent(server)
request = await self._stop_while(agent, server, server.start_entered)
agent._remove_ack_reaction.assert_awaited_once_with(
request,
terminal_emoji=STOPPED_REACTION_EMOJI,
)
self.assertEqual(server.aborted, [])
self.assertEqual(agent._user_stopped_sessions, set())
if __name__ == "__main__":
unittest.main()