Skip to content

World's first open-source enterprise world 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.rs
index 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) -> Optio
if 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.rs
index 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() -> anyho
f.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 });