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
"""Contract coverage for Show checkpoints across every turn entry point."""
from __future__ import annotations
import asyncio
from collections import defaultdict
from types import SimpleNamespace
import httpx
from config import paths
from core import inbox_events, internal_server, show_git
from core.git_binary import ResolvedGit
from core.inbox_events import InboxEventBus
from core.message_context import build_context_turn_sink_key, resolve_turn_sink_key
from core.message_dispatcher import ConsolidatedMessageDispatcher
from core.message_output import MessageOutput
from core.scheduled_tasks import ScheduledTaskService, ScheduledTaskStore, TaskExecutionStore
from core.services.dispatch import dispatch_turn
from core.session_turns import SessionTurnManager, emit_matches_active_turn
from core.show_git import POST_TURN, PRE_TURN, ShowGitCheckpointService, TurnCheckpointContext
from modules.agents.service import AgentService
from modules.im import MessageContext
from storage.agent_session_rows import create_agent_session_row
from storage.db import create_sqlite_engine
from storage.importer import ensure_sqlite_state
from storage import message_deliveries
class _Settings:
@staticmethod
def _canonicalize_message_type(message_type: str) -> str:
return message_type
@staticmethod
def is_message_type_hidden(_settings_key: str, _message_type: str) -> bool:
return False
class _IMClient:
@staticmethod
def should_use_thread_for_reply() -> bool:
return False
class _TerminalDispatcher:
def __init__(self, controller) -> None:
self._delegate = ConsolidatedMessageDispatcher(controller)
@staticmethod
async def begin_status_bubble(_context) -> None:
return None
@staticmethod
def update_thread_message_id(_context) -> None:
return None
async def emit_agent_message(self, **kwargs):
return await self._delegate.emit_agent_message(**kwargs)
class _TerminalAgent:
name = "checkpoint-probe"
def __init__(self, controller) -> None:
self.controller = controller
@staticmethod
def runtime_turn_key(request) -> str:
return request.composite_session_id
async def handle_message(self, request) -> None:
await self.controller.emit_agent_message(
request.context,
"result",
"",
level="silent",
output=MessageOutput(completes_turn=True, completes_run=False),
)
class _MessageHandler:
def __init__(self, controller) -> None:
self.controller = controller
async def _run(self, context: MessageContext, message: str) -> None:
session_id = (context.platform_specific or {}).get("agent_session_id")
request = SimpleNamespace(
context=context,
message=message,
composite_session_id=f"runtime:{session_id}",
processing_indicator=None,
)
await self.controller.agent_service.handle_message("checkpoint-probe", request)
async def handle_user_message(self, context: MessageContext, message: str):
await self._run(context, message)
return None
async def handle_scheduled_message(self, context: MessageContext, message: str, parsed_session_key=None):
del parsed_session_key
await self._run(context, message)
return None
class _Controller:
def __init__(self, checkpoint_service: ShowGitCheckpointService) -> None:
self.config = SimpleNamespace(reply_enhancements=False)
self.show_git_checkpoint_service = checkpoint_service
self.statuses = []
self.session_turns = SessionTurnManager(self)
self.session_turn_gate = self.session_turns
self.agent_service = AgentService(self)
self.agent_service.register(_TerminalAgent(self))
self.message_dispatcher = _TerminalDispatcher(self)
self.message_handler = _MessageHandler(self)
self.processing_indicator = None
self.command_handler = SimpleNamespace(handle_stop=self._stop)
@staticmethod
async def _stop(_context) -> bool:
return True
@staticmethod
def _session_id_from_context(context) -> str | None:
return (context.platform_specific or {}).get("agent_session_id")
@staticmethod
def _get_settings_key(context) -> str:
return context.channel_id
@staticmethod
def get_settings_manager_for_context(_context) -> _Settings:
return _Settings()
@staticmethod
def get_im_client_for_context(_context) -> _IMClient:
return _IMClient()
@staticmethod
def _get_session_key(context) -> str:
return f"{context.platform}::{context.channel_id}"
def _get_turn_sink_key(self, context) -> str:
return build_context_turn_sink_key(context, session_key=self._get_session_key(context))
def register_turn_sink(self, session_key: str, **kwargs) -> None:
self.session_turns.register_turn_sink(session_key, **kwargs)
def pop_turn_sink(self, session_key: str, done_event=None) -> None:
self.session_turns.pop_turn_sink(session_key, done_event)
def get_turn_sink(self, session_key: str):
return self.session_turns.get_turn_sink(session_key)
def mark_turn_complete(self, context=None) -> None:
if context is None:
return
sink = self.get_turn_sink(resolve_turn_sink_key(self, context))
if sink is None or not emit_matches_active_turn(sink, context):
return
done = sink.get("done_event")
if done is not None:
done.set()
def set_agent_status(self, session_id: str, status: str) -> None:
self.statuses.append((session_id, status))
def update_thread_message_id(self, context) -> None:
self.message_dispatcher.update_thread_message_id(context)
async def emit_agent_message(self, context, message_type, text, **kwargs):
try:
return await self.message_dispatcher.emit_agent_message(
context=context,
message_type=message_type,
text=text,
**kwargs,
)
finally:
self.session_turns.on_terminal_delivery_complete(context)
@staticmethod
def _t(key: str, **_kwargs) -> str:
return key
def _context(name: str, *, platform: str, trigger_kind: str | None = None) -> MessageContext:
session_id = f"ses_{name}"
metadata = {
"platform": platform,
"agent_session_id": session_id,
"task_execution_id": f"run-{name}",
}
if trigger_kind:
metadata["task_trigger_kind"] = trigger_kind
metadata["turn_source"] = "scheduled"
return MessageContext(
user_id="user",
channel_id=session_id,
platform=platform,
message_id=f"message-{name}",
platform_specific=metadata,
)
def test_all_turn_entrypoints_reach_checkpoint_subscriber(monkeypatch, tmp_path) -> None:
"""Scenario: MESSAGE-DELIVERY-006."""
monkeypatch.setenv("AVIBE_HOME", str(tmp_path))
ensure_sqlite_state()
contexts = {
"im_message": _context("im_message", platform="slack"),
"workbench_chat": _context("workbench_chat", platform="avibe"),
"show_page": _context("show_page", platform="avibe"),
"agent_run_sync": _context("agent_run_sync", platform="slack", trigger_kind="agent_run"),
"agent_run_async": _context("agent_run_async", platform="slack", trigger_kind="agent_run"),
"scheduled_task": _context("scheduled_task", platform="slack", trigger_kind="scheduled"),
"watch_callback": _context("watch_callback", platform="slack", trigger_kind="watch"),
}
engine = create_sqlite_engine()
show_delivery_id = "msg_show_page"
with engine.begin() as conn:
for context in contexts.values():
create_agent_session_row(
conn,
session_id=context.platform_specific["agent_session_id"],
scope_id=None,
session_anchor=None,
agent_backend="claude",
agent_variant="claude",
workdir=str(tmp_path),
)
message_deliveries.insert_delivery(
conn,
delivery_id=show_delivery_id,
session_id="ses_show_page",
priority="p3",
state="reserved",
snapshot=message_deliveries.message_snapshot(
scope_id=None,
session_id="ses_show_page",
platform="avibe",
author="user",
source="user",
text="edit show page",
),
dispatch_text="edit show page",
)
checkpoint_calls = defaultdict(list)
class _Repository:
def __init__(self, session_id: str) -> None:
self.session_id = session_id
def checkpoint(self, checkpoint: str, **_kwargs) -> bool:
checkpoint_calls[self.session_id].append(checkpoint)
return True
monkeypatch.setattr(
show_git,
"load_turn_checkpoint_context",
lambda session_id, **_kwargs: TurnCheckpointContext(
message=f"drive {session_id}",
message_id=f"message-{session_id}",
),
)
service = ShowGitCheckpointService(ResolvedGit(path=tmp_path / "git", source="system"))
monkeypatch.setattr(service, "_repository", lambda session_id: _Repository(session_id))
monkeypatch.setattr(service, "_link_message", lambda _context, _session_id: True)
bus = InboxEventBus()
monkeypatch.setattr(inbox_events, "bus", bus)
service.start(bus)
controller = _Controller(service)
lifecycle = []
subscription_id = bus.subscribe_callback(
lambda event_type, data: lifecycle.append((event_type, data))
if event_type in {"turn.start", "turn.end"}
else None
)
for context in contexts.values():
paths.get_show_page_dir(context.platform_specific["agent_session_id"]).mkdir(parents=True)
scheduled = ScheduledTaskService(
controller=controller,
store=ScheduledTaskStore(tmp_path / "scheduled_tasks.json"),
request_store=TaskExecutionStore(tmp_path / "task_requests"),
)
async def _build_scheduled_context(
_target,
*,
execution_id: str,
**_kwargs,
) -> MessageContext:
return contexts[execution_id]
monkeypatch.setattr(scheduled, "_build_context", _build_scheduled_context)
async def _build_dispatch_payload(payload) -> tuple[str, MessageContext]:
return "edit show page", contexts[payload["entrypoint"]]
monkeypatch.setattr(internal_server, "_build_dispatch_payload", _build_dispatch_payload)
app = internal_server.create_app(controller)
async def _exercise() -> None:
await dispatch_turn(controller, contexts["im_message"], "IM message")
workbench = contexts["workbench_chat"]
workbench_id = workbench.platform_specific["agent_session_id"]
await controller.session_turns.submit(workbench_id, workbench, "Workbench chat")
await controller.session_turns.in_flight[workbench_id].task
transport = httpx.ASGITransport(app=app)
async with httpx.AsyncClient(transport=transport, base_url="http://testserver") as client:
response = await client.post(
"/internal/dispatch_async",
json={
"session_id": "ses_show_page",
"user_message_id": show_delivery_id,
"entrypoint": "show_page",
},
)
assert response.status_code == 202
for _ in range(100):
if checkpoint_calls["ses_show_page"] == [PRE_TURN, POST_TURN]:
break
await asyncio.sleep(0.01)
# Sync and async CLI modes enqueue the same Agent Run execution; only
# the CLI caller's wait behavior differs. Exercise that executor twice.
for name in ("agent_run_sync", "agent_run_async"):
await scheduled._execute_agent_run(
session_key="slack::channel::C123",
session_id=None,
post_to=None,
deliver_key=None,
message=name,
execution_id=name,
)
for name in ("scheduled_task", "watch_callback"):
await scheduled._execute_request(
session_key="slack::channel::C123",
session_id=None,
post_to=None,
deliver_key=None,
prompt=name,
execution_id=name,
trigger_kind=contexts[name].platform_specific["task_trigger_kind"],
)
try:
asyncio.run(_exercise())
finally:
bus.unsubscribe(subscription_id)
service.stop()
assert len(lifecycle) == len(contexts) * 2
for index, (name, context) in enumerate(contexts.items()):
session_id = context.platform_specific["agent_session_id"]
start_event, end_event = lifecycle[index * 2 : index * 2 + 2]
assert start_event[0] == "turn.start", name
assert end_event[0] == "turn.end", name
assert start_event[1]["session_id"] == session_id, name
assert end_event[1]["session_id"] == session_id, name
assert start_event[1].get("turn_id"), name
assert end_event[1].get("turn_id") == start_event[1]["turn_id"], name
assert checkpoint_calls[session_id] == [PRE_TURN, POST_TURN], name