Skip to content
Python
9.9 KB
Raw Blame
//! Execution-owned run directory. Recordings never grant access or invent runs.
use crate::{
    auth::{self, Action, Scope},
    db::Database,
    PostgresStore, SubmissionError,
};
use anyhow::{ensure, Result};
use openworker_runtime::store::TurnObservation;
use serde::{Deserialize, Serialize};

#[derive(Clone, Debug, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct Cursor {
    pub created_us: i64,
    pub session_id: String,
    pub sequence: i64,
}
#[derive(Clone)]
pub struct Search {
    pub text: String,
    pub agent: Option<String>,
    pub from_ms: Option<i64>,
    pub to_ms: Option<i64>,
    pub after: Option<Cursor>,
    pub as_of_us: Option<i64>,
    pub limit: u16,
}
impl Default for Search {
    fn default() -> Self {
        Self {
            text: String::new(),
            agent: None,
            from_ms: None,
            to_ms: None,
            after: None,
            as_of_us: None,
            limit: 25,
        }
    }
}
impl Search {
    pub fn validate(&self) -> Result<()> {
        ensure!(
            self.text.len() <= 200
                && !self.text.chars().any(char::is_control)
                && self.agent.as_ref().is_none_or(|s| !s.is_empty()
                    && s.len() <= 128
                    && !s.chars().any(char::is_control))
                && (1..=100).contains(&self.limit),
            SubmissionError::InvalidRequest
        );
        ensure!(
            [self.from_ms, self.to_ms]
                .into_iter()
                .flatten()
                .all(|n| (0..=253402300799000).contains(&n))
                && self.from_ms.zip(self.to_ms).is_none_or(|(a, b)| a <= b),
            SubmissionError::InvalidRequest
        );
        if let Some(c) = &self.after {
            crate::submissions::validate_id(&c.session_id, 80)?;
            ensure!(
                c.created_us > 0 && c.sequence > 0,
                SubmissionError::InvalidRequest
            );
        }
        ensure!(
            self.as_of_us.is_none_or(|n| n > 0),
            SubmissionError::InvalidRequest
        );
        Ok(())
    }
}
#[derive(Clone, Debug, Serialize, Deserialize)]
pub struct Run {
    pub session_id: String,
    pub turn_id: String,
    pub submission_id: String,
    pub name: String,
    pub agent: String,
    pub model: String,
    pub status: String,
    pub created_ms: i64,
    #[serde(skip)]
    pub observation: Option<TurnObservation>,
    #[serde(skip)]
    pub pending_waits: u64,
}
pub struct Page {
    pub runs: Vec<Run>,
    pub next: Option<Cursor>,
    pub as_of_us: i64,
}
// Only projected metadata leaves this query. No transcript, submission text,
// arguments, credentials or model payload is selected into a result.
const COLUMNS:&str="q.session_id,q.turn_id,q.id,left(s.data->>'name',512),left(s.data->>'coworker',128),left(s.data->>'model',128),
 CASE WHEN s.data->'turn'->>'id'=q.turn_id THEN s.data->'turn'->>'status' ELSE q.status END,
 (extract(epoch FROM q.created)*1000000)::bigint,q.sequence";
