Skip to content
Python
6.2 KB
Raw Blame
use super::*;
use openworker_runtime::{
    agent_team::Document, store::Session, team_coordination::Phase, team_lifecycle::Mode,
};
impl Host {
    fn record_retirement_pending(
        &self,
        lead: &Session,
        doc: &Document,
        id: &str,
        reason: &str,
    ) -> Result<()> {
        if doc.retirements[id].pending_reason.as_deref() != Some(reason) {
            self.store.lock().unwrap().agent_team(
                &lead.id,
                "retirement_error",
                &json!({"agent_id":id,"reason":reason}),
                None,
            )?;
        }
        Ok(())
    }
    pub(super) async fn reconcile_named_retirements(&self, sessions: &[Session]) -> Result<()> {
        for lead in sessions.iter().filter(|s| s.agent_team.is_some()) {
            let doc: Document = serde_json::from_value(self.store.lock().unwrap().agent_team(
                &lead.id,
                "snapshot",
                &json!({}),
                None,
            )?)?;
            if doc
                .roster
                .instance(&doc.lead)
                .is_none_or(|i| i.session_id != lead.id)
            {
                continue;
            }
            if let Some(state) = &doc.standalone {
                for (id, turn_id) in &state.cancellations {
                    if let Some(instance) = doc.roster.instance(id) {
                        if let Some(child) = sessions.iter().find(|s| s.id == instance.session_id) {
                            if child
                                .turn
                                .as_ref()
                                .is_some_and(|t| t.id == *turn_id && !terminal(&t.status))
                            {
                                self.runtime(&child.coworker)?
                                    .dispatch(
                                        "turn/cancel",
                                        json!({"session_id":child.id,"turn_id":turn_id}),
                                    )
                                    .await?;
                            }
                        }
                    }
                }
            }
            for i in doc
                .roster
                .instances()
                .filter(|i| i.phase == Phase::Retiring)
            {
                if let Some(child) = sessions.iter().find(|s| s.id == i.session_id) {
                    // Saved API controls retain priority over lifecycle work, even
                    // though retirement has closed normal turn admission.
                    if let Some(db) = &self.postgres {
                        if db.next_control(&child.id)?.is_some() {
                            continue;
                        }
                    }
                    let runtime = self.runtime(&child.coworker)?;
                    let active = child.turn.as_ref().is_some_and(|t| !terminal(&t.status));
                    if active {
                        if doc.retirements[&i.agent_id].mode == Mode::Cancel {
                            let turn = child.turn.as_ref().unwrap();
                            if (turn.status != "cancelling" || !runtime.is_busy(&child.id))
                                && runtime
                                    .dispatch(
                                        "turn/cancel",
                                        json!({"session_id":child.id,"turn_id":turn.id}),
                                    )
                                    .await
                                    .is_err()
                            {
                                self.record_retirement_pending(
                                    lead,
                                    &doc,
                                    &i.agent_id,
                                    "cancel_cleanup_not_confirmed",
                                )?;
                            }
                        } else if !runtime.is_busy(&child.id)
                            && child
                                .turn
                                .as_ref()
                                .is_some_and(|t| t.status == "resuming_agents")
                        {
                            runtime
                                .dispatch("team/resume", json!({"session_id":child.id}))
                                .await?;
                        } else if !runtime.is_busy(&child.id)
                            && child
                                .agent_team
                                .as_ref()
                                .is_some_and(|m| m.waiting.is_some())
                        {
                            let wake = self.store.lock().unwrap().agent_team(
                                &child.id,
                                "wake",
                                &json!({}),
                                None,
                            )?;
                            if wake["resume"] == true {
                                runtime
                                    .dispatch("team/resume", json!({"session_id":child.id}))
                                    .await?;
                            }
                        }
                        continue;
                    }
                    if runtime.is_busy(&child.id) {
                        continue;
                    }
                    // Retain retirement/capacity on an unknown cleanup outcome.
                    if !child.closed
                        && runtime
                            .dispatch("session/close", json!({"session_id":child.id}))
                            .await
                            .is_err()
                    {
                        self.record_retirement_pending(
                            lead,
                            &doc,
                            &i.agent_id,
                            "cleanup_not_confirmed",
                        )?;
                        continue;
                    }
                }
                self.store.lock().unwrap().agent_team(
                    &lead.id,
                    "retirement_settle",
                    &json!({"agent_id":i.agent_id}),
                    None,
                )?;
            }
        }
        Ok(())
    }
}