Skip to content
Python
29.0 KB
Raw Blame
use super::*;
use crate::safety::{Action, Config, Guardrails, Rule};
use std::sync::atomic::AtomicUsize;

fn message(text: &str) -> Value {
    json!({"type":"message","role":"assistant","content":[{"type":"output_text","text":text}]})
}
async fn fixture(config: Config, model: Model) -> (tempfile::TempDir, Arc<Runtime>, String) {
    let tmp = tempfile::tempdir().unwrap();
    let work = tmp.path().join("work");
    std::fs::create_dir(&work).unwrap();
    let runner = tmp.path().join("runner");
    std::fs::write(&runner, b"\x7fELF-not-executed").unwrap();
    let bundle = Path::new(env!("CARGO_MANIFEST_DIR")).join("../examples/assistant");
    let rt = Runtime::open(&tmp.path().join("state"), &bundle, &runner, model).unwrap();
    let sid=rt.dispatch("session/create",json!({"name":"Safety","coworker":"assistant-example","workspace":work,"safety":config,"compaction":{"enabled":false},"permissions":{"mode":"bypass"}})).await.unwrap()["session"]["id"].as_str().unwrap().to_owned();
    (tmp, rt, sid)
}
fn fake(outputs: Vec<&'static str>, seen: Arc<AtomicUsize>) -> Model {
    let mut m = Model::new("test".into(), true);
    m.sample_hook = Some(Arc::new(move |_, history, tx| {
        let n = seen.fetch_add(1, Ordering::SeqCst);
        let text = outputs[n.min(outputs.len() - 1)];
        assert!(!serde_json::to_string(&history)
            .unwrap()
            .contains("SECRET_SENTINEL"));
        Box::pin(async move {
            tx.send(Progress::Delta(text.into())).await.unwrap();
            tx.send(Progress::Complete(crate::provider::Completion {
                output: vec![message(text)],
                usage: Some(crate::provider::Usage {
                    output_tokens: 10,
                    ..Default::default()
                }),
            }))
            .await
            .unwrap();
            Ok(())
        })
    }));
    m
}
fn config(action: Action) -> Config {
    Config {
        guardrails: Guardrails {
            user_input: vec![Rule::regex("input-secret", "SECRET_[A-Z]+", action.clone())],
            model_output: vec![Rule::regex("output-secret", "SECRET_[A-Z]+", action)],
            ..Default::default()
        },
        ..Default::default()
    }
}
fn no_leak(rt: &Runtime, sid: &str) {
    let snapshot = rt.snapshot(sid).unwrap();
    let events = {
        let db = rt.store.lock().unwrap();
        json!(db.events(sid, 0).unwrap())
    };
    let history = {
        let db = rt.store.lock().unwrap();
        db.history_page(sid, 0).unwrap()
    };
    for data in [snapshot, events, history] {
        assert!(
            !data.to_string().contains("SECRET_SENTINEL"),
            "public sentinel leak"
        );
    }
}

fn signed_write(arguments: &str) -> Vec<Value> {
    vec![
        json!({"type":"reasoning","provider":"google-chat-completions","binding":"fixture-binding","block":{"type":"thought_signature","target":"tool_call","id":"signed-call","signature":"OPAQUE_SIGNED_CALL"}}),
        json!({"type":"function_call","name":"write_file","call_id":"signed-call","arguments":arguments}),
    ]
}
fn write_schema() -> Value {
    json!({"type":"function","name":"write_file","parameters":{"type":"object","properties":{"path":{"type":"string"},"content":{"type":"string"}},"required":["path","content"]}})
}
fn signed_tool_config(action: Action) -> Config {
    Config {
        guardrails: Guardrails {
            tool_calls: vec![crate::safety::ToolRules {
                tools: vec!["example-tools.write_file".into()],
                rules: vec![Rule::regex("tool-secret", "SECRET_[A-Z]+", action)],
            }],
            ..Default::default()
        },
        ..Default::default()
    }
}

