Skip to content
Python
12.1 KB
Raw Blame
use crate::db::{event, locked, read_history, Database};
use anyhow::{bail, Context, Result};
use openworker_runtime::{
    control::{Action, Command, Record, Status},
    store::{terminal, Event, Session},
};
use postgres::{Row, Transaction};
use serde_json::{json, Value};

fn record(row: &Row) -> Result<Record> {
    Ok(Record {
        command: serde_json::from_value(row.get("command"))?,
        status: serde_json::from_value(json!(row.get::<_, String>("status")))?,
        reason: row.get("reason"),
    })
}
fn verify(tx: &mut Transaction<'_>, sid: &str) -> Result<()> {
    let ok:bool=tx.query_one("SELECT control_count=(SELECT count(*) FROM controls WHERE session_id=$1) FROM sessions WHERE id=$1",&[&sid])?.get(0);
    if !ok {
        bail!("Stored control data incomplete");
    }
    Ok(())
}
pub(crate) fn pending(tx: &mut Transaction<'_>, sid: &str) -> Result<bool> {
    verify(tx, sid)?;
    Ok(tx
        .query_one(
            "SELECT EXISTS(SELECT 1 FROM controls WHERE session_id=$1 AND status='pending')",
            &[&sid],
        )?
        .get(0))
}
fn cancel_pending(tx: &mut Transaction<'_>, s: &Session) -> Result<bool> {
    let tid = s.turn.as_ref().map(|t| t.id.as_str()).unwrap_or("");
    Ok(tx.query_one("SELECT EXISTS(SELECT 1 FROM controls WHERE session_id=$1 AND turn_id=$2 AND target=$3 AND status='pending')",&[&s.id,&tid,&format!("cancel:{tid}")])?.get(0))
}
/// Runs inside the owner's state transaction, before the final lease fence.
pub(crate) fn before_event(
    tx: &mut Transaction<'_>,
    s: &Session,
    kind: &str,
    data: &Value,
) -> Result<()> {
    verify(tx, &s.id)?;
    if matches!(
        kind,
        "tool_started" | "model_request" | "interaction_resolved" | "safety_resumed"
    ) && cancel_pending(tx, s)?
    {
        bail!("Cancellation intent pending; new work refused");
    }
    if kind == "interaction_resolved" {
        if let Some(iid) = data["interaction_id"].as_str() {
            if let Some(row) = tx.query_opt(
                "SELECT id FROM controls WHERE session_id=$1 AND target=$2 AND status='pending'",
                &[&s.id, &format!("response:{iid}")],
            )? {
                if data["control_request_id"].as_str() != Some(row.get::<_, String>(0).as_str()) {
                    bail!("Apply the saved control decision; direct response cannot override it");
                }
            }
        }
    }
    let Some(key) = data["control_request_id"].as_str() else {
        return Ok(());
    };
    if !matches!(
        kind,
        "interaction_resolved" | "turn_cancelling" | "safety_resumed"
    ) {
        return Ok(());
    }
    let saved = record(
        &tx.query_opt(
            "SELECT * FROM controls WHERE session_id=$1 AND id=$2",
            &[&s.id, &key],
        )?
        .context("Missing control command")?,
    )?;
    if saved.status != Status::Pending || data["actor"] != saved.command.actor {
        bail!("Stale or mismatched control command");
    }
    let t = s.turn.as_ref().context("Missing control turn")?;
    if t.id != saved.command.turn_id {
        bail!("Control turn changed");
    }
    match &saved.command.action {
        Action::Response {
            interaction_id,
            response,
            binding,
        } => {
            let i = s
                .interactions
                .iter()
                .find(|i| i.id == *interaction_id)
                .context("Missing interaction")?;
            if kind != "interaction_resolved"
                || i.turn_id != t.id
                || i.response.as_ref() != Some(response)
                || t.status != "accepted"
                || i.bundle_digest != binding.bundle_digest
                || i.schema_digest != binding.schema_digest
                || i.policy_digest != binding.policy_digest
                || i.resource_policy_digest != binding.resource_policy_digest
            {
                bail!("Control application mismatch");
            }
        }
        Action::ResumeSafety => {
            if kind != "safety_resumed" || t.status != "accepted" {
                bail!("Safety resume mismatch");
            }
        }
        Action::Cancel => {
            if kind != "turn_cancelling" || t.status != "cancelling" {
                bail!("Control cancellation mismatch");
            }
        }
    }
    tx.execute(
        "UPDATE controls SET status='applied' WHERE session_id=$1 AND id=$2",
        &[&s.id, &key],
    )?;
    Ok(())
}
impl Database {
    pub(crate) fn submit_control(&mut self, command: Command) -> Result<Record> {
        command
            .validate()
            .map_err(|_| crate::SubmissionError::InvalidRequest)?;
        let mut tx = self.client.transaction()?;
        let p = crate::auth::guard(
            &mut tx,
            self.auth.as_ref(),
            crate::auth::Action::Control,
            Some(&command.session_id),
            None,
        )?;
        crate::auth::actor(p.as_ref(), &command.actor)?;
        let s = locked(&mut tx, &command.session_id, None)?;
        verify(&mut tx, &s.id)?;
        if let Some(row) = tx.query_opt(
            "SELECT * FROM controls WHERE session_id=$1 AND id=$2",
            &[&s.id, &command.request_id],
        )? {
            let saved = record(&row)?;
            if saved.command != command {
                return Err(crate::SubmissionError::Conflict.into());
            }
            crate::auth::audit(
                &mut tx,
                p.as_ref(),
                crate::auth::Action::Control,
                Some(&command.session_id),
                Some(&command.request_id),
            )?;
            tx.commit()?;
            return Ok(saved);
        }
        if s.closed {
            return Err(crate::SubmissionError::Closed.into());
        }
        if tx
            .query_opt(
                "SELECT id FROM controls WHERE session_id=$1 AND target=$2",
                &[&s.id, &command.target()],
            )?
            .is_some()
        {
            return Err(crate::SubmissionError::ControlConflict.into());
        }
        if matches!(command.action,Action::ResumeSafety) && tx.query_one("SELECT EXISTS(SELECT 1 FROM controls WHERE session_id=$1 AND turn_id=$2 AND status='pending' AND command->'action'->>'kind'='resume_safety')",&[&s.id,&command.turn_id])?.get::<_,bool>(0){return Err(crate::SubmissionError::ControlConflict.into());}
        command
            .check_saved(&s)
            .map_err(|_| crate::SubmissionError::ControlConflict)?;
        if !matches!(command.action, Action::Cancel) && cancel_pending(&mut tx, &s)? {
            return Err(crate::SubmissionError::ControlConflict.into());
        }
        let count: i64 = tx
            .query_one(
                "SELECT count(*) FROM controls WHERE session_id=$1 AND status='pending'",
                &[&s.id],
            )?
            .get(0);
        if count >= 128 {
            return Err(crate::SubmissionError::QueueFull.into());
        }
        let row=tx.query_one("UPDATE sessions SET control_count=control_count+1,cursor=cursor+1 WHERE id=$1 RETURNING control_count,cursor,epoch",&[&s.id])?;
        let (seq, cursor, epoch): (i64, i64, i64) = (row.get(0), row.get(1), row.get(2));
        let payload = serde_json::to_value(&command)?;
        tx.execute("INSERT INTO controls(session_id,id,turn_id,target,command,sequence,status) VALUES($1,$2,$3,$4,$5,$6,'pending')",&[&s.id,&command.request_id,&command.turn_id,&command.target(),&payload,&seq])?;
        let data = json!({"request_id":command.request_id,"actor":command.actor,"target":command.target(),"status":"pending"});
        tx.execute(
            "INSERT INTO events VALUES($1,$2,$3,'control_received',$4)",
            &[&s.id, &cursor, &command.turn_id, &data],
        )?;
        tx.execute("INSERT INTO audit(session_id,cursor,turn_id,kind,owner_epoch,actor) VALUES($1,$2,$3,'control_received',$4,$5)",&[&s.id,&cursor,&command.turn_id,&epoch,&command.actor])?;
        crate::auth::audit(
            &mut tx,
            p.as_ref(),
            crate::auth::Action::Control,
            Some(&command.session_id),
            Some(&command.request_id),
        )?;
        tx.commit()?;
        Ok(Record {
            command,
            status: Status::Pending,
            reason: None,
        })
    }
    pub(crate) fn control_record(&mut self, sid: &str, key: &str, owned: bool) -> Result<Record> {
        let epoch = if owned { Some(self.epoch(sid)?) } else { None };
        let mut tx = self.client.transaction()?;
        crate::auth::guard(
            &mut tx,
            self.auth.as_ref(),
            crate::auth::Action::Read,
            Some(sid),
            None,
        )?;
        locked(&mut tx, sid, epoch.map(|e| (self.owner.as_str(), e)))?;
        verify(&mut tx, sid)?;
        let result = record(
            &tx.query_opt(
                "SELECT * FROM controls WHERE session_id=$1 AND id=$2",
                &[&sid, &key],
            )?
            .ok_or(crate::SubmissionError::NotFound)?,
        )?;
        tx.commit()?;
        Ok(result)
    }
    pub(crate) fn next_control(&mut self, sid: &str) -> Result<Option<Record>> {
        let epoch = self.epoch(sid)?;
        let mut tx = self.client.transaction()?;
        locked(&mut tx, sid, Some((&self.owner, epoch)))?;
        verify(&mut tx, sid)?;
        let result=tx.query_opt("SELECT * FROM controls WHERE session_id=$1 AND status='pending' ORDER BY (command->'action'->>'kind'='cancel') DESC,sequence LIMIT 1",&[&sid])?.map(|r|record(&r)).transpose()?;
        tx.commit()?;
        Ok(result)
    }
    pub(crate) fn settle_control(
        &mut self,
        sid: &str,
        key: &str,
        rejected: bool,
        reason: &str,
    ) -> Result<Event> {
        if ![
            "stale_identity_or_target",
            "runtime_validation_failed",
            "already_terminal",
        ]
        .contains(&reason)
        {
            bail!("Invalid control settlement reason");
        }
        let epoch = self.epoch(sid)?;
        let mut tx = self.client.transaction()?;
        let s = locked(&mut tx, sid, Some((&self.owner, epoch)))?;
        verify(&mut tx, sid)?;
        let saved = record(
            &tx.query_opt(
                "SELECT * FROM controls WHERE session_id=$1 AND id=$2",
                &[&sid, &key],
            )?
            .context("Control missing")?,
        )?;
        if saved.status != Status::Pending {
            bail!("Control already settled");
        }
        if !rejected
            && (!matches!(saved.command.action, Action::Cancel)
                || s.turn
                    .as_ref()
                    .is_none_or(|t| t.id != saved.command.turn_id || !terminal(&t.status)))
        {
            bail!("Cannot acknowledge unapplied control");
        }
        let status = if rejected { "rejected" } else { "applied" };
        tx.execute(
            "UPDATE controls SET status=$3,reason=$4 WHERE session_id=$1 AND id=$2",
            &[&sid, &key, &status, &reason],
        )?;
        let result = event(
            &mut tx,
            &s,
            &self.owner,
            epoch,
            "control_settled",
            json!({"control_request_id":key,"actor":saved.command.actor,"status":status,"reason":reason}),
        )?;
        tx.commit()?;
        Ok(result)
    }
    pub(crate) fn uncertain_calls(&mut self, sid: &str) -> Result<Vec<Value>> {
        let epoch = self.epoch(sid)?;
        let mut tx = self.client.transaction()?;
        let mut s = locked(&mut tx, sid, Some((&self.owner, epoch)))?;
        read_history(&mut tx, &mut s)?;
        let mut calls = vec![];
        if let Some(t) = &s.turn {
            for c in &t.queue {
                let started:bool=tx.query_one("SELECT EXISTS(SELECT 1 FROM events WHERE session_id=$1 AND turn_id=$2 AND kind='tool_started' AND data->>'call_id'=$3)",&[&sid,&t.id,&c["call_id"].as_str().context("Bad call ID")?])?.get(0);
                if started
                    && !s.history.iter().any(|v| {
                        v["type"] == "function_call_output" && v["call_id"] == c["call_id"]
                    })
                {
                    calls.push(c.clone());
                }
            }
        }
        tx.commit()?;
        Ok(calls)
    }
}