Skip to content
Python
12.2 KB
Raw Blame
//! Non-owner session creation and coherent snapshot reads. API-scoped handles
//! authorize inside transactions; unscoped embedding/worker handles are trusted.
use crate::auth::{self, Action, Scope};
use crate::db::{append_history, event, locked, verify_history_count, write_metadata, Database};
use crate::SubmissionError;
use anyhow::{bail, Result};
use openworker_runtime::store::{terminal, Session};
use postgres::Transaction;
use serde::{Deserialize, Serialize};
use serde_json::{json, Value};
#[derive(Clone, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct SessionCreation {
    pub request_id: String,
    pub actor: String,
    pub parameters: Value,
}
impl SessionCreation {
    pub(crate) fn validate(&self) -> Result<()> {
        crate::submissions::validate_id(&self.request_id, 100)?;
        crate::submissions::validate_id(&self.actor, 128)?;
        if !self.parameters.is_object() || self.parameters.to_string().len() > 128_000 {
            return Err(SubmissionError::InvalidRequest.into());
        }
        Ok(())
    }
}
#[derive(Clone, Debug, Serialize, Deserialize, PartialEq, Eq)]
pub struct CreationReceipt {
    pub request_id: String,
    pub session_id: String,
    pub duplicate: bool,
}
fn lookup(tx: &mut Transaction<'_>, request: &SessionCreation) -> Result<Option<CreationReceipt>> {
    if let Some(row) = tx.query_opt(
        "SELECT actor,parameters,session_id FROM creations WHERE request_id=$1",
        &[&request.request_id],
    )? {
        if row.get::<_, String>(0) != request.actor || row.get::<_, Value>(1) != request.parameters
        {
            return Err(SubmissionError::Conflict.into());
        }
        let sid: String = row.get(2);
        locked(tx, &sid, None)?;
        let key: Option<String> = tx
            .query_one(
                "SELECT creation_request_id FROM sessions WHERE id=$1",
                &[&sid],
            )?
            .get(0);
        if key.as_deref() != Some(&request.request_id) {
            bail!("Creation identity linkage changed");
        }
        return Ok(Some(CreationReceipt {
            request_id: request.request_id.clone(),
            session_id: sid,
            duplicate: true,
        }));
    }
    if tx
        .query_one(
            "SELECT EXISTS(SELECT 1 FROM sessions WHERE creation_request_id=$1)",
            &[&request.request_id],
        )?
        .get::<_, bool>(0)
    {
        bail!("Creation receipt missing; stored data incomplete");
    }
    Ok(None)
}
impl Database {
    pub(crate) fn creation(&mut self, request: SessionCreation) -> Result<Option<CreationReceipt>> {
        let mut tx = self.client.transaction()?;
        let p = auth::guard(
            &mut tx,
            self.auth.as_ref(),
            Action::Create,
            None,
            request.parameters["environment_id"].as_str(),
        )?;
        auth::actor(p.as_ref(), &request.actor)?;
        let receipt = lookup(&mut tx, &request)?;
        if let (Some(p), Some(r)) = (&p, &receipt) {
            anyhow::ensure!(
                auth::session_allowed(&mut tx, p, &r.session_id)?,
                auth::Error::Forbidden
            );
        }
        tx.commit()?;
        Ok(receipt)
    }
    pub(crate) fn create_session(
        &mut self,
        request: SessionCreation,
        s: Session,
    ) -> Result<CreationReceipt> {
        if s.storage_revision != 0
            || s.turn.is_some()
            || s.closed
            || !s.history.is_empty()
            || !s.interactions.is_empty()
            || !s.approval_grants.is_empty()
            || s.sandbox.is_some()
            || !s.direct_processes.is_empty()
            || s.schema_digest.is_some()
        {
            bail!("Expected fresh prepared session");
        }
        let mut tx = self.client.transaction()?;
        let p = auth::guard(
            &mut tx,
            self.auth.as_ref(),
            Action::Create,
            None,
            request.parameters["environment_id"].as_str(),
        )?;
        auth::actor(p.as_ref(), &request.actor)?;
        let result = create_in_tx(&mut tx, &self.owner, request, s, p)?;
        tx.commit()?;
        Ok(result)
    }
    pub(crate) fn read_snapshot(&mut self, sid: &str) -> Result<Value> {
        let mut tx = self.client.transaction()?;
        auth::guard(&mut tx, self.auth.as_ref(), Action::Read, Some(sid), None)?;
        let s = locked(&mut tx, sid, None)?;
        verify_history_count(&mut tx, sid)?;
        let cursor: i64 = tx
            .query_one("SELECT cursor FROM sessions WHERE id=$1", &[&sid])?
            .get(0);
        let count:i64=tx.query_one("SELECT count(*) FROM history WHERE session_id=$1 AND (data->>'role'='user' OR data->>'type'='message')",&[&sid])?.get(0);
        let mut messages = vec![];
        let mut bytes = 0;
        for row in tx.query("SELECT data FROM history WHERE session_id=$1 AND (data->>'role'='user' OR data->>'type'='message') ORDER BY seq DESC LIMIT 100",&[&sid])? {
            let value:Value=row.get(0);bytes+=value.to_string().len();if bytes>262144 {break;}messages.push(value);
        }
        messages.reverse();
        let attempts:Vec<Value>=tx.query("SELECT id,turn_id,status,text,truncated FROM attempts WHERE session_id=$1 ORDER BY ordinal DESC LIMIT 20",&[&sid])?.into_iter().map(|r|json!({"id":r.get::<_,String>(0),"turn_id":r.get::<_,String>(1),"status":r.get::<_,String>(2),"text":r.get::<_,String>(3),"truncated":r.get::<_,bool>(4)})).collect();
        let pending: Vec<_> = s
            .interactions
            .iter()
            .filter(|i| {
                i.response.is_none()
                    && s.turn
                        .as_ref()
                        .is_some_and(|t| t.id == i.turn_id && !terminal(&t.status))
            })
            .collect();
        let truncated = (messages.len() as i64) < count;
        let mut snapshot = json!({"session":{"id":s.id,"name":s.name,"compliance":s.compliance,"coworker":s.coworker,"workspace":s.workspace,"environment":s.environment,"model":s.model,"model_provider":s.model_provider,"model_selection":s.model_selection,"reviewer_selection":s.reviewer_selection,"closed":s.closed,"permissions":s.permissions,"sandbox":s.execution_backend,"enforcement":s.enforcement()},"turn":s.turn,"cursor":cursor,"messages":messages,"history_truncated":truncated,"attempts":attempts,"interactions":pending,"mode":if s.scripted{"scripted-test"}else{"live"}});
        // Control receipts are separate from the agent's current state. Expose their
        // bounded status so a reconnect does not invite a duplicate human decision.
        let tid = s.turn.as_ref().map(|t| t.id.as_str()).unwrap_or("");
        let controls: Vec<Value> = tx.query("SELECT id,target,status,reason FROM controls WHERE session_id=$1 AND turn_id=$2 ORDER BY sequence LIMIT 128", &[&sid, &tid])?.into_iter().map(|r| json!({"id":r.get::<_,String>(0),"target":r.get::<_,String>(1),"status":r.get::<_,String>(2),"reason":r.get::<_,Option<String>>(3)})).collect();
        snapshot["controls"] = json!(controls);
        if s.package.planning {
            snapshot["plan"] = json!(s.plan);
        }
        tx.commit()?;
        Ok(snapshot)
    }
    /// Bounded operational projection. No prompts, tool arguments, credentials,
    /// provider payloads or histories in the session directory.
    pub(crate) fn session_page(&mut self, after: Option<&str>, limit: u16) -> Result<Value> {
        let mut tx = self.client.transaction()?;
        let p = auth::guard(&mut tx, self.auth.as_ref(), Action::Read, None, None)?;
        let after = after.unwrap_or("");
        if let Some(p) = &p {
            if !after.is_empty() {
                anyhow::ensure!(
                    auth::session_allowed(&mut tx, p, after)?,
                    auth::Error::Forbidden
                );
            }
        }
        if !after.is_empty()
            && !tx
                .query_one(
                    "SELECT EXISTS(SELECT 1 FROM sessions WHERE id=$1)",
                    &[&after],
                )?
                .get::<_, bool>(0)
        {
            return Err(crate::SubmissionError::NotFound.into());
        }
        let owner = p.as_ref().and_then(|p| {
            if p.scope == Scope::Owned {
                Some(p.principal.clone())
            } else {
                None
            }
        });
        let ids: Option<Vec<String>> = p.as_ref().and_then(|p| {
            if let Scope::Sessions { ids } = &p.scope {
                Some(ids.clone())
            } else {
                None
            }
        });
        let filter = if owner.is_some() {
            "EXISTS(SELECT 1 FROM api_session_owners o WHERE o.session_id=s.id AND o.principal=$3)"
        } else {
            "$3::text IS NULL"
        };
        let sql=format!("SELECT jsonb_build_object(
          'id',id,'name',left(data->>'name',512),'coworker',left(data->>'coworker',128),
          'model',left(data->>'model',128),'status',COALESCE(data->'turn'->>'status','idle'),
          'turn_id',data->'turn'->>'id','closed',data->'closed','cursor',cursor,'created',created,
          'pending',(SELECT count(*) FROM jsonb_array_elements(COALESCE(data->'interactions','[]'::jsonb)) i
             WHERE i->>'response' IS NULL AND i->>'turn_id'=data->'turn'->>'id'
             AND data->'turn'->>'status' IN ('accepted','running','waiting','recoverable','executing','cancelling')),
          'recovered',EXISTS(SELECT 1 FROM events e WHERE e.session_id=s.id AND e.kind='turn_recovered'))
          FROM sessions s WHERE ($1='' OR (created,id)<(SELECT created,id FROM sessions WHERE id=$1))
          AND {filter} AND ($4::text[] IS NULL OR s.id=ANY($4))
          ORDER BY created DESC,id DESC LIMIT $2");
        let rows = tx.query(&sql, &[&after, &(i64::from(limit) + 1), &owner, &ids])?;
        let more = rows.len() > usize::from(limit);
        let sessions: Vec<Value> = rows
            .into_iter()
            .take(usize::from(limit))
            .map(|r| r.get(0))
            .collect();
        let next = if more {
            sessions.last().and_then(|s| s["id"].as_str())
        } else {
            None
        };
        let result = json!({"sessions":sessions,"next_after":next});
        tx.commit()?;
        Ok(result)
    }
}