#[tokio::test]
async fn signed_tool_redaction_and_denial_discard_candidate_with_bounded_retry() {
    for action in [Action::redact(), Action::Block] {
        for (recovers, message_level) in
            [(true, false), (false, false), (true, true), (false, true)]
        {
            let seen = Arc::new(AtomicUsize::new(0));
            let count = seen.clone();
            let mut model = Model::new("test".into(), true);
            model.sample_hook = Some(Arc::new(move |instructions, history, tx| {
                let n = count.fetch_add(1, Ordering::SeqCst);
                let raw = serde_json::to_string(&history).unwrap();
                assert!(!raw.contains("SECRET_SENTINEL"));
                assert!(!raw.contains("OPAQUE_SIGNED_CALL"));
                if n > 0 {
                    assert!(instructions.contains("application policy"));
                }
                let output = if n > 0 && recovers {
                    vec![message("I can offer a safe alternative.")]
                } else {
                    // Only the first call is signed; an unsafe parallel sibling
                    // must also cause the entire candidate to be discarded.
                    let mut batch = signed_write("{\"path\":\"safe.txt\",\"content\":\"safe\"}");
                    if message_level {
                        // Some Google models sign the first text part instead
                        // of a function call. The following tools remain part
                        // of the same signed candidate.
                        batch[0]["block"]["target"] = json!("message");
                        batch[0]["block"]["id"] = json!("signed-message");
                        let mut text = message("I will write both files.");
                        text["id"] = json!("signed-message");
                        batch.insert(1, text);
                    }
                    batch.push(json!({"type":"function_call","name":"write_file","call_id":"parallel-call","arguments":"{\"path\":\"no-write.txt\",\"content\":\"SECRET_SENTINEL\"}"}));
                    batch
                };
                Box::pin(async move {
                    tx.send(Progress::Complete(crate::provider::Completion {
                        output,
                        usage: Some(crate::provider::Usage {
                            output_tokens: 10,
                            ..Default::default()
                        }),
                    }))
                    .await
                    .unwrap();
                    Ok(())
                })
            }));
            let (tmp, rt, sid) = fixture(signed_tool_config(action.clone()), model).await;
            rt.store
                .lock()
                .unwrap()
                .accept(&sid, "signed-check", "write a file")
                .unwrap();
            let result = rt
                .drive(&sid, Default::default(), vec![write_schema()])
                .await;
            if recovers {
                result.unwrap();
            } else {
                assert!(result.unwrap_err().is::<safety::Blocked>());
            }
            assert_eq!(seen.load(Ordering::SeqCst), 2);
            assert!(!tmp.path().join("work/safe.txt").exists());
            assert!(!tmp.path().join("work/no-write.txt").exists());
            no_leak(&rt, &sid);
            let db = rt.store.lock().unwrap();
            assert!(!serde_json::to_string(&db.get(&sid).unwrap().history)
                .unwrap()
                .contains("OPAQUE_SIGNED_CALL"));
            let events = db.events(&sid, 0).unwrap();
            assert!(!events.iter().any(|e| e.kind == "tool_started"));
            assert_eq!(
                events
                    .iter()
                    .filter(|e| e.kind == "safety_output_retry")
                    .count(),
                1
            );
        }
    }
}

#[tokio::test]
async fn allowed_signed_tool_arguments_keep_the_exact_original_encoding() {
    let arguments = "{ \"path\": \"safe.txt\", \"content\": \"safe\" }";
    let mut model = Model::new("test".into(), true);
    model.sample_hook = Some(Arc::new(move |_, _, tx| {
        Box::pin(async move {
            tx.send(Progress::Complete(crate::provider::Completion {
                output: signed_write(arguments),
                usage: Some(crate::provider::Usage {
                    output_tokens: 10,
                    ..Default::default()
                }),
            }))
            .await
            .unwrap();
            Ok(())
        })
    }));
    let (_tmp, rt, sid) = fixture(signed_tool_config(Action::redact()), model).await;
    rt.store
        .lock()
        .unwrap()
        .accept(&sid, "signed-pass", "write a file")
        .unwrap();
    let history = rt.store.lock().unwrap().get(&sid).unwrap().history;
    let completion = rt.sample(&sid, &history, &[write_schema()]).await.unwrap();
    assert_eq!(
        completion.output[0]["block"]["signature"],
        "OPAQUE_SIGNED_CALL"
    );
    assert_eq!(completion.output[1]["arguments"], arguments);
}

