mirror of
https://github.com/andrewyng/openworker.git
synced 2026-11-20 20:37:44 +00:00
164 lines
6.3 KiB
Rust
164 lines
6.3 KiB
Rust
use super::*;
|
|
use crate::agent_team::{self, Document, Message, Transaction};
|
|
use rusqlite::OptionalExtension;
|
|
pub(super) fn migrate(db: &Connection) -> Result<()> {
|
|
db.execute_batch("CREATE TABLE IF NOT EXISTS agent_teams(id TEXT PRIMARY KEY,data TEXT NOT NULL); CREATE TABLE IF NOT EXISTS agent_team_messages(team TEXT NOT NULL,seq INTEGER NOT NULL,id TEXT NOT NULL UNIQUE,data TEXT NOT NULL,PRIMARY KEY(team,seq));")?;
|
|
Ok(())
|
|
}
|
|
struct Tx<'a>(&'a Connection);
|
|
impl Transaction for Tx<'_> {
|
|
fn load(&mut self, id: &str) -> Result<Document> {
|
|
Ok(serde_json::from_str(&self.0.query_row(
|
|
"SELECT data FROM agent_teams WHERE id=?",
|
|
[id],
|
|
|r| r.get::<_, String>(0),
|
|
)?)?)
|
|
}
|
|
fn write(&mut self, d: &Document, creating: bool) -> Result<()> {
|
|
if creating {
|
|
self.0.execute(
|
|
"INSERT INTO agent_teams VALUES(?,?)",
|
|
params![d.id, serde_json::to_string(d)?],
|
|
)?;
|
|
} else {
|
|
anyhow::ensure!(
|
|
self.0.execute(
|
|
"UPDATE agent_teams SET data=? WHERE id=?",
|
|
params![serde_json::to_string(d)?, d.id]
|
|
)? == 1,
|
|
"Missing team"
|
|
);
|
|
}
|
|
Ok(())
|
|
}
|
|
fn append(&mut self, team: &str, m: &Message) -> Result<()> {
|
|
self.0.execute(
|
|
"INSERT INTO agent_team_messages VALUES(?,?,?,?)",
|
|
params![team, m.sequence, m.id, serde_json::to_string(m)?],
|
|
)?;
|
|
Ok(())
|
|
}
|
|
fn messages(
|
|
&mut self,
|
|
team: &str,
|
|
after: u64,
|
|
before: Option<u64>,
|
|
recipient: Option<&str>,
|
|
board: bool,
|
|
reverse: bool,
|
|
limit: usize,
|
|
) -> Result<Vec<Message>> {
|
|
let order = if reverse { "DESC" } else { "ASC" };
|
|
let sql=format!("SELECT data FROM agent_team_messages WHERE team=?1 AND seq>?2 AND (?3 IS NULL OR seq<?3) AND (?4 IS NULL OR EXISTS(SELECT 1 FROM json_each(json_extract(data,'$.recipients')) WHERE value=?4)) AND (?5=0 OR json_extract(data,'$.board')=1) ORDER BY seq {order} LIMIT ?6");
|
|
let rows = self
|
|
.0
|
|
.prepare(&sql)?
|
|
.query_map(
|
|
params![team, after, before, recipient, board, limit as i64],
|
|
|r| r.get::<_, String>(0),
|
|
)?
|
|
.collect::<rusqlite::Result<Vec<_>>>()?;
|
|
rows.into_iter()
|
|
.map(|v| Ok(serde_json::from_str(&v)?))
|
|
.collect()
|
|
}
|
|
fn anchor(&mut self, team: &str, id: &str) -> Result<u64> {
|
|
self.0.query_row("SELECT seq FROM agent_team_messages WHERE team=? AND id=? AND json_extract(data,'$.board')=1",params![team,id],|r|r.get(0)).optional()?.context("Unknown board message ID")
|
|
}
|
|
fn optional_session(&mut self, id: &str) -> Result<Option<Session>> {
|
|
self.0
|
|
.query_row("SELECT data FROM sessions WHERE id=?", [id], |r| {
|
|
r.get::<_, String>(0)
|
|
})
|
|
.optional()?
|
|
.map(|raw| Ok(serde_json::from_str(&raw)?))
|
|
.transpose()
|
|
}
|
|
}
|
|
impl Store {
|
|
pub fn agent_team(
|
|
&mut self,
|
|
sid: &str,
|
|
operation: &str,
|
|
args: &Value,
|
|
call: Option<(&str, &Value)>,
|
|
) -> Result<Value> {
|
|
let mut s = if call.is_some() {
|
|
self.get(sid)?
|
|
} else {
|
|
self.metadata(sid)?
|
|
};
|
|
let tx = self
|
|
.db
|
|
.transaction_with_behavior(rusqlite::TransactionBehavior::Immediate)?;
|
|
if let Some((_, call)) = call {
|
|
crate::coding_handoff::workflow::require_approval(&s, call)?;
|
|
}
|
|
let before = serde_json::to_value(&s)?;
|
|
let result = agent_team::apply(&mut Tx(&tx), &mut s, operation, args, now_ms())?;
|
|
if call.is_none()
|
|
&& (matches!(
|
|
operation,
|
|
"snapshot" | "pending" | "pending_inbox" | "team_read_board"
|
|
) || (operation == "wake" && result["resume"] != true)
|
|
|| (operation == "deliver"
|
|
&& result["messages"].as_array().is_some_and(Vec::is_empty)
|
|
&& result["wait_notices"] == 0))
|
|
{
|
|
tx.commit()?;
|
|
return Ok(result);
|
|
}
|
|
if let Some((tid, call)) = call {
|
|
finish(&mut s, tid, call, &result)?;
|
|
}
|
|
if call.is_none() && !s.history.is_empty() {
|
|
let pending = std::mem::take(&mut s.history);
|
|
let rows = tx
|
|
.prepare("SELECT data FROM history WHERE session_id=? ORDER BY seq")?
|
|
.query_map([sid], |r| r.get::<_, String>(0))?
|
|
.collect::<rusqlite::Result<Vec<_>>>()?;
|
|
s.history = rows
|
|
.into_iter()
|
|
.map(|raw| serde_json::from_str(&raw))
|
|
.collect::<serde_json::Result<_>>()?;
|
|
s.history.extend(pending);
|
|
}
|
|
if call.is_some() || !s.history.is_empty() {
|
|
Self::append_history(&tx, &s)?;
|
|
}
|
|
|
|
if call.is_some() || before != serde_json::to_value(&s)? {
|
|
tx.execute(
|
|
"UPDATE sessions SET data=? WHERE id=?",
|
|
params![serde_json::to_string(&s)?, sid],
|
|
)?;
|
|
}
|
|
tx.execute("INSERT INTO events(session_id,turn_id,kind,data) VALUES(?,?,?,?)",params![sid,s.turn.as_ref().map(|t|&t.id),"agent_team",crate::safety::public_internal_event(&s,json!({"operation":operation,"result":result,"call_id":call.map(|(_,c)|&c["call_id"])})).to_string()])?;
|
|
tx.commit()?;
|
|
Ok(result)
|
|
}
|
|
}
|
|
pub(crate) fn finish(s: &mut Session, tid: &str, call: &Value, result: &Value) -> Result<()> {
|
|
crate::agent_team::finish(s, tid, call, result)
|
|
}
|
|
|
|
pub(super) fn ensure_admission(db: &Connection, s: &Session) -> Result<()> {
|
|
if let Some(member) = &s.agent_team {
|
|
let raw: String = db.query_row(
|
|
"SELECT data FROM agent_teams WHERE id=?",
|
|
[&member.team_id],
|
|
|r| r.get(0),
|
|
)?;
|
|
let doc: Document = serde_json::from_str(&raw)?;
|
|
anyhow::ensure!(
|
|
crate::team_lifecycle::admits(&doc, s),
|
|
"Team member is stopped or retiring"
|
|
);
|
|
}
|
|
Ok(())
|
|
}
|
|
|
|
pub(super) fn terminal_saved(db: &Connection, s: &Session) -> Result<()> {
|
|
crate::subagents::terminal_saved(&mut Tx(db), s)
|
|
}
|