/// Shared atomic session insertion used by service-controller admission too.
pub(crate) fn create_in_tx(
    tx: &mut Transaction<'_>,
    owner: &str,
    request: SessionCreation,
    s: Session,
    p: Option<auth::Identity>,
) -> Result<CreationReceipt> {
    tx.query_one(
        "SELECT pg_advisory_xact_lock(hashtext(current_schema()),hashtext($1))",
        &[&format!("session-create:{}", request.request_id)],
    )?;
    if let Some(receipt) = lookup(tx, &request)? {
        if let Some(p) = &p {
            anyhow::ensure!(
                auth::session_allowed(tx, p, &receipt.session_id)?,
                auth::Error::Forbidden
            );
        }
        return Ok(receipt);
    }
    // API-created sessions are immediately claimable; creating a session
    // does not start a worker, model request or sandbox operation.
    tx.execute("INSERT INTO sessions(id,data,owner,epoch,expires,creation_request_id) VALUES($1,'{}',$2,0,clock_timestamp()+interval '5 minutes',$3)",&[&s.id,&owner,&request.request_id])?;
    append_history(tx, &s)?;
    write_metadata(tx, &s)?;
    if let Some(p) = &p {
        tx.execute(
            "INSERT INTO api_session_owners VALUES($1,$2)",
            &[&s.id, &p.principal],
        )?;
    }
    auth::audit(
        tx,
        p.as_ref(),
        Action::Create,
        Some(&s.id),
        Some(&request.request_id),
    )?;
    event(
        tx,
        &s,
        owner,
        0,
        "session_created",
        json!({"request_id":request.request_id,"actor":request.actor,"coworker":s.coworker,"environment":s.environment,"permissions":s.permissions,"resource_policy":s.resource_policy}),
    )?;
    tx.execute(
        "INSERT INTO creations(request_id,actor,parameters,session_id) VALUES($1,$2,$3,$4)",
        &[
            &request.request_id,
            &request.actor,
            &request.parameters,
            &s.id,
        ],
    )?;
    tx.execute(
        "UPDATE sessions SET expires=clock_timestamp() WHERE id=$1",
        &[&s.id],
    )?;
    Ok(CreationReceipt {
        request_id: request.request_id,
        session_id: s.id,
        duplicate: false,
    })
}