#[tokio::test]
async fn user_block_precedes_admission_and_never_enters_history() {
    let seen = Arc::new(AtomicUsize::new(0));
    let (_tmp, rt, sid) = fixture(config(Action::Block), fake(vec!["safe"], seen.clone())).await;
    let out = rt
        .dispatch(
            "turn/start",
            json!({"session_id":sid,"submission_id":"blocked","text":"SECRET_SENTINEL"}),
        )
        .await;
    assert!(out.is_err());
    assert_eq!(seen.load(Ordering::SeqCst), 0);
    assert!(!rt
        .store
        .lock()
        .unwrap()
        .has_submission(&sid, "blocked")
        .unwrap());
    no_leak(&rt, &sid);
}

#[tokio::test]
async fn guarded_output_redacts_before_deltas_snapshots_and_history() {
    let seen = Arc::new(AtomicUsize::new(0));
    let (_tmp, rt, sid) = fixture(
        config(Action::redact()),
        fake(vec!["SECRET_SENTINEL"], seen.clone()),
    )
    .await;
    let input = rt.check_user_input(&sid, "SECRET_SENTINEL").await.unwrap();
    assert_eq!(input, "[redacted]");
    rt.store
        .lock()
        .unwrap()
        .accept(&sid, "redacted", &input)
        .unwrap();
    rt.drive(&sid, Default::default(), vec![]).await.unwrap();
    no_leak(&rt, &sid);
    assert_eq!(seen.load(Ordering::SeqCst), 1);
    assert!(rt
        .store
        .lock()
        .unwrap()
        .history_page(&sid, 0)
        .unwrap()
        .to_string()
        .contains("[redacted]"));
}

#[tokio::test]
async fn blocked_output_regenerates_from_accepted_history_with_bounded_budget() {
    let seen = Arc::new(AtomicUsize::new(0));
    let (_tmp, rt, sid) = fixture(
        config(Action::Block),
        fake(vec!["SECRET_SENTINEL", "Safe answer"], seen.clone()),
    )
    .await;
    rt.store
        .lock()
        .unwrap()
        .accept(&sid, "retry", "hello")
        .unwrap();
    rt.drive(&sid, Default::default(), vec![]).await.unwrap();
    assert_eq!(seen.load(Ordering::SeqCst), 2);
    no_leak(&rt, &sid);
    let s = rt.store.lock().unwrap().metadata(&sid).unwrap();
    let t = s.turn.unwrap();
    assert_eq!(t.safety_retries, 1);
    assert_eq!(t.budget.model_calls, 2);
}

#[tokio::test]
async fn persistent_output_block_stops_after_configured_retry() {
    let seen = Arc::new(AtomicUsize::new(0));
    let (_tmp, rt, sid) = fixture(
        config(Action::Block),
        fake(vec!["SECRET_SENTINEL"], seen.clone()),
    )
    .await;
    rt.store
        .lock()
        .unwrap()
        .accept(&sid, "retry", "hello")
        .unwrap();
    assert!(rt
        .drive(&sid, Default::default(), vec![])
        .await
        .unwrap_err()
        .is::<safety::Blocked>());
    assert_eq!(seen.load(Ordering::SeqCst), 2);
    no_leak(&rt, &sid);
}

struct Deny;
impl crate::safety::Handler for Deny {
    fn call(
        &self,
        _: crate::safety::Context,
        _: CancellationToken,
    ) -> crate::safety::CheckFuture<'_> {
        Box::pin(async { Ok(crate::safety::Decision::block("PUBLICATION_BLOCKED")) })
    }
}

