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
"""In-memory lifecycle tracking for Codex turns."""
from __future__ import annotations
from dataclasses import dataclass, field
from typing import TYPE_CHECKING, List, Optional, Tuple
if TYPE_CHECKING:
from modules.agents.base import AgentRequest
@dataclass
class CodexHeldMessage:
"""One intermediate message a turn narrated but has not delivered yet.
Held because a ref it cites has no source recorded for it so far, or because
a message ahead of it is. ``thread_id`` travels with it because a ref_id only
names a source inside its own Codex thread.
"""
role: str
text: str
parse_mode: Optional[str]
thread_id: str
level: str = "normal"
# A reply's stable identity (the ``agentMessage`` item id), None for narration.
output_key: Optional[str] = None
@dataclass
class CodexTurnState:
turn_id: str
request: AgentRequest
pending_assistant: Optional[Tuple[str, Optional[str]]] = None
# The ``agentMessage.phase`` Codex gave the held message, None when it named
# none (``docs/plans/reply-and-turn-end.md``).
pending_assistant_phase: Optional[str] = None
# Its ``agentMessage`` item id.
pending_assistant_id: Optional[str] = None
# Narration this turn has produced but not yet delivered, oldest first,
# because the source that will attribute part of it has not arrived. Held as
# one queue per turn so the order the turn narrated in is the order the user
# reads, and so a boundary that ends the turn can settle all of it at once.
pending_narration: List[CodexHeldMessage] = field(default_factory=list)
terminal_error: Optional[str] = None
terminal_error_notified: bool = False
visible_to_user: bool = True
indicator_cleanup_claimed: bool = False
@dataclass
class CodexPendingTurnStart:
request: AgentRequest
thread_id: str
turn_id: Optional[str] = None
completed: bool = False
class CodexTurnRegistry:
"""Owns Codex turn-scoped request routing and lifecycle state."""
def __init__(self) -> None:
self._turns: dict[str, CodexTurnState] = {}
self._active_turns: dict[str, str] = {}
self._latest_requests: dict[str, AgentRequest] = {}
self._pending_turn_starts: dict[str, CodexPendingTurnStart] = {}
def remember_request(self, request: AgentRequest) -> None:
self._latest_requests[request.base_session_id] = request
def get_latest_request(self, base_session_id: str) -> Optional[AgentRequest]:
return self._latest_requests.get(base_session_id)
def begin_turn_start(self, request: AgentRequest, thread_id: str) -> None:
self.remember_request(request)
self._pending_turn_starts[request.base_session_id] = CodexPendingTurnStart(
request=request,
thread_id=thread_id,
)
def register_turn(self, turn_id: str, request: AgentRequest) -> CodexTurnState | None:
if not turn_id:
return None
self.remember_request(request)
state = self._turns.get(turn_id)
if state is None:
state = CodexTurnState(turn_id=turn_id, request=request)
self._turns[turn_id] = state
else:
state.request = request
state.visible_to_user = True
self._active_turns[request.base_session_id] = turn_id
pending = self._pending_turn_starts.get(request.base_session_id)
if pending and pending.request is request:
self._pending_turn_starts.pop(request.base_session_id, None)
return state
def finalize_turn_start_response(self, turn_id: str, request: AgentRequest) -> CodexTurnState | None:
pending = self._pending_turn_starts.get(request.base_session_id)
if pending and pending.request is request:
if pending.turn_id and pending.turn_id != turn_id:
self.pop_turn(pending.turn_id)
self._pending_turn_starts.pop(request.base_session_id, None)
return self.register_turn(turn_id, request)
if pending.completed and pending.turn_id == turn_id:
self._pending_turn_starts.pop(request.base_session_id, None)
return None
return self.register_turn(turn_id, request)
def bootstrap_turn(self, turn_id: str, base_session_id: str, thread_id: str) -> CodexTurnState | None:
pending = self._pending_turn_starts.get(base_session_id)
if not pending or not turn_id:
return None
if pending.thread_id != thread_id:
return None
if pending.turn_id and pending.turn_id != turn_id:
return None
pending.turn_id = turn_id
state = self._turns.get(turn_id)
if state is None:
state = CodexTurnState(turn_id=turn_id, request=pending.request)
self._turns[turn_id] = state
else:
state.request = pending.request
state.visible_to_user = True
self._active_turns[base_session_id] = turn_id
return state
def get_bootstrapped_turn_id(self, base_session_id: str, request: AgentRequest) -> Optional[str]:
pending = self._pending_turn_starts.get(base_session_id)
if not pending or pending.request is not request:
return None
return pending.turn_id
def clear_pending_turn_start(self, base_session_id: str, request: AgentRequest | None = None) -> None:
pending = self._pending_turn_starts.get(base_session_id)
if not pending:
return
if request is not None and pending.request is not request:
return
self._pending_turn_starts.pop(base_session_id, None)
def has_pending_turn_start(self, base_session_id: str) -> bool:
return base_session_id in self._pending_turn_starts
def get_turn(self, turn_id: str) -> Optional[CodexTurnState]:
if not turn_id:
return None
return self._turns.get(turn_id)
def pop_turn(self, turn_id: str) -> Optional[CodexTurnState]:
if not turn_id:
return None
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)
if state:
pending = self._pending_turn_starts.get(state.request.base_session_id)
if pending and pending.request is state.request and pending.turn_id == turn_id:
pending.completed = True
return state
def claim_indicator_cleanup(self, turn_id: str) -> Optional[AgentRequest]:
"""Return the turn request to the first indicator-cleanup owner only."""
state = self.get_turn(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) -> Optional[CodexTurnState]:
state = self.get_turn(turn_id)
if not state:
return None
state.visible_to_user = False
state.pending_assistant = None
state.pending_assistant_phase = None
state.pending_assistant_id = None
# A hidden turn says nothing further, so everything it was still holding
# back goes with it rather than surfacing under its successor.
state.pending_narration.clear()
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 get_request_for_turn(self, turn_id: str) -> Optional[AgentRequest]:
state = self.get_turn(turn_id)
return state.request if state else None
def get_active_turn(self, base_session_id: str) -> Optional[str]:
return self._active_turns.get(base_session_id)
def is_active_turn(self, turn_id: str) -> bool:
state = self.get_turn(turn_id)
if not state:
return False
return self._active_turns.get(state.request.base_session_id) == turn_id
def clear_active_turn(self, base_session_id: str) -> None:
self._active_turns.pop(base_session_id, None)
def should_emit_progress(self, turn_id: str) -> bool:
state = self.get_turn(turn_id)
return bool(state and state.visible_to_user and self.is_active_turn(turn_id))
def should_emit_terminal_error(self, turn_id: str) -> bool:
state = self.get_turn(turn_id)
return bool(state and state.visible_to_user and self.is_active_turn(turn_id))
def should_emit_result(self, turn_id: str) -> bool:
state = self.get_turn(turn_id)
return bool(state and state.visible_to_user and self.is_active_turn(turn_id))
def clear_session(self, base_session_id: str) -> int:
self._latest_requests.pop(base_session_id, None)
self._active_turns.pop(base_session_id, None)
self._pending_turn_starts.pop(base_session_id, None)
removed = 0
for turn_id, state in list(self._turns.items()):
if state.request.base_session_id == base_session_id:
self._turns.pop(turn_id, None)
removed += 1
return removed