250b244ab4
## Current State Observations - `Session` currently holds many unrelated responsibilities (history, approval queues, task handles, rollout recorder, shell discovery, token tracking, etc.), making it hard to reason about ownership and lifetimes. - The anonymous `State` struct inside `codex.rs` mixes session-long data with turn-scoped queues and approval bookkeeping. - Turn execution (`run_task`) relies on ad-hoc local variables that should conceptually belong to a per-turn state object. - External modules (`codex::compact`, tests) frequently poke the raw `Session.state` mutex, which couples them to implementation details. - Interrupts, approvals, and rollout persistence all have bespoke cleanup paths, contributing to subtle bugs when a turn is aborted mid-flight. ## Desired End State - Keep a slim `Session` object that acts as the orchestrator and façade. It should expose a focused API (submit, approvals, interrupts, event emission) without storing unrelated fields directly. - Introduce a `state` module that encapsulates all mutable data structures: - `SessionState`: session-persistent data (history, approved commands, token/rate-limit info, maybe user preferences). - `ActiveTurn`: metadata for the currently running turn (sub-id, task kind, abort handle) and an `Arc<TurnState>`. - `TurnState`: all turn-scoped pieces (pending inputs, approval waiters, diff tracker, review history, auto-compact flags, last agent message, outstanding tool call bookkeeping). - Group long-lived helpers/managers into a dedicated `SessionServices` struct so `Session` does not accumulate "random" fields. - Provide clear, lock-safe APIs so other modules never touch raw mutexes. - Ensure every turn creates/drops a `TurnState` and that interrupts/finishes delegate cleanup to it.
61 lines
1.6 KiB
Rust
61 lines
1.6 KiB
Rust
//! Turn-scoped state and active turn metadata scaffolding.
|
|
|
|
use std::collections::HashMap;
|
|
use std::sync::Arc;
|
|
use tokio::sync::Mutex;
|
|
|
|
use codex_protocol::models::ResponseInputItem;
|
|
use tokio::sync::oneshot;
|
|
|
|
use crate::protocol::ReviewDecision;
|
|
|
|
/// Metadata about the currently running turn.
|
|
#[derive(Default)]
|
|
pub(crate) struct ActiveTurn {
|
|
pub(crate) sub_id: String,
|
|
pub(crate) turn_state: Arc<Mutex<TurnState>>,
|
|
}
|
|
|
|
/// Mutable state for a single turn.
|
|
#[derive(Default)]
|
|
pub(crate) struct TurnState {
|
|
pending_approvals: HashMap<String, oneshot::Sender<ReviewDecision>>,
|
|
pending_input: Vec<ResponseInputItem>,
|
|
}
|
|
|
|
impl TurnState {
|
|
pub(crate) fn insert_pending_approval(
|
|
&mut self,
|
|
key: String,
|
|
tx: oneshot::Sender<ReviewDecision>,
|
|
) -> Option<oneshot::Sender<ReviewDecision>> {
|
|
self.pending_approvals.insert(key, tx)
|
|
}
|
|
|
|
pub(crate) fn remove_pending_approval(
|
|
&mut self,
|
|
key: &str,
|
|
) -> Option<oneshot::Sender<ReviewDecision>> {
|
|
self.pending_approvals.remove(key)
|
|
}
|
|
|
|
pub(crate) fn clear_pending(&mut self) {
|
|
self.pending_approvals.clear();
|
|
self.pending_input.clear();
|
|
}
|
|
|
|
pub(crate) fn push_pending_input(&mut self, input: ResponseInputItem) {
|
|
self.pending_input.push(input);
|
|
}
|
|
|
|
pub(crate) fn take_pending_input(&mut self) -> Vec<ResponseInputItem> {
|
|
if self.pending_input.is_empty() {
|
|
Vec::with_capacity(0)
|
|
} else {
|
|
let mut ret = Vec::new();
|
|
std::mem::swap(&mut ret, &mut self.pending_input);
|
|
ret
|
|
}
|
|
}
|
|
}
|