#[tokio::test]
async fn application_instruction_addendum_is_checked_before_the_model() {
    use crate::safety::{HandlerRef, Hook, HookPhase};
    struct Inspect;
    impl crate::safety::Handler for Inspect {
        fn call(
            &self,
            c: crate::safety::Context,
            _: CancellationToken,
        ) -> crate::safety::CheckFuture<'_> {
            Box::pin(async move {
                assert_eq!(c.phase, crate::safety::Phase::ModelInput);
                assert!(c.text.contains("BLOCKED_APPLICATION_CONTEXT"));
                Ok(crate::safety::Decision::block(
                    "APPLICATION_CONTEXT_BLOCKED",
                ))
            })
        }
    }
    let reference = HandlerRef {
        name: "inspect-context".into(),
        version: "1".into(),
    };
    let config = Config {
        hooks: vec![Hook {
            name: "inspect-context".into(),
            version: "1".into(),
            when: HookPhase::BeforeModel,
            tools: vec![],
            handler: reference.clone(),
            timeout_ms: 100,
        }],
        ..Default::default()
    };
    let seen = Arc::new(AtomicUsize::new(0));
    let (_tmp, rt, sid) = fixture(config, fake(vec!["must not run"], seen.clone())).await;
    rt.safety_handlers
        .register(reference, Arc::new(Inspect))
        .unwrap();
    rt.store
        .lock()
        .unwrap()
        .accept_with_context(
            &sid,
            "context",
            "hello",
            None,
            None,
            crate::turn_options::Context {
                instruction_addendum: Some("BLOCKED_APPLICATION_CONTEXT".into()),
                ..Default::default()
            },
        )
        .unwrap();
    let history = rt.store.lock().unwrap().get(&sid).unwrap().history;
    assert!(rt
        .sample(&sid, &history, &[])
        .await
        .unwrap_err()
        .is::<super::safety::Blocked>());
    assert_eq!(seen.load(Ordering::SeqCst), 0);
    assert!(rt.store.lock().unwrap().attempts(&sid).unwrap().is_empty());
    assert!(!rt
        .store
        .lock()
        .unwrap()
        .history_page(&sid, 0)
        .unwrap()
        .to_string()
        .contains("BLOCKED_APPLICATION_CONTEXT"));
}
#[tokio::test]
async fn hook_blocks_tool_in_bypass_and_returns_safe_unexecuted_result_to_model() {
    use crate::safety::{HandlerRef, Hook, HookPhase};
    let mut model = Model::new("test".into(), true);
    let count = Arc::new(AtomicUsize::new(0));
    let seen = count.clone();
    model.sample_hook = Some(Arc::new(move |_, history, tx| {
        let n = seen.fetch_add(1, Ordering::SeqCst);
        let output = if n == 0 {
            json!({"type":"function_call","name":"write_file","call_id":"blocked-call","arguments":json!({"path":"no-write.txt","content":"SECRET_SENTINEL"}).to_string()})
        } else {
            let result = history
                .iter()
                .find(|v| v["type"] == "function_call_output")
                .unwrap();
            let result: Value = serde_json::from_str(result["output"].as_str().unwrap()).unwrap();
            assert_eq!(result["executed"], false);
            assert!(!serde_json::to_string(&history)
                .unwrap()
                .contains("SECRET_SENTINEL"));
            message("I could not write the file.")
        };
        Box::pin(async move {
            tx.send(Progress::Complete(crate::provider::Completion {
                output: vec![output],
                usage: Some(crate::provider::Usage {
                    output_tokens: 10,
                    ..Default::default()
                }),
            }))
            .await
            .unwrap();
            Ok(())
        })
    }));
    let reference = HandlerRef {
        name: "deny".into(),
        version: "1".into(),
    };
    let config = Config {
        hooks: vec![Hook {
            name: "deny".into(),
            version: "1".into(),
            when: HookPhase::BeforeTool,
            tools: vec![],
            handler: reference.clone(),
            timeout_ms: 50,
        }],
        ..Default::default()
    };
    let (tmp, rt, sid) = fixture(config, model).await;
    rt.safety_handlers
        .register(reference, Arc::new(Deny))
        .unwrap();
    rt.store
        .lock()
        .unwrap()
        .accept(&sid, "blocked-tool", "write a file")
        .unwrap();
    let schema = json!({"type":"function","name":"write_file","parameters":{"type":"object","properties":{"path":{"type":"string"},"content":{"type":"string"}},"required":["path","content"]}});
    rt.drive(&sid, Default::default(), vec![schema])
        .await
        .unwrap();
    assert_eq!(count.load(Ordering::SeqCst), 2);
    assert!(!tmp.path().join("work/no-write.txt").exists());
    no_leak(&rt, &sid);
    assert!(!rt
        .store
        .lock()
        .unwrap()
        .events(&sid, 0)
        .unwrap()
        .iter()
        .any(|e| e.kind == "tool_started"));
}

