Skip to content
Python
4.6 KB
Raw Blame
use super::*;
pub(super) fn initialize(db: &Connection) -> Result<()> {
    use rusqlite::functions::FunctionFlags;
    db.create_scalar_function("ow_observer_hooks", 2, FunctionFlags::SQLITE_UTF8, |ctx| {
        let raw: String = ctx.get(0)?;
        let s: Session = serde_json::from_str(&raw)
            .map_err(|e| rusqlite::Error::UserFunctionError(Box::new(e)))?;
        let turn_id: Option<String> = ctx.get(1)?;
        let config = s
            .safety
            .merge(
                &s.turn
                    .filter(|t| Some(&t.id) == turn_id.as_ref())
                    .map(|t| t.safety)
                    .unwrap_or_default(),
            )
            .map_err(|_| {
                rusqlite::Error::UserFunctionError("Required observer unavailable".into())
            })?;
        Ok(json!(config
            .hooks
            .into_iter()
            .filter(|h| h.when == crate::safety::HookPhase::OnEvent)
            .collect::<Vec<_>>())
        .to_string())
    })?;
    db.create_scalar_function(
        "ow_observer_project",
        3,
        FunctionFlags::SQLITE_UTF8,
        |ctx| {
            let s: String = ctx.get(0)?;
            let k: String = ctx.get(1)?;
            let d: String = ctx.get(2)?;
            let parse = |v: &str| {
                serde_json::from_str::<Value>(v)
                    .map_err(|e| rusqlite::Error::UserFunctionError(Box::new(e)))
            };
            Ok(crate::compliance::project(&parse(&s)?, &k, &parse(&d)?).to_string())
        },
    )?;
    #[cfg(feature="guardrails")]
    db.execute_batch("CREATE TABLE IF NOT EXISTS safety_observers(session_id TEXT NOT NULL,cursor INTEGER NOT NULL,hook_name TEXT NOT NULL,hook_version TEXT NOT NULL,hook TEXT NOT NULL,record TEXT NOT NULL,turn_id TEXT,next_ms INTEGER NOT NULL DEFAULT 0,attempts INTEGER NOT NULL DEFAULT 0,PRIMARY KEY(session_id,cursor,hook_name,hook_version));
    DROP TRIGGER IF EXISTS safety_observer_capture;
    CREATE TRIGGER safety_observer_capture AFTER INSERT ON events
    WHEN NEW.kind NOT IN ('assistant_delta','tool_progress','agent_run_state','observer_delivery')
    BEGIN
      INSERT OR IGNORE INTO safety_observers(session_id,cursor,hook_name,hook_version,hook,record,turn_id)
      SELECT NEW.session_id,NEW.id,json_extract(h.value,'$.name'),json_extract(h.value,'$.version'),h.value,ow_observer_project(s.data,NEW.kind,NEW.data),NEW.turn_id
      FROM sessions s,json_each(ow_observer_hooks(s.data,NEW.turn_id)) h WHERE s.id=NEW.session_id;
    END;")?;
    Ok(())
}
impl Store {
    pub fn pending_observers(&self, sid: &str) -> Result<Vec<Value>> {
        #[cfg(not(feature = "guardrails"))]
        {
            let _ = sid;
            Ok(vec![])
        }
        #[cfg(feature = "guardrails")]
        {
            self.metadata(sid)?;
            let mut q=self.db.prepare("SELECT cursor,hook_name,hook_version,hook,record,turn_id,attempts,next_ms FROM safety_observers WHERE session_id=?1 ORDER BY next_ms,cursor,hook_name LIMIT 64")?;
            let rows = q.query_map(params![sid], |r| {
                Ok((
                    r.get::<_, i64>(0)?,
                    r.get::<_, String>(1)?,
                    r.get::<_, String>(2)?,
                    r.get::<_, String>(3)?,
                    r.get::<_, String>(4)?,
                    r.get::<_, Option<String>>(5)?,
                    r.get::<_, u32>(6)?,
                    r.get::<_, i64>(7)?,
                ))
            })?;
            rows.map(|r|{let (cursor,name,version,hook,record,turn,attempts,next)=r?;Ok(json!({"cursor":cursor,"name":name,"version":version,"hook":serde_json::from_str::<Value>(&hook)?,"record":serde_json::from_str::<Value>(&record)?,"turnId":turn,"attempts":attempts,"nextMs":next}))}).collect()
        }
    }
    pub fn settle_observer(&self, sid: &str, receipt: &Value, success: bool) -> Result<()> {
        self.metadata(sid)?;
        let cursor = receipt["cursor"]
            .as_i64()
            .context("Invalid observer cursor")?;
        let name = receipt["name"].as_str().context("Invalid observer name")?;
        let version = receipt["version"]
            .as_str()
            .context("Invalid observer version")?;
        if success {
            self.db.execute("DELETE FROM safety_observers WHERE session_id=?1 AND cursor=?2 AND hook_name=?3 AND hook_version=?4",params![sid,cursor,name,version])?;
        } else {
            self.db.execute("UPDATE safety_observers SET attempts=MIN(attempts+1,30),next_ms=?5+MIN(300000,1000*(1<<MIN(attempts,8))) WHERE session_id=?1 AND cursor=?2 AND hook_name=?3 AND hook_version=?4",params![sid,cursor,name,version,now_ms() as i64])?;
        }
        Ok(())
    }
}