fn run(row: &postgres::Row) -> Run {
    Run {
        session_id: row.get(0),
        turn_id: row.get(1),
        submission_id: row.get(2),
        name: row.get::<_, Option<String>>(3).unwrap_or_default(),
        agent: row.get::<_, Option<String>>(4).unwrap_or_default(),
        model: row.get::<_, Option<String>>(5).unwrap_or_default(),
        status: row.get(6),
        created_ms: row.get::<_, i64>(7) / 1000,
        observation: None,
        pending_waits: 0,
    }
}
impl Database {
    pub(crate) fn search_runs(&mut self, query: Search) -> Result<Page> {
        let mut tx = self.client.transaction()?;
        let p = auth::guard(&mut tx, self.auth.as_ref(), Action::Read, None, None)?;
        let all = p.as_ref().is_none_or(|p| p.scope == Scope::All);
        let owner = p
            .as_ref()
            .and_then(|p| (p.scope == Scope::Owned).then(|| p.principal.clone()));
        let ids = p.as_ref().and_then(|p| {
            if let Scope::Sessions { ids } = &p.scope {
                Some(ids.clone())
            } else {
                None
            }
        });
        let now: i64 = tx
            .query_one(
                "SELECT (extract(epoch FROM clock_timestamp())*1000000)::bigint",
                &[],
            )?
            .get(0);
        let as_of = query.as_of_us.unwrap_or(now);
        ensure!(as_of <= now, SubmissionError::InvalidRequest);
        let after = query.after.as_ref();
        let sql=format!("SELECT {COLUMNS} FROM submissions q JOIN sessions s ON s.id=q.session_id
          WHERE ($1::boolean OR ($2::text IS NOT NULL AND EXISTS(SELECT 1 FROM api_session_owners o WHERE o.session_id=s.id AND o.principal=$2)) OR s.id=ANY($3::text[]))
          AND ($4='' OR strpos(lower(concat_ws(' ',s.data->>'name',s.id,q.turn_id,q.id)),lower($4))>0)
          AND ($5::text IS NULL OR s.data->>'coworker'=$5)
          AND ($6::bigint IS NULL OR q.created>=TIMESTAMPTZ 'epoch'+$6*INTERVAL '1 millisecond')
          AND ($7::bigint IS NULL OR q.created<=TIMESTAMPTZ 'epoch'+$7*INTERVAL '1 millisecond')
          AND q.created<=TIMESTAMPTZ 'epoch'+$8::bigint*INTERVAL '1 microsecond'
          AND ($9::bigint IS NULL OR (q.created,q.session_id,q.sequence)<(TIMESTAMPTZ 'epoch'+$9::bigint*INTERVAL '1 microsecond',$10,$11))
          ORDER BY q.created DESC,q.session_id DESC,q.sequence DESC LIMIT $12");
        let rows = tx.query(
            &sql,
            &[
                &all,
                &owner,
                &ids,
                &query.text,
                &query.agent,
                &query.from_ms,
                &query.to_ms,
                &as_of,
                &after.map(|c| c.created_us),
                &after.map(|c| c.session_id.as_str()),
                &after.map(|c| c.sequence),
                &(i64::from(query.limit) + 1),
            ],
        )?;
        let more = rows.len() > usize::from(query.limit);
        let rows: Vec<_> = rows.into_iter().take(query.limit.into()).collect();
        let next = if more {
            rows.last().map(|r| Cursor {
                created_us: r.get(7),
                session_id: r.get(0),
                sequence: r.get(8),
            })
        } else {
            None
        };
        let runs = rows.iter().map(run).collect();
        tx.commit()?;
        Ok(Page {
            runs,
            next,
            as_of_us: as_of,
        })
    }
    pub(crate) fn observation_run(&mut self, sid: &str, tid: &str) -> Result<Run> {
        let mut tx = self.client.transaction()?;
        auth::guard(&mut tx, self.auth.as_ref(), Action::Read, Some(sid), None)?;
        let sql=format!("SELECT {COLUMNS} FROM submissions q JOIN sessions s ON s.id=q.session_id WHERE q.session_id=$1 AND q.turn_id=$2");
        let row = tx
            .query_opt(&sql, &[&sid, &tid])?
            .ok_or(SubmissionError::NotFound)?;
        let mut run = run(&row);
        run.observation=tx.query_opt("SELECT data->'observation' FROM events WHERE session_id=$1 AND turn_id=$2 AND kind='execution_segment_started' ORDER BY cursor DESC LIMIT 1",&[&sid,&tid])?.map(|r|serde_json::from_value(r.get(0))).transpose()?;
        if !openworker_runtime::store::terminal(&run.status) {
            let pending:i64=tx.query_one("SELECT count(*) FROM sessions s,jsonb_array_elements(COALESCE(s.data->'interactions','[]'::jsonb)) i WHERE s.id=$1 AND i->>'turn_id'=$2 AND i->>'response' IS NULL AND i->>'resolved_at_ms' IS NULL",&[&sid,&tid])?.get(0);
            run.pending_waits = pending as u64;
        }
        tx.commit()?;
        Ok(run)
    }
}
impl PostgresStore {
    pub fn search_runs(&self, query: Search) -> Result<Page> {
        query.validate()?;
        self.call(move |db| db.search_runs(query))
    }
    /// Rechecks current credential/scope and run existence; never reads recordings.
    pub fn observation_run(&self, sid: &str, tid: &str) -> Result<Run> {
        crate::submissions::validate_id(sid, 80)?;
        crate::submissions::validate_id(tid, 80)?;
        let (sid, tid) = (sid.to_owned(), tid.to_owned());
        self.call(move |db| db.observation_run(&sid, &tid))
    }
}

impl Database {
    pub(crate) fn observation_children(
        &mut self,
        sid: &str,
        tid: &str,
    ) -> Result<Vec<openworker_runtime::observation_links::ChildLink>> {
        let mut tx = self.client.transaction()?;
        auth::guard(&mut tx, self.auth.as_ref(), Action::Read, Some(sid), None)?;
        let row=tx.query_opt("SELECT t.data FROM sessions s JOIN agent_teams t ON t.id=s.data->'agent_team'->>'team_id' WHERE s.id=$1",&[&sid])?;
        let mut visible = Vec::new();
        if let Some(row) = row {
            let doc = serde_json::from_value(row.get(0))?;
            for mut child in openworker_runtime::observation_links::children(&doc, sid, tid) {
                // Parent visibility never grants access to a child's identifiers or usage.
                match auth::guard(
                    &mut tx,
                    self.auth.as_ref(),
                    Action::Read,
                    Some(&child.child_session_id),
                    None,
                ) {
                    Ok(_) => {
                        child.child_turn_id=tx.query_opt("SELECT turn_id FROM submissions WHERE session_id=$1 AND turn_id IS NOT NULL ORDER BY sequence LIMIT 1", &[&child.child_session_id])?.and_then(|r|r.get(0));
                        visible.push(child);
                    }
                    Err(e)
                        if matches!(
                            e.downcast_ref::<auth::Error>(),
                            Some(auth::Error::Forbidden)
                        ) => {}
                    Err(e) => return Err(e),
                }
            }
        }
        tx.commit()?;
        Ok(visible)
    }
}
impl PostgresStore {
    pub fn observation_children(
        &self,
        sid: &str,
        tid: &str,
    ) -> Result<Vec<openworker_runtime::observation_links::ChildLink>> {
        let (sid, tid) = (sid.to_owned(), tid.to_owned());
        self.call(move |db| db.observation_children(&sid, &tid))
    }
}