#[tokio::test]
async fn blocked_result_reports_completed_effect_without_exposing_result() {
    use crate::safety::{HandlerRef, Hook, HookPhase};
    let reference = HandlerRef {
        name: "deny".into(),
        version: "1".into(),
    };
    let config = Config {
        hooks: vec![Hook {
            name: "deny".into(),
            version: "1".into(),
            when: HookPhase::AfterTool,
            tools: vec![],
            handler: reference.clone(),
            timeout_ms: 50,
        }],
        ..Default::default()
    };
    let (_tmp, rt, sid) = fixture(config, Model::new("test".into(), true)).await;
    rt.safety_handlers
        .register(reference, Arc::new(Deny))
        .unwrap();
    let result = rt
        .check_tool_result(
            &sid,
            "read_file",
            json!({"content":[{"type":"text","text":"SECRET_SENTINEL"}]}),
        )
        .await
        .unwrap();
    assert_eq!(result["executed"], true);
    assert_eq!(result["outputBlocked"], true);
    assert!(!result.to_string().contains("SECRET_SENTINEL"));
    no_leak(&rt, &sid);
}

#[tokio::test]
async fn transactional_memory_result_is_held_until_inspection_and_recovery_never_replays() {
    use crate::safety::{HandlerRef, Hook, HookPhase};
    let reference = HandlerRef {
        name: "deny".into(),
        version: "1".into(),
    };
    let config = Config {
        hooks: vec![Hook {
            name: "deny".into(),
            version: "1".into(),
            when: HookPhase::AfterTool,
            tools: vec![],
            handler: reference.clone(),
            timeout_ms: 50,
        }],
        ..Default::default()
    };
    let (tmp, rt, sid) = fixture(config, Model::new("test".into(), true)).await;
    rt.safety_handlers
        .register(reference, Arc::new(Deny))
        .unwrap();
    rt.store
        .lock()
        .unwrap()
        .accept(&sid, "memory", "read memory")
        .unwrap();
    let call = json!({"type":"function_call","call_id":"memory-call","name":"memory_read","arguments":"{\"id\":\"m1\"}"});
    let session = rt
        .update(&sid, "fixture", json!({}), |s| {
            s.package.memory = true;
            s.history.push(call.clone());
            let t = s.turn.as_mut().unwrap();
            t.status = "running".into();
            t.queue = vec![call.clone()];
            Ok(())
        })
        .unwrap();
    let scope = crate::assistant_tools::scope(&session);
    let tid = session.turn.unwrap().id;
    let mut bank = crate::assistant_tools::MemoryBank::default();
    bank.entries.insert(
        "m1".into(),
        crate::assistant_tools::Memory {
            id: "m1".into(),
            revision: 1,
            summary: "test".into(),
            content: "SECRET_SENTINEL".into(),
            updated_at: 1,
        },
    );
    let db = rusqlite::Connection::open(tmp.path().join("state/runtime.sqlite3")).unwrap();
    db.execute(
        "INSERT INTO assistant_memories VALUES(?1,?2)",
        rusqlite::params![scope, serde_json::to_string(&bank).unwrap()],
    )
    .unwrap();
    drop(db);
    let candidate = rt
        .store
        .lock()
        .unwrap()
        .assistant_call(&sid, &tid, &call, &json!({"id":"m1"}))
        .unwrap();
    assert!(candidate.data.to_string().contains("SECRET_SENTINEL"));
    no_leak(&rt, &sid);
    assert!(rt
        .store
        .lock()
        .unwrap()
        .metadata(&sid)
        .unwrap()
        .turn
        .unwrap()
        .pending_safety_result
        .is_some());
    let (held, result) = rt
        .release_internal_result(&sid, &call, candidate.data["result"].clone())
        .await
        .unwrap();
    assert!(held);
    assert_eq!(result["outputBlocked"], true);
    no_leak(&rt, &sid);
    let call = json!({"type":"function_call","call_id":"memory-crash","name":"memory_read","arguments":"{\"id\":\"m1\"}"});
    rt.update(&sid, "fixture", json!({}), |s| {
        s.history.push(call.clone());
        s.turn.as_mut().unwrap().queue = vec![call.clone()];
        Ok(())
    })
    .unwrap();
    rt.store
        .lock()
        .unwrap()
        .assistant_call(&sid, &tid, &call, &json!({"id":"m1"}))
        .unwrap();
    rt.store.lock().unwrap().recover().unwrap();
    let s = rt.store.lock().unwrap().get(&sid).unwrap();
    let t = s.turn.unwrap();
    assert!(t.pending_safety_result.is_none() && t.queue.is_empty());
    let output: Value =
        serde_json::from_str(s.history.last().unwrap()["output"].as_str().unwrap()).unwrap();
    assert_eq!(output["executed"], true);
    assert_eq!(output["code"], "INSPECTION_INTERRUPTED");
    no_leak(&rt, &sid);
}

