World's first open-source enterprise world model.
Rust agent-memorybitemporalgraphragknowledge-baseknowledge-graphllmontologypgvectorpostgresqlragrustself-hostedsemantic-searchtemporal-knowledge-graphworld-model
//! 本体代理的一轮(0061):没绑上的形状和接受了的问题交给脚本化的模型,提案落进
//! `ontology_proposals` 并记下服务的问题与形状;采纳建出属性并排对齐;提过的形状下一轮
//! 不再送。没有 `UTOPIA_DATABASE_URL` 时跳过。
use super::*;
use axum::body::{to_bytes, Body};
use axum::http::{Request, StatusCode};
use axum::{extract::State, response::IntoResponse, routing::post, Json, Router};
use serde_json::{json, Value};
use std::sync::atomic::{AtomicUsize, Ordering};
use std::sync::{Arc, Mutex};
use tower::ServiceExt;
use utopia_store::phrase_bindings::Decision;
#[derive(Clone)]
struct Model {
replies: Arc<Mutex<Vec<Value>>>,
requests: Arc<Mutex<Vec<Value>>>,
embeds: Arc<AtomicUsize>,
}
/// 嵌入端点只数次数:采纳不该在请求里调它
async fn embed(State(m): State<Model>) -> Json<Value> {
m.embeds.fetch_add(1, Ordering::SeqCst);
Json(json!({ "data": [] }))
}
async fn reply(State(m): State<Model>, Json(body): Json<Value>) -> impl IntoResponse {
m.requests.lock().unwrap().push(body);
let text = {
let mut replies = m.replies.lock().unwrap();
if replies.is_empty() {
panic!("unexpected model request");
}
replies.remove(0).to_string()
};
let frame = json!({"choices":[{"delta":{"content":text}}]});
(
[("content-type", "text/event-stream")],
format!("data: {frame}\n\ndata: [DONE]\n\n"),
)
}
struct Fx {
pool: sqlx::PgPool,
state: AppState,
org: Uuid,
kb: Uuid,
organization: Uuid,
place: Uuid,
located_in: Uuid,
/// 采纳的人(decided_by 是外键)
user: Uuid,
model: Model,
server: tokio::task::JoinHandle<()>,
_dir: tempfile::TempDir,
}
impl Fx {
/// 一个库:organization、place 两个类,一条属性 located_in(organization → place);
/// Acme —founded in→ London、Acme —located in→ London 两条开放陈述(形状按短语排:
/// s0 = founded in,s1 = located in)
async fn new(replies: Vec<Value>) -> anyhow::Result<Option<Self>> {
let Some(url) = utopia_store::test_db::url() else {
return Ok(None);
};
let pool = sqlx::PgPool::connect(&url).await?;
utopia_store::db::migrate(&pool).await?;
let (org, ws, kb, organization, place, acme, london, statement, user, located_in, st2) = (
Uuid::now_v7(),
Uuid::now_v7(),
Uuid::now_v7(),
Uuid::now_v7(),
Uuid::now_v7(),
Uuid::now_v7(),
Uuid::now_v7(),
Uuid::now_v7(),
Uuid::now_v7(),
Uuid::now_v7(),
Uuid::now_v7(),
);
sqlx::raw_sql(&format!(
"INSERT INTO organizations(id,name) VALUES ('{org}','ontology-agent');
INSERT INTO workspaces(id,org_id,name) VALUES ('{ws}','{org}','ontology-agent');
INSERT INTO knowledge_bases(id,workspace_id,name) VALUES ('{kb}','{ws}','ontology-agent');
INSERT INTO users(id,org_id,email,password_hash,display_name) VALUES ('{user}','{org}','{user}@agent.test','unused','Adopter');
INSERT INTO entity_types(id,kb_id,key,label,color,shape,description) VALUES
('{organization}','{kb}','organization','Organization','#000','circle','a company or institution'),
('{place}','{kb}','place','Place','#000','circle','a geographic location');
INSERT INTO entities(id,kb_id,canonical_name,type_id) VALUES
('{acme}','{kb}','Acme','{organization}'), ('{london}','{kb}','London','{place}');
INSERT INTO relation_types(id,kb_id,key,label,kind,temporal,description) VALUES
('{located_in}','{kb}','located_in','located in','relation','state','where an organization sits');
INSERT INTO relation_type_domains(relation_type_id,entity_type_id) VALUES ('{located_in}','{organization}');
INSERT INTO relation_type_ranges(relation_type_id,entity_type_id) VALUES ('{located_in}','{place}');
INSERT INTO facts(id,kb_id,subject_id,object_id,layer,phrase) VALUES
('{statement}','{kb}','{acme}','{london}','open','founded in'),
('{st2}','{kb}','{acme}','{london}','open','located in');"
))
.execute(&pool)
.await?;
let model = Model {
replies: Arc::new(Mutex::new(replies)),
requests: Arc::new(Mutex::new(Vec::new())),
embeds: Arc::new(AtomicUsize::new(0)),
};
let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await?;
let endpoint = format!("http://{}", listener.local_addr()?);
let router = Router::new()
.route("/chat/completions", post(reply))
.route("/embeddings", post(embed))
.with_state(model.clone());
let server = tokio::spawn(async move { axum::serve(listener, router).await.unwrap() });
utopia_store::settings::upsert(
&pool,
ws,
Some(&endpoint),
None,
Some("scripted"),
None,
None,
None,
None,
)
.await?;
let dir = tempfile::tempdir()?;
let cfg = utopia_core::config::AppConfig {
data_dir: dir.path().to_string_lossy().into_owned(),
..Default::default()
};
let search = Arc::new(utopia_search::SearchIndex::open(
&dir.path().join("search"),
)?);
let state = AppState::new(pool.clone(), &cfg, search, "test-only".into());
Ok(Some(Self {
pool,
state,
org,
kb,
organization,
place,
located_in,
user,
model,
server,
_dir: dir,
}))
}
/// 对齐判过这两条形状:没有属性可绑
async fn decide_none(&self) -> anyhow::Result<()> {
let sigs = phrase_bindings::signatures(&self.pool, self.kb).await?;
assert_eq!(sigs.len(), 2, "two open statements, two signatures");
for sig in &sigs {
phrase_bindings::decide(
&self.pool,
self.kb,
sig,
Decision {
relation_type_id: None,
direction: None,
status: "none",
votes: &json!({ "reason": "no_candidates" }),
decided_by: "agent",
basis: Some("test"),
marks: None,
marks_asked: false,
},
)
.await?;
}
Ok(())
}
/// 库里有一条人写的问题:本体代理就不先去提问题(那是没问题的库才走的一步)
async fn seed_question(&self) -> anyhow::Result<Uuid> {
Ok(competency_questions::create(
&self.pool,
self.kb,
competency_questions::NewQuestion {
question: "Where was each organization founded?",
expected_answer: None,
needs: None,
origin: "person",
status: "accepted",
created_by: None,
},
)
.await?)
}
async fn requests(&self) -> usize {
self.model.requests.lock().unwrap().len()
}
/// 一条形状写进提案里的样子,带第一条例句的陈述 id
async fn shape(&self, phrase: &str) -> anyhow::Result<Value> {
let sigs = phrase_bindings::signatures(&self.pool, self.kb).await?;
let sig = sigs
.iter()
.find(|s| s.phrase == phrase)
.ok_or_else(|| anyhow::anyhow!("no shape `{phrase}`"))?;
Ok(shape_of(sig))
}
/// 代理提过的一条,直接落库
async fn seed(
&self,
section: &str,
key: &str,
payload: Value,
signatures: Value,
) -> anyhow::Result<()> {
utopia_store::ontology::save_agent_proposals(
&self.pool,
self.kb,
&[utopia_store::ontology::AgentProposal {
section: section.into(),
key: key.into(),
payload,
serves: Vec::new(),
signatures,
}],
)
.await?;
Ok(())
}
/// 以这个库的编辑身份走一次接口
async fn post(&self, path: &str, body: Value) -> anyhow::Result<(StatusCode, Value)> {
sqlx::query(
"INSERT INTO kb_members(kb_id,user_id,role) VALUES($1,$2,'editor') ON CONFLICT DO NOTHING",
)
.bind(self.kb)
.bind(self.user)
.execute(&self.pool)
.await?;
let token = crate::auth::issue_token(&self.state, self.user)?;
let request = Request::post(format!("/api/v1/kbs/{}{path}", self.kb))
.header("content-type", "application/json")
.header("authorization", format!("Bearer {token}"))
.body(Body::from(body.to_string()))?;
let response = crate::api::router(self.state.clone(), &Default::default())
.oneshot(request)
.await?;
let status = response.status();
let bytes = to_bytes(response.into_body(), 1 << 20).await?;
Ok((
status,
serde_json::from_slice(&bytes).unwrap_or(Value::Null),
))
}
/// 这个库排着的任务,按到期的先后
async fn queued(&self) -> anyhow::Result<Vec<String>> {
Ok(sqlx::query_scalar(
"SELECT kind FROM jobs WHERE status='queued' AND payload->>'kb_id'=$1 ORDER BY run_at, id",
)
.bind(self.kb.to_string())
.fetch_all(&self.pool)
.await?)
}
/// 一个键留下了什么:同键的元素在不在、提案的状态、这个库的任务数、回归用例数
async fn left_by(&self, key: &str) -> anyhow::Result<(bool, String, i64, i64)> {
Ok(sqlx::query_as(
"SELECT EXISTS(SELECT 1 FROM relation_types WHERE kb_id=$1 AND key=$2)
OR EXISTS(SELECT 1 FROM entity_types WHERE kb_id=$1 AND key=$2),
(SELECT status FROM ontology_proposals WHERE kb_id=$1 AND key=$2),
(SELECT count(*) FROM jobs WHERE payload->>'kb_id'=$1::text),
(SELECT count(*) FROM ontology_regression_cases WHERE kb_id=$1)",
)
.bind(self.kb)
.bind(key)
.fetch_one(&self.pool)
.await?)
}
async fn cleanup(self) -> anyhow::Result<()> {
self.server.abort();
sqlx::query("DELETE FROM jobs WHERE payload->>'kb_id'=$1")
.bind(self.kb.to_string())
.execute(&self.pool)
.await?;
// decided_by 指向 users,不级联:先清提案再删组织
sqlx::query("DELETE FROM ontology_agent_reviews WHERE kb_id=$1")
.bind(self.kb)
.execute(&self.pool)
.await?;
sqlx::query("DELETE FROM ontology_proposals WHERE kb_id=$1")
.bind(self.kb)
.execute(&self.pool)
.await?;
sqlx::query("DELETE FROM organizations WHERE id=$1")
.bind(self.org)
.execute(&self.pool)
.await?;
Ok(())
}
}
/// founded in 那条形状提成的关系:organization → place
fn founded_in() -> Value {
json!({ "key": "founded_in", "label": "founded in", "description": "where an organization was founded",
"temporal": "state", "domains": ["organization"], "ranges": ["place"], "proposed_by": "agent" })
}
/// 代理提的新类:city,父类 place
fn city() -> Value {
json!({ "key": "city", "label": "City", "description": "a city", "parents": ["place"], "proposed_by": "agent" })
}
fn user_text(request: &Value) -> String {
request["messages"]
.as_array()
.into_iter()
.flatten()
.filter(|m| m["role"] == "user")
.filter_map(|m| m["content"].as_str())
.collect::<Vec<_>>()
.join("\n")
}
#[tokio::test]
async fn an_unbound_shape_becomes_a_proposal_that_serves_a_question_and_adoption_builds_the_property(
) -> anyhow::Result<()> {
let Some(f) = Fx::new(vec![json!({
"p": [{
"kind": "property", "key": "founded_in", "label": "founded in",
"definition": "the place where an organization was founded",
"value": false, "datatype": null,
"domains": ["organization"], "ranges": ["place"],
"s": [0], "k": [], "q": [0]
}],
"existing": []
})])
.await?
else {
return Ok(());
};
f.decide_none().await?;
let qid = f.seed_question().await?;
propose(&f.state, f.kb).await?;
// 模型看到了形状、词表和问题
let requests = f.model.requests.lock().unwrap().clone();
assert_eq!(requests.len(), 1, "one batch, one call");
let text = user_text(&requests[0]);
assert!(
text.contains("founded in"),
"the open shape is offered: {text}"
);
assert!(
text.contains("organization"),
"the glossary is offered: {text}"
);
assert!(
text.contains("located_in"),
"existing properties are in the glossary: {text}"
);
assert!(
text.contains("Where was each organization founded?"),
"the accepted question is offered: {text}"
);
// 提案落库,带着谁提的、服务的问题、会绑的形状
let open = utopia_store::ontology::open_proposals(&f.pool, f.kb).await?;
assert_eq!(open.len(), 1, "one proposal: {open:?}");
let p = &open[0];
assert_eq!(p.section, "relation_types");
assert_eq!(p.key, "founded_in");
assert_eq!(p.proposed_by, "agent");
assert_eq!(p.serves, vec![qid]);
assert_eq!(
p.signatures["phrases"][0]["phrase"], "founded in",
"the shape it binds is recorded: {}",
p.signatures
);
assert_eq!(p.signatures["phrases"][0]["subject"], "organization");
assert_eq!(p.payload["forms"][0], "founded in");
assert_eq!(p.payload["domains"][0], "organization");
assert_eq!(p.payload["ranges"][0], "place");
let example_id: Uuid =
serde_json::from_value(p.signatures["phrases"][0]["example_statement_ids"][0].clone())?;
let phrase: String = sqlx::query_scalar("SELECT phrase FROM facts WHERE id=$1 AND kb_id=$2")
.bind(example_id)
.bind(f.kb)
.fetch_one(&f.pool)
.await?;
assert_eq!(
phrase, "founded in",
"the proposed example has a stable source identity"
);
assert_eq!(
p.payload["description"],
"the place where an organization was founded"
);
// 提过的形状、看过没提的形状(located in)下一轮都不再送:没有模型调用
let outcomes: Vec<(String, String)> = sqlx::query_as(
"SELECT shape->>'phrase', outcome FROM ontology_agent_reviews WHERE kb_id=$1 ORDER BY 1",
)
.bind(f.kb)
.fetch_all(&f.pool)
.await?;
assert_eq!(
outcomes,
vec![
("founded in".to_string(), "proposed".to_string()),
("located in".to_string(), "declined".to_string())
],
"every offered shape is recorded with its outcome"
);
propose(&f.state, f.kb).await?;
assert_eq!(
f.requests().await,
1,
"already-proposed and declined shapes are not offered again"
);
// 采纳:属性建出来,签名域值域照提案,提案标记 adopted,短语对齐排上
let id = adopt(
&f.state,
f.kb,
"relation_types",
"founded_in",
AdoptEdits {
label: Some("Founded in".into()),
..Default::default()
},
f.user,
)
.await?
.id;
let props = utopia_store::ontology::relation_type_views(&f.pool, f.kb).await?;
let built = props
.iter()
.find(|p| p.id == id)
.expect("the property exists");
assert_eq!(built.key, "founded_in");
// 属性标签照库里的规矩写成小驼峰:人的改动进去了,只是换了写法
assert_eq!(built.label, "foundedIn", "the person's edit wins");
assert_eq!(built.kind, "relation");
assert_eq!(built.domains, vec![f.organization]);
assert_eq!(built.ranges, vec![f.place]);
assert_eq!(
built.description,
"the place where an organization was founded"
);
assert!(
utopia_store::ontology::open_proposals(&f.pool, f.kb)
.await?
.is_empty(),
"the proposal is no longer open"
);
let status: String = sqlx::query_scalar(
"SELECT status FROM ontology_proposals WHERE kb_id=$1 AND section='relation_types' AND key='founded_in'",
)
.bind(f.kb)
.fetch_one(&f.pool)
.await?;
assert_eq!(status, "adopted");
let cases = utopia_store::ontology_regressions::list(&f.pool, f.kb).await?;
assert_eq!(cases.len(), 1);
assert_eq!(cases[0].statement_id, example_id);
assert_eq!(cases[0].expected_property_id, id);
assert_eq!(cases[0].expected_direction, "forward");
assert_eq!(cases[0].created_by, Some(f.user));
assert_eq!(cases[0].origin, "adoption");
assert!(
utopia_store::jobs::pending_for_kb(&f.pool, "align_phrases", f.kb).await?,
"adoption re-decides the shapes through alignment"
);
// 采纳过的不能再采纳
let again = adopt(
&f.state,
f.kb,
"relation_types",
"founded_in",
AdoptEdits::default(),
f.user,
)
.await;
assert!(
matches!(again, Err(AppError::NotFound)),
"a decided proposal is not open: {again:?}"
);
// Older proposals lack source IDs: adoption succeeds without inventing cases.
let mut legacy_shape = p.signatures["phrases"][0].clone();
legacy_shape
.as_object_mut()
.unwrap()
.remove("example_statement_ids");
utopia_store::ontology::save_agent_proposals(
&f.pool,
f.kb,
&[utopia_store::ontology::AgentProposal {
section: "map_to".into(),
key: "located_in".into(),
payload: json!({"kind":"relation"}),
serves: vec![],
signatures: json!({"phrases":[legacy_shape]}),
}],
)
.await?;
adopt(
&f.state,
f.kb,
"map_to",
"located_in",
AdoptEdits::default(),
f.user,
)
.await?;
assert!(
utopia_store::ontology::open_proposal(&f.pool, f.kb, "map_to", "located_in")
.await?
.is_none()
);
assert_eq!(
utopia_store::ontology_regressions::list(&f.pool, f.kb)
.await?
.len(),
1,
"a proposal without example IDs adds no regression case"
);
f.cleanup().await
}
#[tokio::test]
async fn a_proposal_for_an_existing_key_or_binding_nothing_is_dropped() -> anyhow::Result<()> {
let Some(f) = Fx::new(vec![json!({
"p": [
// 已有的类:不提
{"kind": "class", "key": "place", "label": "Place", "definition": "x", "parents": [], "s": [], "k": [], "q": []},
// 什么都不绑:坏项
{"kind": "property", "key": "orphan", "label": "orphan", "definition": "x", "value": false,
"domains": [], "ranges": [], "s": [], "k": [], "q": []},
// 字面值属性:进 attribute_types,datatype 缺省 text
{"kind": "property", "key": "founding_note", "label": "founding note", "definition": "x", "value": true,
"datatype": "weird", "domains": ["organization"], "ranges": [], "s": [0], "k": [], "q": []}
],
"existing": []
})])
.await?
else {
return Ok(());
};
f.decide_none().await?;
f.seed_question().await?;
propose(&f.state, f.kb).await?;
let open = utopia_store::ontology::open_proposals(&f.pool, f.kb).await?;
assert_eq!(open.len(), 1, "only the attribute survives: {open:?}");
assert_eq!(open[0].section, "attribute_types");
assert_eq!(open[0].key, "founding_note");
assert_eq!(open[0].payload["datatype"], "text");
assert!(open[0].serves.is_empty());
f.cleanup().await
}
#[tokio::test]
async fn a_declined_shape_returns_when_its_statements_double_and_an_existing_answer_becomes_a_binding(
) -> anyhow::Result<()> {
let Some(f) = Fx::new(vec![
// 第一轮:founded in 没提;located in 本体里已经有(located_in,正向)
json!({ "p": [], "existing": [{ "key": "located_in", "dir": "forward", "s": [1], "k": [] }] }),
// 陈述翻倍之后的那轮:只有 founded in 送来(这一批里它是 s0),答成 located_in 反着读
json!({ "p": [], "existing": [{ "key": "located_in", "dir": "reverse", "s": [0], "k": [] }] }),
])
.await?
else {
return Ok(());
};
f.decide_none().await?;
f.seed_question().await?;
propose(&f.state, f.kb).await?;
assert_eq!(f.requests().await, 1);
let open = utopia_store::ontology::open_proposals(&f.pool, f.kb).await?;
assert_eq!(
open.len(),
1,
"the existing answer is a map_to proposal: {open:?}"
);
let m = &open[0];
assert_eq!(m.section, "map_to");
assert_eq!(m.key, "located_in");
assert_eq!(m.proposed_by, "agent");
assert_eq!(m.payload["kind"], "relation");
assert_eq!(
m.payload["label"], "located in",
"the target's label travels with it"
);
assert_eq!(m.payload["forms"][0], "located in");
assert_eq!(m.signatures["phrases"][0]["phrase"], "located in");
assert_eq!(m.signatures["phrases"][0]["direction"], "forward");
// 第二轮:一条提过(map_to)、一条看过没提,词表没变——不问
propose(&f.state, f.kb).await?;
assert_eq!(f.requests().await, 1, "nothing new to look at");
// 词表变了(多了一个类):看过没提的不再问——对齐自己会拿新元素去重判,问代理只是烧 token
utopia_store::ontology::create_entity_type(
&f.pool,
f.kb,
"city",
"City",
"#000",
"circle",
&[f.place],
"a city",
)
.await?;
propose(&f.state, f.kb).await?;
assert_eq!(
f.requests().await,
1,
"a changed glossary alone does not re-offer declined shapes"
);
// founded in 的陈述翻倍了(1 → 2):再送一次;map_to 已经提过的 located in 不送
sqlx::query(
"INSERT INTO facts(id,kb_id,subject_id,object_id,layer,phrase)
SELECT $1, kb_id, subject_id, object_id, 'open', 'founded in' FROM facts
WHERE kb_id=$2 AND phrase='founded in' LIMIT 1",
)
.bind(Uuid::now_v7())
.bind(f.kb)
.execute(&f.pool)
.await?;
propose(&f.state, f.kb).await?;
assert_eq!(
f.requests().await,
2,
"a declined shape with twice the statements is offered again"
);
let text = user_text(&f.model.requests.lock().unwrap()[1]);
assert!(
text.contains("founded in"),
"the declined shape is offered again: {text}"
);
assert!(
!text.contains("s1"),
"the shape already proposed as map_to is not offered: {text}"
);
// 这一轮的答案并进同一条 map_to:两条形状,各自的方向
let open = utopia_store::ontology::open_proposals(&f.pool, f.kb).await?;
assert_eq!(open.len(), 1, "still one map_to row: {open:?}");
let shapes = open[0].signatures["phrases"].as_array().unwrap().clone();
assert_eq!(
shapes.len(),
2,
"shapes from both rounds are kept: {shapes:?}"
);
assert_eq!(shapes[0]["phrase"], "located in");
assert_eq!(shapes[0]["direction"], "forward");
assert_eq!(shapes[1]["phrase"], "founded in");
assert_eq!(shapes[1]["direction"], "reverse");
assert_eq!(
open[0].payload["forms"],
json!(["located in", "founded in"])
);
// 采纳 map_to:两条形状都成了人的绑定,绑到 located_in,各按自己的方向
let id = adopt(
&f.state,
f.kb,
"map_to",
"located_in",
AdoptEdits::default(),
f.user,
)
.await?
.id;
assert_eq!(id, f.located_in);
let bindings = phrase_bindings::bindings(&f.pool, f.kb).await?;
for (phrase, dir) in [("located in", "forward"), ("founded in", "reverse")] {
let b = bindings
.iter()
.find(|b| b.phrase == phrase)
.expect("the binding exists");
assert_eq!(b.status, "bound", "{phrase}");
assert_eq!(b.decided_by, "person", "{phrase}");
assert_eq!(b.relation_type_id, Some(f.located_in), "{phrase}");
assert_eq!(b.direction.as_deref(), Some(dir), "{phrase}");
}
assert!(
utopia_store::ontology::open_proposals(&f.pool, f.kb)
.await?
.is_empty(),
"the map_to proposal is adopted"
);
// 再来一轮:两条都绑上了——不问
propose(&f.state, f.kb).await?;
assert_eq!(f.requests().await, 2);
f.cleanup().await
}
#[tokio::test]
async fn a_base_with_no_questions_gets_them_proposed_and_the_report_counts_them(
) -> anyhow::Result<()> {
let Some(f) = Fx::new(vec![
// 本体代理发现库里一条问题都没有:先提问题(这一轮的第一次调用)
json!({ "q": [
{ "question": "Where is each organization located?", "classes": ["organization", "place"], "properties": ["located_in", "made_up"] },
{ "question": "Why?", "classes": [], "properties": [] }
] }),
// 然后照旧按说法提本体
json!({ "p": [], "existing": [] }),
// 界面上再叫一次提问题:同一句不重复,新的进来
json!({ "q": [
{ "question": "where is each ORGANIZATION located?", "classes": [], "properties": [] },
{ "question": "Which organizations were founded in each place?", "classes": ["organization"], "properties": [] }
] }),
])
.await?
else {
return Ok(());
};
f.decide_none().await?;
propose(&f.state, f.kb).await?;
assert_eq!(
f.requests().await,
2,
"questions first, then the ontology round"
);
let text = user_text(&f.model.requests.lock().unwrap()[0]);
assert!(text.contains("Most frequent statement shapes"), "{text}");
assert!(
text.contains("\"founded in\""),
"the shapes are offered: {text}"
);
assert!(
text.contains("Acme (organization)"),
"the connected entities are offered: {text}"
);
let qs = competency_questions::list(&f.pool, f.kb).await?;
assert_eq!(qs.len(), 1, "the short one is dropped: {qs:?}");
assert_eq!(qs[0].origin, "agent");
assert_eq!(qs[0].status, "proposed");
assert_eq!(
qs[0].needs,
Some(json!({ "classes": ["organization", "place"], "properties": ["located_in"] })),
"keys the ontology lacks are dropped from needs"
);
// 提出来的还没接受:本体那一轮没有问题可用
let text = user_text(&f.model.requests.lock().unwrap()[1]);
assert!(text.contains("(none written yet"), "{text}");
let written = propose_questions(&f.state, f.kb).await?;
assert_eq!(written, 1, "the duplicate is skipped, the new one written");
assert_eq!(f.requests().await, 3);
let text = user_text(&f.model.requests.lock().unwrap()[2]);
assert!(text.contains("do not repeat them"), "{text}");
assert!(
text.contains("Where is each organization located?"),
"{text}"
);
// 接受一条、问过一条:报告数得出来
let qs = competency_questions::list(&f.pool, f.kb).await?;
competency_questions::set_status(&f.pool, f.kb, qs[0].id, "accepted").await?;
competency_questions::set_status(&f.pool, f.kb, qs[1].id, "accepted").await?;
assert!(
competency_questions::record_result(
&f.pool,
f.kb,
qs[0].id,
&json!({ "answered": true, "judged_by": "shape" })
)
.await?
);
let r = competency_questions::report(&f.pool, f.kb).await?;
assert_eq!(
(r.accepted, r.proposed, r.checked, r.answered),
(2, 0, 1, 1)
);
let p = utopia_store::ontology::agent_proposal_report(&f.pool, f.kb).await?;
assert_eq!(
(p.open, p.adopted, p.adopted_edited, p.rejected),
(0, 0, 0, 0)
);
f.cleanup().await
}
/// 采纳半途失败什么都不留。字面值属性的例句宾语是实体,回归用例写不进去:从前属性先提交、
/// 对齐先排上,提案还开着而键已被占,这条提案再也采纳不了
#[tokio::test]
async fn a_failed_adoption_leaves_nothing_behind() -> anyhow::Result<()> {
let Some(f) = Fx::new(Vec::new()).await? else {
return Ok(());
};
let founding_note = json!({ "key": "founding_note", "label": "founding note", "description": "x",
"datatype": "text", "domains": ["organization"], "proposed_by": "agent" });
let shapes = json!({ "phrases": [f.shape("founded in").await?] });
f.seed("attribute_types", "founding_note", founding_note, shapes)
.await?;
let adopt = json!({ "section": "attribute_types", "key": "founding_note" });
let (status, body) = f.post("/ontology/proposals/adopt", adopt).await?;
assert_eq!(status, StatusCode::UNPROCESSABLE_ENTITY, "{body}");
assert_eq!(body["code"], "bad_property_shape");
assert_eq!(
f.left_by("founding_note").await?,
(false, "open".to_string(), 0, 0),
"no attribute, no job, no case; the proposal stays open for a person to reject"
);
f.cleanup().await
}
/// 只改状态的接口不再收「采纳」:从前它把提案标成采纳,元素却没建
#[tokio::test]
async fn the_status_only_endpoint_does_not_adopt() -> anyhow::Result<()> {
let Some(f) = Fx::new(Vec::new()).await? else {
return Ok(());
};
f.seed("relation_types", "founded_in", founded_in(), json!({}))
.await?;
let adopt = json!({ "section": "relation_types", "key": "founded_in", "status": "adopted" });
let (status, body) = f.post("/ontology/proposals", adopt).await?;
assert_eq!(status, StatusCode::UNPROCESSABLE_ENTITY, "{body}");
assert_eq!(body["code"], "adoption_endpoint");
assert_eq!(
f.left_by("founded_in").await?,
(false, "open".to_string(), 0, 0)
);
f.cleanup().await
}
/// 退役的 Suggest 留下的提案不能采纳:工作台早就不列它(`stored_proposals`),从前直接调采纳的
/// 接口却照样建出元素
#[tokio::test]
async fn a_proposal_the_retired_suggest_left_is_not_adopted() -> anyhow::Result<()> {
let Some(f) = Fx::new(Vec::new()).await? else {
return Ok(());
};
f.seed("relation_types", "founded_in", founded_in(), json!({}))
.await?;
sqlx::query("UPDATE ontology_proposals SET proposed_by='suggest' WHERE kb_id=$1")
.bind(f.kb)
.execute(&f.pool)
.await?;
let adopt = json!({ "section": "relation_types", "key": "founded_in" });
let (status, body) = f.post("/ontology/proposals/adopt", adopt).await?;
assert_eq!(status, StatusCode::NOT_FOUND, "{body}");
f.cleanup().await
}
/// 采纳像编辑器一样先排补向量、再排对齐(新属性排短语对齐,新类排类别词对齐),和元素同一次
/// 提交,请求里不调嵌入。对齐晚 5 秒到期:同时到期的话两份一起被领走,对齐看见补向量正跑着,
/// 就把自己挪到半分钟后
#[tokio::test]
async fn adoption_queues_vectors_before_alignment() -> anyhow::Result<()> {
let Some(f) = Fx::new(Vec::new()).await? else {
return Ok(());
};
// 配上嵌入模型:请求里就地嵌的话,嵌入端点数得到
sqlx::query(
"UPDATE llm_settings SET embed_base_url = chat_base_url, embed_model = 'scripted-embed'
WHERE workspace_id = (SELECT workspace_id FROM knowledge_bases WHERE id = $1)",
)
.bind(f.kb)
.execute(&f.pool)
.await?;
f.seed("relation_types", "founded_in", founded_in(), json!({}))
.await?;
f.seed("entity_types", "city", city(), json!({})).await?;
for (section, key, align) in [
("relation_types", "founded_in", "align_phrases"),
("entity_types", "city", "align_types"),
] {
let adopt = json!({ "section": section, "key": key });
let (status, body) = f.post("/ontology/proposals/adopt", adopt).await?;
assert_eq!(status, StatusCode::OK, "{body}");
assert_eq!(
(f.queued().await?, f.model.embeds.load(Ordering::SeqCst)),
(vec!["embed_ontology".to_string(), align.to_string()], 0),
"{key}: the vectors are queued ahead of alignment, and the request embeds nothing"
);
let gap: f64 = sqlx::query_scalar(
"SELECT extract(epoch FROM max(run_at) - min(run_at))::float8 FROM jobs WHERE payload->>'kb_id'=$1",
)
.bind(f.kb.to_string())
.fetch_one(&f.pool)
.await?;
assert!(
gap >= 5.0,
"{key}: alignment is due {gap} s after the vectors"
);
sqlx::query("DELETE FROM jobs WHERE payload->>'kb_id'=$1")
.bind(f.kb.to_string())
.execute(&f.pool)
.await?;
}
f.cleanup().await
}
/// 复用属性时每条形状写一条人的绑定,整次采纳排一份投影,不是一条形状一份
#[tokio::test]
async fn a_reuse_queues_one_projection_for_its_shapes() -> anyhow::Result<()> {
let Some(f) = Fx::new(Vec::new()).await? else {
return Ok(());
};
let shapes = json!({ "phrases": [f.shape("located in").await?, f.shape("founded in").await?] });
let reuse = json!({ "key": "located_in", "label": "located in", "kind": "relation", "proposed_by": "agent" });
f.seed("map_to", "located_in", reuse, shapes).await?;
let adopt = json!({ "section": "map_to", "key": "located_in" });
let (status, body) = f.post("/ontology/proposals/adopt", adopt).await?;
assert_eq!(status, StatusCode::OK, "{body}");
let bound: i64 = sqlx::query_scalar(
"SELECT count(*) FROM phrase_bindings WHERE kb_id=$1 AND decided_by='person' AND relation_type_id=$2",
)
.bind(f.kb)
.bind(f.located_in)
.fetch_one(&f.pool)
.await?;
assert_eq!(
(bound, f.queued().await?),
(2, vec![phrase_bindings::MATERIALIZE_KIND.to_string()]),
"both shapes are the person's, and one projection follows them"
);
f.cleanup().await
}
/// 复用类时类别词写成人的判定,整次采纳另排一份短语对齐,已经排着一份也照排:那份可能在这次
/// 提交之前就被领走,读不到换过的类
#[tokio::test]
async fn a_class_reuse_queues_its_own_phrase_alignment() -> anyhow::Result<()> {
let Some(f) = Fx::new(Vec::new()).await? else {
return Ok(());
};
utopia_store::jobs::enqueue(&f.pool, "align_phrases", json!({ "kb_id": f.kb })).await?;
let reuse = json!({ "key": "organization", "kind": "class", "proposed_by": "agent" });
let words = json!({ "kind_words": ["company"] });
f.seed("map_to", "organization", reuse, words).await?;
let adopt = json!({ "section": "map_to", "key": "organization" });
let (status, body) = f.post("/ontology/proposals/adopt", adopt).await?;
assert_eq!(status, StatusCode::OK, "{body}");
let bound: Option<Uuid> = sqlx::query_scalar(
"SELECT type_id FROM type_bindings WHERE kb_id=$1 AND kind_word='company' AND decided_by='person'",
)
.bind(f.kb)
.fetch_one(&f.pool)
.await?;
assert_eq!(
(bound, f.queued().await?),
(Some(f.organization), vec!["align_phrases".to_string(); 2]),
"company is the person's, and the adoption queues its own phrase alignment"
);
f.cleanup().await
}
/// 复用替掉的是代理读到的那个判定,读过之后人定的照人留着。founded in、firm 是人在代理读之前
/// 说的「没有」,照样替掉(firm 是第一轮读的,company 下一轮并进同一行,并的时候不丢它读到的时刻);
/// located in、company 是读过之后人绑到别处的,留着、列在回执里,located in 还是同事在采纳等着那一行
/// 时才提交的;headquartered in、wharf 是读过之后人绑得和提案一样的,算已写:不重写、不列,形状照样
/// 有回归用例;只有 wharf 的那条复用什么都没写,不另排短语对齐。venue 那条一个也写不了,整条不算
/// 采纳;没记下读到哪一刻的旧提案,人的判定一概不改
#[tokio::test]
async fn a_reuse_keeps_what_a_person_decided_after_the_agent_read_it() -> anyhow::Result<()> {
let Some(f) = Fx::new(vec![
// 形状按短语排:s0 founded in、s1 headquartered in、s2 located in;
// 类别词 k0 firm、k1 venue、k2 wharf
json!({ "p": [], "existing": [{ "key": "located_in", "s": [0, 1, 2] },
{ "key": "organization", "k": [0] }, { "key": "place", "k": [1] },
{ "key": "site", "k": [2] }] }),
json!({ "p": [], "existing": [{ "key": "organization", "k": [0] }] }),
])
.await?
else {
return Ok(());
};
f.decide_none().await?;
f.seed_question().await?;
let based_in = Uuid::now_v7();
let site = Uuid::now_v7();
// 类别词放在不出现在陈述里的实体上:归了类,形状的两端也不跟着变
sqlx::raw_sql(&format!(
"INSERT INTO relation_types(id,kb_id,key,label,kind,temporal,description)
VALUES ('{based_in}','{kb}','based_in','based in','relation','state','x');
INSERT INTO entity_types(id,kb_id,key,label,color,shape,description)
VALUES ('{site}','{kb}','site','Site','#000','circle','x');
INSERT INTO facts(id,kb_id,subject_id,object_id,layer,phrase)
SELECT '{fact}', kb_id, subject_id, object_id, 'open', 'headquartered in'
FROM facts WHERE kb_id='{kb}' AND phrase='located in';
INSERT INTO entities(id,kb_id,canonical_name,specific_type) VALUES
('{}','{kb}','Initech','firm'), ('{}','{kb}','Hall','venue'),
('{}','{kb}','Globex','company'), ('{}','{kb}','Pier','wharf');",
Uuid::now_v7(),
Uuid::now_v7(),
Uuid::now_v7(),
Uuid::now_v7(),
kb = f.kb,
fact = Uuid::now_v7(),
))
.execute(&f.pool)
.await?;
let votes = json!({ "person": "test" });
let word = |w: &'static str, class: Option<Uuid>, by: &'static str| {
let status = if class.is_some() { "bound" } else { "none" };
type_bindings::decide(&f.pool, f.kb, w, &[], class, status, &votes, by)
};
let sigs = phrase_bindings::signatures(&f.pool, f.kb).await?;
let sig = |phrase: &str| sigs.iter().find(|s| s.phrase == phrase).unwrap();
let person = |property: Option<Uuid>| Decision {
relation_type_id: property,
direction: property.map(|_| "forward"),
status: if property.is_some() { "bound" } else { "none" },
votes: &votes,
decided_by: "person",
basis: None,
marks: None,
marks_asked: false,
};
let shape = |phrase: &str, property: Option<Uuid>| {
phrase_bindings::decide(&f.pool, f.kb, sig(phrase), person(property))
};
shape("founded in", None).await?;
shape("headquartered in", None).await?;
word("firm", None, "person").await?;
word("venue", None, "agent").await?;
word("wharf", None, "agent").await?;
// company 还没判过,这一轮不送;判成「没有」后下一轮才送
propose(&f.state, f.kb).await?;
word("company", None, "agent").await?;
propose(&f.state, f.kb).await?;
assert_eq!(f.requests().await, 2);
// 代理读过之后人定的
shape("headquartered in", Some(f.located_in)).await?;
word("company", Some(f.place), "person").await?;
word("venue", Some(f.organization), "person").await?;
word("wharf", Some(site), "person").await?;
// located in 是同事定的,等 located_in 的采纳排到那一行后面才提交。那次的事务在代理读到的判定
// 之前就开始了:decided_at 是事务开始的时刻,比读到的还早,照样是读过之后定的
let mut deciding = f.pool.begin().await?;
let pid: i32 = sqlx::query_scalar("SELECT pg_backend_pid()")
.fetch_one(&mut *deciding)
.await?;
let colleague = person(Some(based_in));
phrase_bindings::decide_on(&mut deciding, f.kb, sig("located in"), colleague).await?;
sqlx::query(
"UPDATE phrase_bindings SET decided_at = decided_at - interval '1 day'
WHERE kb_id = $1 AND phrase = 'located in'",
)
.bind(f.kb)
.execute(&mut *deciding)
.await?;
let pool = f.pool.clone();
let commit = async move {
for _ in 0..500 {
let waiting: bool = sqlx::query_scalar(
"SELECT EXISTS(SELECT 1 FROM pg_stat_activity WHERE $1 = ANY(pg_blocking_pids(pid)))",
)
.bind(pid)
.fetch_one(&pool)
.await?;
if waiting {
break;
}
tokio::time::sleep(std::time::Duration::from_millis(10)).await;
}
deciding.commit().await?;
anyhow::Ok(())
};
let adopt = |key: &str| json!({ "section": "map_to", "key": key });
let ((status, body), ()) = tokio::try_join!(
f.post("/ontology/proposals/adopt", adopt("located_in")),
commit
)?;
assert_eq!(status, StatusCode::OK, "{body}");
assert_eq!(
body["skipped"],
json!([{ "phrase": "located in", "subject": "organization", "object": "place", "value": false,
"person": { "status": "bound", "property": "based_in", "direction": "forward" } }])
);
let (status, body) = f
.post("/ontology/proposals/adopt", adopt("organization"))
.await?;
assert_eq!(status, StatusCode::OK, "{body}");
assert_eq!(
body["skipped"],
json!([{ "kind_word": "company", "person": { "status": "bound", "class": "place" } }])
);
let (status, body) = f.post("/ontology/proposals/adopt", adopt("site")).await?;
assert_eq!(
(status, &body["skipped"]),
(StatusCode::OK, &json!([])),
"{body}"
);
let (status, body) = f.post("/ontology/proposals/adopt", adopt("place")).await?;
assert_eq!(
(status, &body["code"]),
(StatusCode::CONFLICT, &json!("proposal_stale")),
"{body}"
);
// 这一格之前存的复用没记读到的时刻:founded in 此刻是人的判定,不改,整条不算采纳
let reuse = json!({ "key": "based_in", "kind": "relation", "proposed_by": "agent" });
let shapes = json!({ "phrases": [f.shape("founded in").await?] });
f.seed("map_to", "based_in", reuse, shapes).await?;
let (status, body) = f
.post("/ontology/proposals/adopt", adopt("based_in"))
.await?;
assert_eq!(
(status, &body["code"]),
(StatusCode::CONFLICT, &json!("proposal_stale")),
"{body}"
);
type Row = (String, Option<String>, Option<String>);
let row = |s: &str, key: &str, via: Option<&str>| -> Row {
(s.into(), Some(key.into()), via.map(Into::into))
};
let shapes: Vec<Row> = sqlx::query_as(
"SELECT b.phrase, r.key, b.votes #>> '{person,via}' FROM phrase_bindings b
LEFT JOIN relation_types r ON r.id = b.relation_type_id WHERE b.kb_id = $1 ORDER BY 1",
)
.bind(f.kb)
.fetch_all(&f.pool)
.await?;
let words: Vec<Row> = sqlx::query_as(
"SELECT b.kind_word, t.key, b.votes->>'via' FROM type_bindings b
LEFT JOIN entity_types t ON t.id = b.type_id WHERE b.kb_id = $1 ORDER BY 1",
)
.bind(f.kb)
.fetch_all(&f.pool)
.await?;
let via = Some("ontology_agent");
assert_eq!(
(shapes, words),
(
vec![
row("founded in", "located_in", via),
row("headquartered in", "located_in", None),
row("located in", "based_in", None),
],
vec![
row("company", "place", None),
row("firm", "organization", via),
row("venue", "organization", None),
row("wharf", "site", None),
]
),
"what the agent read is replaced; what a person decided after it stays theirs"
);
let cases: Vec<String> = sqlx::query_scalar(
"SELECT f.phrase FROM ontology_regression_cases c JOIN facts f ON f.id = c.statement_id
WHERE c.kb_id = $1 ORDER BY 1",
)
.bind(f.kb)
.fetch_all(&f.pool)
.await?;
assert_eq!(
cases,
["founded in", "headquartered in"],
"none for the kept shape"
);
// venue 那条还开着。后三次都没多排任务、没多写用例:两份任务、两条用例都是前两次采纳的
assert_eq!(f.left_by("place").await?, (true, "open".to_string(), 2, 2));
f.cleanup().await
}
/// 采纳途中,提案要的类被删了:等删完答 unknown_class,什么都不写,不是写父类时才撞上外键
#[tokio::test]
async fn a_class_deleted_during_adoption_answers_unknown_class() -> anyhow::Result<()> {
let Some(f) = Fx::new(Vec::new()).await? else {
return Ok(());
};
// 没有实体的类才删得掉
sqlx::query(
"INSERT INTO entity_types(id,kb_id,key,label,color,shape,description)
VALUES ($1,$2,'region','Region','#000','circle','x')",
)
.bind(Uuid::now_v7())
.bind(f.kb)
.execute(&f.pool)
.await?;
let mut town = city();
town["parents"] = json!(["region"]);
f.seed("entity_types", "city", town, json!({})).await?;
let mut deleting = f.pool.begin().await?;
let pid: i32 = sqlx::query_scalar("SELECT pg_backend_pid()")
.fetch_one(&mut *deleting)
.await?;
sqlx::query("DELETE FROM entity_types WHERE kb_id=$1 AND key='region'")
.bind(f.kb)
.execute(&mut *deleting)
.await?;
let pool = f.pool.clone();
let delete = async move {
// 等采纳排到这次删除后面,再提交
for _ in 0..500 {
let waiting: bool = sqlx::query_scalar(
"SELECT EXISTS(SELECT 1 FROM pg_stat_activity WHERE $1 = ANY(pg_blocking_pids(pid)))",
)
.bind(pid)
.fetch_one(&pool)
.await?;
if waiting {
break;
}
tokio::time::sleep(std::time::Duration::from_millis(10)).await;
}
deleting.commit().await?;
anyhow::Ok(())
};
let adopt = json!({ "section": "entity_types", "key": "city" });
let ((status, body), ()) =
tokio::try_join!(f.post("/ontology/proposals/adopt", adopt), delete)?;
assert_eq!(status, StatusCode::UNPROCESSABLE_ENTITY, "{body}");
assert_eq!(body["code"], "unknown_class");
assert_eq!(f.left_by("city").await?, (false, "open".to_string(), 0, 0));
f.cleanup().await
}