World's first open-source enterprise world model.
Rust agent-memorybitemporalgraphragknowledge-baseknowledge-graphllmontologypgvectorpostgresqlragrustself-hostedsemantic-searchtemporal-knowledge-graphworld-model
Reject phrase bindings whose selected direction does not fit their declared ends (#1206)
Virtue039438afa77c8aa
diff --git a/crates/utopia-server/src/phrase_alignment.rs b/crates/utopia-server/src/phrase_alignment.rsindex b6e9269a..c158788b 100644--- a/crates/utopia-server/src/phrase_alignment.rs+++ b/crates/utopia-server/src/phrase_alignment.rs@@ -112,9 +112,21 @@ pub(crate) fn structurally_fits(/// 签名两端的类落在属性声明的域/值域里,经继承也算;正反两个方向都算。fn fits(p: &RelationTypeView, sig: &PhraseSignature, closure: &Closure) -> Option<Fit> {+ fits_direction(p, sig, closure, Direction::Forward)+ .or_else(|| fits_direction(p, sig, closure, Direction::Reverse))+}++// Admitting a property in either orientation does not admit both orientations.+// Two agreeing model votes used to turn a forward-only candidate into a reverse binding.+fn fits_direction(+ p: &RelationTypeView,+ sig: &PhraseSignature,+ closure: &Closure,+ direction: Direction,+) -> Option<Fit> {let mut via = Vec::new();if sig.object_is_value {- if p.kind != "attribute" {+ if p.kind != "attribute" || direction != Direction::Forward {return None;}via.extend(within(&p.domains, sig.subject_type_id, closure)?);@@ -123,22 +135,34 @@ fn fits(p: &RelationTypeView, sig: &PhraseSignature, closure: &Closure) -> Optioif p.kind != "relation" {return None;}- let forward = within(&p.domains, sig.subject_type_id, closure).zip(within(- &p.ranges,- sig.object_type_id,- closure,- ));- let reverse = within(&p.domains, sig.object_type_id, closure).zip(within(- &p.ranges,- sig.subject_type_id,- closure,- ));- let (a, b) = forward.or(reverse)?;+ let (subject, object) = match direction {+ Direction::Forward => (sig.subject_type_id, sig.object_type_id),+ Direction::Reverse => (sig.object_type_id, sig.subject_type_id),+ };+ let a = within(&p.domains, subject, closure)?;+ let b = within(&p.ranges, object, closure)?;via.extend(a);via.extend(b);Some(Fit { via })}+fn invalid_agent_direction(+ b: &phrase_bindings::Binding,+ sig: &PhraseSignature,+ props: &[RelationTypeView],+ closure: &Closure,+) -> bool {+ b.decided_by == "agent"+ && b.status == "bound"+ && b.relation_type_id+ .and_then(|id| props.iter().find(|p| p.id == id))+ .is_some_and(|p| match b.direction.as_deref() {+ Some("forward") => fits_direction(p, sig, closure, Direction::Forward).is_none(),+ Some("reverse") => fits_direction(p, sig, closure, Direction::Reverse).is_none(),+ _ => true,+ })+}+/// 签名的键:短语 + 两端的类 + 宾语是不是字面值(与 `PhraseSignature::key` 同形)type SignatureKey = (String, Option<Uuid>, Option<Uuid>, bool);/// 每条签名此刻的候选与指纹@@ -599,7 +623,8 @@ async fn align_phrases_locked(Some(b) => {b.decided_by != "person"&& (b.basis.as_deref() != Some(considered[&s.key()].1.as_str())- || awaits_marks(b, &props))+ || awaits_marks(b, &props)+ || invalid_agent_direction(b, s, &props, &closure))}}).collect();@@ -610,8 +635,10 @@ async fn align_phrases_locked(.iter().filter_map(|s| {let b = existing.get(&s.key())?;- (b.basis.as_deref() == Some(considered[&s.key()].1.as_str()) && awaits_marks(b, &props))- .then_some((s.key(), b))+ (b.basis.as_deref() == Some(considered[&s.key()].1.as_str())+ && awaits_marks(b, &props)+ && !invalid_agent_direction(b, s, &props, &closure))+ .then_some((s.key(), b))}).collect();tracing::info!(%kb_id, signatures = sigs.len(), to_decide = todo.len(), properties = props.len(), "短语对齐开始");@@ -916,18 +943,27 @@ async fn align_phrases_locked(}).unwrap_or(serde_json::Value::Null)};- let record = if asked_twice {+ let mut record = if asked_twice {serde_json::json!({ "first": show(a), "second": show(b) })} else {serde_json::json!({ "first": null, "reason": "first_vote_none" })};+ let valid = |v: &Vote| v.as_ref().is_none_or(|(k, d, _)| {+ by_key.get(k.as_str()).is_some_and(|p| fits_direction(p, s, closure, *d).is_some())+ });+ let invalid_direction = !valid(a) || !valid(b);+ if invalid_direction {+ // Keep both votes for review; an invalid direction is neither a+ // semantic none nor permission to silently flip the model's answer.+ record["reason"] = serde_json::json!("invalid_direction");+ }// 两票选的属性与方向(或都说没有)是否一致let agree = match (a, b) {(Some((ka, da, _)), Some((kb, db, _))) => ka == kb && da == db,(None, None) => true,_ => false,};- if !agree {+ if !agree || invalid_direction {phrase_bindings::decide(pool,kb_id,@@ -1030,6 +1066,69 @@ async fn align_phrases_locked(unsettled += us;}}+ // Old invalid agent bindings have matching fingerprints, so explicitly retry+ // them above. If the model fails, structural invalidity still cannot support+ // their typed rows: keep the old votes in an undecided result for a person.+ // Read again so a person who decided during the request remains protected.+ let repair: Vec<_> = todo+ .iter()+ .copied()+ .filter(|s| {+ existing+ .get(&s.key())+ .is_some_and(|b| invalid_agent_direction(b, s, &props, &closure))+ })+ .collect();+ if !repair.is_empty() {+ let now: HashMap<_, _> = phrase_bindings::bindings(pool, kb_id)+ .await?+ .into_iter()+ .map(|b| (b.key(), b))+ .collect();+ for s in repair {+ let Some(b) = now.get(&s.key()) else {+ continue;+ };+ if !invalid_agent_direction(b, s, &props, &closure) {+ continue;+ }+ let previous: Option<serde_json::Value> = sqlx::query_scalar(+ "SELECT votes FROM phrase_bindings WHERE kb_id=$1 AND phrase=$2+ AND subject_type_id IS NOT DISTINCT FROM $3+ AND object_type_id IS NOT DISTINCT FROM $4 AND object_is_value=$5",+ )+ .bind(kb_id)+ .bind(&s.phrase)+ .bind(s.subject_type_id)+ .bind(s.object_type_id)+ .bind(s.object_is_value)+ .fetch_optional(pool)+ .await?;+ let Some(previous) = previous else {+ continue;+ };+ if phrase_bindings::decide(+ pool,+ kb_id,+ s,+ Decision {+ relation_type_id: None,+ direction: None,+ status: "undecided",+ votes: &serde_json::json!({"reason":"invalid_direction", "previous":previous,+ "previous_decided_at":b.decided_at}),+ decided_by: "agent",+ basis: Some(&considered[&s.key()].1),+ marks: None,+ marks_asked: false,+ },+ )+ .await?+ {+ undecided += 1;+ }+ }+ }tracing::info!(%kb_id, bound, none, undecided, skipped, failed, unanswered, marked, unsettled, "短语对齐完成");if unanswered > 0 {tracing::warn!(%kb_id, unanswered, "短语对齐有签名模型没答到,这些签名这轮没有结论");@@ -1401,6 +1500,49 @@ mod tests {);}+ #[test]+ fn a_selected_direction_respects_inheritance_unknown_types_and_literal_shape() {+ let (parent, child, place) = (Uuid::now_v7(), Uuid::now_v7(), Uuid::now_v7());+ let closure = closures([(parent, &[][..]), (child, &[parent][..]), (place, &[][..])]);+ let relation = view("relation", vec![parent], vec![place]);+ let attribute = view("attribute", vec![parent], vec![]);+ let open = view("relation", vec![], vec![]);+ let any_to_place = view("relation", vec![], vec![place]);+ for (p, s, allowed) in [+ (+ &relation,+ sig(Some(child), Some(place), false),+ [true, false],+ ),+ (+ &relation,+ sig(Some(place), Some(child), false),+ [false, true],+ ),+ (&relation, sig(None, Some(place), false), [false, false]),+ (&any_to_place, sig(None, Some(place), false), [true, false]),+ (&any_to_place, sig(Some(place), None, false), [false, true]),+ (&open, sig(None, None, false), [true, true]),+ (&attribute, sig(Some(child), None, true), [true, false]),+ (+ &attribute,+ sig(Some(child), Some(place), false),+ [false, false],+ ),+ (&relation, sig(Some(child), None, true), [false, false]),+ ] {+ for (direction, expected) in [Direction::Forward, Direction::Reverse]+ .into_iter()+ .zip(allowed)+ {+ assert_eq!(+ fits_direction(p, &s, &closure, direction).is_some(),+ expected+ );+ }+ }+ }+/// 闭包:多继承与菱形,每个祖先只出现一次,且含自己#[test]fn closures_walk_the_hierarchy_once_per_ancestor() {diff --git a/crates/utopia-server/src/phrase_alignment_tests.rs b/crates/utopia-server/src/phrase_alignment_tests.rsindex 0d3bbe11..bc485195 100644--- a/crates/utopia-server/src/phrase_alignment_tests.rs+++ b/crates/utopia-server/src/phrase_alignment_tests.rs@@ -332,6 +332,179 @@ fn none() -> Vec<Value> {vec![vote(None, None)]}+#[tokio::test]+async fn agreeing_votes_cannot_bind_a_direction_outside_the_declared_ends() -> anyhow::Result<()> {+ for shape in ["forward-only", "reverse-only", "literal"] {+ let Some(f) = Fx::new().await? else {+ return Ok(());+ };+ let run = async {+ let invalid = match shape {+ "reverse-only" => {+ sqlx::query("UPDATE facts SET subject_id=object_id,object_id=subject_id WHERE kb_id=$1 AND layer='open'")+ .bind(f.kb).execute(&f.pool).await?;+ "forward"+ }+ "literal" => {+ sqlx::query("DELETE FROM relation_type_ranges WHERE relation_type_id=$1")+ .bind(f.based_in).execute(&f.pool).await?;+ sqlx::query("UPDATE relation_types SET kind='attribute' WHERE id=$1")+ .bind(f.based_in).execute(&f.pool).await?;+ sqlx::query("UPDATE facts SET object_id=NULL,object_value='{\"value\":\"London\"}' WHERE kb_id=$1 AND layer='open'")+ .bind(f.kb).execute(&f.pool).await?;+ "reverse"+ }+ _ => "reverse",+ };+ let answer = marked(Some("based_in"), Some(invalid), Some("end"));+ f.script(vec![answer.clone(), answer, nothing_implied()]);+ f.run().await?;+ let b = f.binding().await?;+ assert_eq!(b.status, "undecided", "{shape}: agreement is not structural validity");+ assert!(b.relation_type_id.is_none() && b.direction.is_none() && b.marks.is_none());+ let votes: Value = sqlx::query_scalar("SELECT votes FROM phrase_bindings WHERE kb_id=$1")+ .bind(f.kb).fetch_one(&f.pool).await?;+ assert_eq!(votes["reason"], "invalid_direction");+ assert_eq!(votes["first"]["direction"], invalid);+ assert_eq!(votes["second"]["direction"], invalid);+ assert_eq!(f.typed().await?, 0);+ assert_eq!(f.requests().len(), 2, "no implication question for an invalid binding");+ assert!(!f.requeued().await?);+ f.run().await?;+ assert_eq!(f.requests().len(), 2, "unchanged undecided stays in review");+ sqlx::query("UPDATE relation_types SET updated_at=clock_timestamp() WHERE id=$1")+ .bind(f.based_in).execute(&f.pool).await?;+ let allowed = if shape == "reverse-only" { "reverse" } else { "forward" };+ let answer = vote(Some("based_in"), Some(allowed));+ f.script(vec![answer.clone(), answer, nothing_implied()]);+ f.run().await?;+ let b = f.binding().await?;+ assert_eq!((b.status.as_str(), b.direction.as_deref()), ("bound", Some(allowed)));+ assert_eq!(f.typed().await?, 1, "a later valid decision still materializes");+ assert!(!f.requeued().await?);+ anyhow::Ok(())+ }.await;+ f.cleanup().await?;+ run?;+ }+ Ok(())+}++// Reproduce an old accepted reverse binding whose fingerprint is already current,+// including its materialized row. A version/fingerprint mismatch cannot rescue it.+async fn cached_invalid_direction(f: &Fx, decider: &str) -> anyhow::Result<String> {+ f.script(bound());+ f.run().await?;+ let basis = f.binding().await?.basis.unwrap();+ let sig = phrase_bindings::signatures(&f.pool, f.kb).await?.remove(0);+ phrase_bindings::decide(&f.pool, f.kb, &sig, Decision {+ relation_type_id: Some(f.based_in), direction: Some("reverse"), status: "bound",+ votes: &json!({"first":{"property":"based_in","direction":"reverse"},"second":{"property":"based_in","direction":"reverse"}}),+ decided_by: decider, basis: (decider == "agent").then_some(basis.as_str()),+ marks: Some("none"), marks_asked: true,+ }).await?;+ materialize::materialize(&f.pool, f.kb).await?;+ assert_eq!(f.typed().await?, 1);+ f.clear_jobs().await?;+ Ok(basis)+}++#[tokio::test]+async fn a_cached_invalid_direction_is_redecided_without_an_input_edit() -> anyhow::Result<()> {+ let Some(f) = Fx::new().await? else {+ return Ok(());+ };+ let run = async {+ let basis = cached_invalid_direction(&f, "agent").await?;+ f.script(bound());+ // This cache also predates the marks question: repairing its direction+ // must not be narrowed to a marks-only request by the unchanged basis.+ sqlx::query("UPDATE phrase_bindings SET marks=NULL,marks_asked_at=NULL WHERE kb_id=$1")+ .bind(f.kb).execute(&f.pool).await?;+ f.run().await?;+ let b = f.binding().await?;+ assert_eq!((b.status.as_str(), b.direction.as_deref()), ("bound", Some("forward")));+ assert_eq!(b.basis.as_deref(), Some(basis.as_str()));+ assert_eq!(f.requests().len(), 4, "two fresh votes despite the unchanged fingerprint");+ let correct: i64 = sqlx::query_scalar("SELECT count(*) FROM facts WHERE kb_id=$1 AND layer='typed' AND invalidated_at IS NULL AND subject_id=$2")+ .bind(f.kb).bind(f.acme).fetch_one(&f.pool).await?;+ assert_eq!(correct, 1, "the corrected projection follows the statement direction");+ assert!(!f.requeued().await?);+ anyhow::Ok(())+ }.await;+ f.cleanup().await?;+ run+}++#[tokio::test]+async fn an_unreadable_repair_cannot_keep_an_invalid_cached_projection() -> anyhow::Result<()> {+ let Some(f) = Fx::new().await? else {+ return Ok(());+ };+ let run = async {+ let basis = cached_invalid_direction(&f, "agent").await?;+ f.script(vec![json!({"unreadable":true})]);+ f.run().await?;+ let b = f.binding().await?;+ assert_eq!(+ b.status, "undecided",+ "a failed model is not support for the old invalid direction"+ );+ assert_eq!(b.basis.as_deref(), Some(basis.as_str()));+ assert_eq!(f.typed().await?, 0);+ let votes: Value = sqlx::query_scalar("SELECT votes FROM phrase_bindings WHERE kb_id=$1")+ .bind(f.kb)+ .fetch_one(&f.pool)+ .await?;+ assert_eq!(votes["reason"], "invalid_direction");+ assert_eq!(votes["previous"]["first"]["direction"], "reverse");+ assert_eq!(f.requests().len(), 3);+ f.clear_jobs().await?;+ f.run().await?;+ assert_eq!(+ f.requests().len(),+ 3,+ "the unresolved direction remains for a person"+ );+ assert!(!f.requeued().await?);+ anyhow::Ok(())+ }+ .await;+ f.cleanup().await?;+ run+}++#[tokio::test]+async fn an_inapplicable_direction_chosen_by_a_person_is_preserved() -> anyhow::Result<()> {+ let Some(f) = Fx::new().await? else {+ return Ok(());+ };+ let run = async {+ cached_invalid_direction(&f, "person").await?;+ f.run().await?;+ let b = f.binding().await?;+ assert_eq!(+ (+ b.status.as_str(),+ b.direction.as_deref(),+ b.decided_by.as_str()+ ),+ ("bound", Some("reverse"), "person")+ );+ assert_eq!(+ f.requests().len(),+ 2,+ "only the seed agent binding used the model"+ );+ assert_eq!(f.typed().await?, 1);+ assert!(!f.requeued().await?);+ anyhow::Ok(())+ }+ .await;+ f.cleanup().await?;+ run+}+/// 类别词对齐还排着时短语对齐不动手:两端的类还没定,判了也是重判。它给自己排一份半分钟/// 后的,类别词对齐收尾后照常判#[tokio::test]@@ -716,7 +889,11 @@ async fn a_person_decision_made_during_the_request_is_not_overwritten() -> anyhof.model.hold.store(true, std::sync::atomic::Ordering::SeqCst);- f.script(none());+ f.script(vec![+ vote(Some("based_in"), Some("reverse")),+ vote(Some("based_in"), Some("reverse")),+ nothing_implied(),+ ]);let state = f.state.clone();let kb = f.kb;let worker = tokio::spawn(async move { align_phrases_reasking(&state, kb, 0).await });