#[tokio::test]
async fn turn_overrides_bind_idempotency_and_do_not_leak_to_the_next_turn() {
    let (_tmp, rt, sid) = fixture(Config::default(), Model::new("test".into(), true)).await;
    let rules = config(Action::Block);
    assert!(rt.dispatch("turn/start",json!({"session_id":sid,"submission_id":"rejected","text":"SECRET_SENTINEL","safety":rules})).await.is_err());
    assert!(!rt
        .store
        .lock()
        .unwrap()
        .has_submission(&sid, "rejected")
        .unwrap());
    let (first, fresh, _) = rt
        .store
        .lock()
        .unwrap()
        .accept_with_safety(&sid, "bound", "safe", None, Some(rules.clone()))
        .unwrap();
    assert!(fresh);
    let (second, fresh, _) = rt
        .store
        .lock()
        .unwrap()
        .accept_with_safety(&sid, "bound", "safe", None, Some(rules.clone()))
        .unwrap();
    assert!(!fresh);
    assert_eq!(first.turn.unwrap().id, second.turn.unwrap().id);
    assert!(rt
        .store
        .lock()
        .unwrap()
        .accept_with_safety(&sid, "bound", "safe", None, None)
        .is_err());
    rt.update(&sid, "turn_completed", json!({"status":"completed"}), |s| {
        s.turn.as_mut().unwrap().status = "completed".into();
        Ok(())
    })
    .unwrap();
    let (next, _, _) = rt
        .store
        .lock()
        .unwrap()
        .accept_with_safety(&sid, "next", "safe", None, None)
        .unwrap();
    assert_eq!(next.turn.unwrap().safety, Config::default());
    no_leak(&rt, &sid);
}

#[tokio::test]
async fn before_model_rejection_has_no_attempt_or_working_model_charge() {
    use crate::safety::{HandlerRef, Hook, HookPhase};
    let reference = HandlerRef {
        name: "deny".into(),
        version: "1".into(),
    };
    let config = Config {
        hooks: vec![Hook {
            name: "deny".into(),
            version: "1".into(),
            when: HookPhase::BeforeModel,
            tools: vec![],
            handler: reference.clone(),
            timeout_ms: 50,
        }],
        ..Default::default()
    };
    let seen = Arc::new(AtomicUsize::new(0));
    let (_tmp, rt, sid) = fixture(config, fake(vec!["should not run"], seen.clone())).await;
    rt.safety_handlers
        .register(reference, Arc::new(Deny))
        .unwrap();
    rt.store
        .lock()
        .unwrap()
        .accept(&sid, "blocked-model", "hello")
        .unwrap();
    let history = rt.store.lock().unwrap().get(&sid).unwrap().history;
    assert!(rt
        .sample(&sid, &history, &[])
        .await
        .unwrap_err()
        .is::<super::safety::Blocked>());
    let db = rt.store.lock().unwrap();
    assert!(db.attempts(&sid).unwrap().is_empty());
    let turn = db.metadata(&sid).unwrap().turn.unwrap();
    assert_eq!(turn.budget.model_calls, 0);
    assert_eq!(turn.budget.charged_output_tokens, 0);
    assert_eq!(seen.load(Ordering::SeqCst), 0);
}

#[tokio::test]
async fn observer_outbox_is_metadata_only_and_does_not_hold_the_agent_turn() {
    use crate::safety::{CheckFuture, Context, Decision, Handler, HandlerRef, Hook, HookPhase};
    struct Observe(Arc<Mutex<Vec<Value>>>);
    impl Handler for Observe {
        fn call(&self, c: Context, _: CancellationToken) -> CheckFuture<'_> {
            Box::pin(async move {
                self.0.lock().unwrap().push(c.context);
                Ok(Decision::Allow)
            })
        }
    }
    let reference = HandlerRef {
        name: "activity".into(),
        version: "1".into(),
    };
    let config = Config {
        hooks: vec![Hook {
            name: "activity".into(),
            version: "1".into(),
            when: HookPhase::OnEvent,
            tools: vec![],
            handler: reference.clone(),
            timeout_ms: 100,
        }],
        ..Default::default()
    };
    let received = Arc::new(Mutex::new(vec![]));
    let (_tmp, rt, sid) = fixture(config, Model::new("test".into(), true)).await;
    rt.safety_handlers
        .register(reference, Arc::new(Observe(received.clone())))
        .unwrap();
    rt.start_observers();
    rt.progress(
        &sid,
        "safety_test",
        json!({"text":"SECRET_SENTINEL","code":"DEMO"}),
    )
    .unwrap();
    tokio::time::timeout(std::time::Duration::from_secs(5), async {
        loop {
            if received
                .lock()
                .unwrap()
                .iter()
                .any(|v| v["event"]["kind"] == "safety_test")
            {
                break;
            }
            tokio::time::sleep(std::time::Duration::from_millis(10)).await;
        }
    })
    .await
    .unwrap();
    let records = received.lock().unwrap().clone();
    assert!(!json!(records).to_string().contains("SECRET_SENTINEL"));
    assert!(records.iter().all(|v| v["eventId"]
        .as_str()
        .unwrap()
        .starts_with(&format!("{sid}:"))));
    rt.shutdown().await.unwrap();
}

#[tokio::test]
async fn guard_model_binding_accepts_key_rotation_but_not_provider_retargeting() {
    use crate::safety::{Detector, ModelRef};
    let (_tmp, rt, sid) = fixture(Config::default(), Model::new("test".into(), true)).await;
    rt.connections
        .register_host(
            "privacy",
            crate::provider::Kind::Openai,
            "privacy-endpoint-v1",
            "fake-one".to_owned().into(),
        )
        .unwrap();
    let config = Config {
        guardrails: Guardrails {
            user_input: vec![Rule {
                name: "spoken-pii".into(),
                version: "1".into(),
                detector: Detector::Model {
                    model: ModelRef::new("privacy", "fixture"),
                    instructions: "Find identifiers".into(),
                },
                action: Action::Block,
                timeout_ms: 100,
            }],
            ..Default::default()
        },
        ..Default::default()
    };
    let pins = rt.pin_safety_models(&config).unwrap();
    rt.update(&sid, "test_policy", json!({}), |s| {
        s.safety = config;
        s.safety_models = pins;
        Ok(())
    })
    .unwrap();
    let saved = rt.store.lock().unwrap().metadata(&sid).unwrap();
    let pinned = saved.safety_models.values().next().unwrap();
    rt.connections
        .register_host(
            "privacy",
            crate::provider::Kind::Openai,
            "privacy-endpoint-v1",
            "fake-two".to_owned().into(),
        )
        .unwrap();
    assert!(rt.connections.key(pinned).is_ok());
    rt.connections
        .register_host(
            "privacy",
            crate::provider::Kind::Openai,
            "different-endpoint",
            "fake-three".to_owned().into(),
        )
        .unwrap();
    assert!(rt.connections.key(pinned).is_err());
    assert_eq!(
        rt.store
            .lock()
            .unwrap()
            .metadata(&sid)
            .unwrap()
            .safety_models
            .values()
            .next()
            .unwrap()
            .identity,
        pinned.identity
    );
}

#[tokio::test]
async fn tool_rules_resolve_registered_qualified_names_without_cross_namespace_matches() {
    let config = Config {
        guardrails: Guardrails {
            tool_results: vec![crate::safety::ToolRules {
                tools: vec!["example-tools.read_file".into()],
                rules: vec![Rule::regex("secret", "SECRET_[A-Z]+", Action::redact())],
            }],
            ..Default::default()
        },
        ..Default::default()
    };
    let (_tmp, rt, sid) = fixture(config, Model::new("test".into(), true)).await;
    assert_eq!(rt.safety_tool_name("read_file"), "example-tools.read_file");
    assert_eq!(
        rt.safety_tool_name("example-tools.read_file"),
        "example-tools.read_file"
    );
    assert_ne!(
        rt.safety_tool_name("other.read_file"),
        "example-tools.read_file"
    );
    let checked = rt
        .check_tool_result(&sid, "read_file", json!({"text":"SECRET_SENTINEL"}))
        .await
        .unwrap();
    assert!(!checked.to_string().contains("SECRET_SENTINEL"));
    assert!(!rt
        .effective_safety(&sid)
        .unwrap()
        .protects(crate::safety::Phase::ToolResult, Some("other.read_file")));
}