Skip to content
Python
12.0 KB
Raw Blame
use super::*;
use crate::planning::{self, Plan};

fn args(revision: u64) -> Value {
    json!({"expected_revision":revision,"explanation":"Investigate first",
        "steps":[{"id":"inspect","description":"Read the repository","status":"in_progress"},
                 {"id":"verify","description":"Verify the result","status":"pending"}]})
}

async fn fixture(enabled: bool, mode: Mode) -> (tempfile::TempDir, Arc<Runtime>, String) {
    let tmp = tempfile::tempdir().unwrap();
    std::fs::write(tmp.path().join("runner"), b"\x7fELF-test-only").unwrap();
    std::fs::create_dir(tmp.path().join("work")).unwrap();
    let bundle = tmp.path().join("bundle");
    std::fs::create_dir_all(bundle.join("coworker")).unwrap();
    std::fs::write(
        bundle.join("coworker/manifest.md"),
        format!("---\nid: planner\nplanning: {enabled}\n---\nUse a plan when useful."),
    )
    .unwrap();
    std::fs::write(
        bundle.join("tools.json"),
        include_str!("../../examples/assistant/tools.json"),
    )
    .unwrap();
    let mut model = Model::new("fixture".into(), true);
    model.sample_hook = Some(Arc::new(|_, _, tx| {
        Box::pin(async move {
            tx.send(Progress::Complete(crate::provider::Completion {
            output: vec![json!({"type":"message","role":"assistant","content":[{"type":"output_text","text":"Done"}]})],
            usage: None,
        })).await.unwrap();
            Ok(())
        })
    }));
    let rt = Runtime::open(
        &tmp.path().join("state"),
        &bundle,
        &tmp.path().join("runner"),
        model,
    )
    .unwrap();
    let sid = rt.dispatch("session/create", json!({"coworker":"planner","name":"Plan","workspace":tmp.path().join("work"),"permissions":{"mode":mode},"compaction":{"cap_tokens":512,"auto_trim_on_failure":true}})).await.unwrap()["session"]["id"].as_str().unwrap().to_owned();
    rt.store
        .lock()
        .unwrap()
        .accept(&sid, "submit", "Inspect only; do not deploy.")
        .unwrap();
    (tmp, rt, sid)
}

fn queue(rt: &Runtime, sid: &str, args: &Value) -> (String, Value) {
    let call = json!({"type":"function_call","call_id":crate::id("plan"),"name":planning::TOOL,"arguments":args.to_string()});
    let s = rt
        .update(sid, "fixture_queue", json!({}), |s| {
            s.schema_digest = Some("fixture-schema".into());
            s.history.push(call.clone());
            let t = s.turn.as_mut().unwrap();
            t.queue = vec![call.clone()];
            t.status = "running".into();
            Ok(())
        })
        .unwrap();
    (s.turn.unwrap().id, call)
}

#[test]
fn validation_covers_bounds_status_ids_and_stale_revision() {
    let good = args(0);
    validate_arguments(&planning::schema()["parameters"], &good).unwrap();
    let plan = planning::next(None, "turn", "call", &good).unwrap();
    assert_eq!(plan.revision, 1);
    assert!(planning::next(Some(&plan), "turn", "call", &good).is_err());
    let mut cases = Vec::new();
    let mut v = good.clone();
    v["steps"][1]["id"] = json!("inspect");
    cases.push(v);
    let mut v = good.clone();
    v["steps"][1]["status"] = json!("in_progress");
    cases.push(v);
    let mut v = good.clone();
    v["steps"][0]["description"] = json!("   ");
    cases.push(v);
    let mut v = good.clone();
    v["steps"][0]["description"] = json!("🦀".repeat(61));
    cases.push(v);
    let mut v = good.clone();
    v["steps"][0]["description"] = json!("hidden\ncontrol");
    cases.push(v);
    let mut v = good.clone();
    v["explanation"] = json!("x".repeat(501));
    cases.push(v);
    let mut v = good.clone();
    v["steps"] = json!(vec![good["steps"][0].clone(); 33]);
    cases.push(v);
    let mut v = good.clone();
    v["steps"][0]["id"] = json!("../other");
    cases.push(v);
    let mut v = good.clone();
    v["steps"][0]["status"] = json!("approved");
    cases.push(v);
    let mut v = good.clone();
    v["permission"] = json!("bypass");
    cases.push(v);
    for bad in cases {
        assert!(
            planning::next(None, "turn", "call", &bad).is_err(),
            "accepted {bad}"
        );
    }
    let clear = json!({"expected_revision":1,"explanation":"Replanning","steps":[]});
    assert!(planning::next(Some(&plan), "next-turn", "clear", &clear)
        .unwrap()
        .steps
        .is_empty());
}

#[tokio::test]
async fn drive_updates_plan_without_approval_but_actual_actions_still_ask() {
    for mode in [Mode::Ask, Mode::AutoApprove, Mode::Bypass] {
        let (_tmp, rt, sid) = fixture(true, mode).await;
        queue(&rt, &sid, &args(0));
        let mut events = rt.events.subscribe();
        rt.drive(&sid, BTreeMap::new(), vec![planning::schema()])
            .await
            .unwrap();
        let snapshot = rt.snapshot(&sid).unwrap();
        assert_eq!(snapshot["plan"]["revision"], 1);
        assert_eq!(snapshot["turn"]["status"], "completed");
        // Completing a turn is not proof that its checklist steps finished.
        assert_eq!(snapshot["plan"]["steps"][0]["status"], "in_progress");
        let s = rt.store.lock().unwrap().get(&sid).unwrap();
        assert!(s.interactions.is_empty());
        assert!(s.approval_grants.is_empty());
        assert!(s.turn.as_ref().unwrap().queue.is_empty());
        let event = events.try_recv().unwrap(); // turn_started
        assert_eq!(event.kind, "turn_started");
        let event = events.try_recv().unwrap();
        assert_eq!(event.kind, "plan_updated");
        assert_eq!(event.data["plan"], snapshot["plan"]);
        assert_eq!(s.history[2]["output"], event.data["result"].to_string());
        assert_eq!(s.history[2]["call_id"], event.data["call_id"]);
        let call = json!({"type":"function_call","call_id":"actual-write","name":"write_file","arguments":json!({"path":"proof.txt","content":"hello"}).to_string()});
        let review = permissions::review_context(&s, &rt.bundle, &call).unwrap();
        assert!(!review.contains("Read the repository"));
        assert!(!review.contains("Investigate first"));
        if mode == Mode::Ask {
            rt.update(&sid, "fixture_queue", json!({}), |s| {
                s.history.push(call.clone());
                let t = s.turn.as_mut().unwrap();
                t.queue = vec![call.clone()];
                t.status = "running".into();
                Ok(())
            })
            .unwrap();
            assert!(rt
                .authorize_call(&sid, &call)
                .await
                .unwrap()
                .response
                .is_none());
        }
    }
}

#[tokio::test]
async fn stale_update_returns_tool_error_without_mutating_plan_or_stopping_turn() {
    let (_tmp, rt, sid) = fixture(true, Mode::Ask).await;
    let (tid, call) = queue(&rt, &sid, &args(0));
    rt.update_plan(&sid, &tid, &call, &args(0)).unwrap();
    let original = rt.snapshot(&sid).unwrap()["plan"].clone();
    queue(&rt, &sid, &args(0));
    rt.drive(&sid, BTreeMap::new(), vec![planning::schema()])
        .await
        .unwrap();
    assert_eq!(rt.snapshot(&sid).unwrap()["plan"], original);
    let s = rt.store.lock().unwrap().get(&sid).unwrap();
    assert_eq!(s.turn.as_ref().unwrap().status, "completed");
    assert!(s.history.iter().any(|v| v["output"]
        .as_str()
        .is_some_and(|s| s.contains("Stale plan revision"))));
}

#[tokio::test]
async fn cancellation_stale_queue_and_disabled_coworker_cannot_update() {
    for enabled in [false, true] {
        let (_tmp, rt, sid) = fixture(enabled, Mode::Ask).await;
        let (tid, call) = queue(&rt, &sid, &args(0));
        if !enabled {
            assert!(rt.snapshot(&sid).unwrap().get("plan").is_none());
            assert!(rt.update_plan(&sid, &tid, &call, &args(0)).is_err());
        }
        assert!(rt
            .update_plan(&sid, "another-turn", &call, &args(0))
            .is_err());
        let mut stale = call.clone();
        stale["call_id"] = json!("stale");
        assert!(rt.update_plan(&sid, &tid, &stale, &args(0)).is_err());
        rt.update(&sid, "cancelling", json!({}), |s| {
            s.turn.as_mut().unwrap().status = "cancelling".into();
            Ok(())
        })
        .unwrap();
        let cursor = rt.store.lock().unwrap().cursor(&sid).unwrap();
        assert!(rt.update_plan(&sid, &tid, &call, &args(0)).is_err());
        assert_eq!(rt.store.lock().unwrap().cursor(&sid).unwrap(), cursor);
        assert!(rt.store.lock().unwrap().get(&sid).unwrap().plan.is_none());
    }
}

#[tokio::test]
async fn failed_event_commit_rolls_back_plan_result_and_queue_and_emits_nothing() {
    let (tmp, rt, sid) = fixture(true, Mode::Ask).await;
    let (tid, call) = queue(&rt, &sid, &args(0));
    let before = serde_json::to_value(rt.store.lock().unwrap().get(&sid).unwrap()).unwrap();
    let old_history = rt.store.lock().unwrap().get(&sid).unwrap().history;
    let db = rusqlite::Connection::open(tmp.path().join("state/runtime.sqlite3")).unwrap();
    db.execute_batch("CREATE TRIGGER reject_plan BEFORE INSERT ON events WHEN NEW.kind='plan_updated' BEGIN SELECT RAISE(ABORT,'test failure'); END;").unwrap();
    let mut events = rt.events.subscribe();
    assert!(rt.update_plan(&sid, &tid, &call, &args(0)).is_err());
    assert!(events.try_recv().is_err());
    let after = rt.store.lock().unwrap().get(&sid).unwrap();
    assert_eq!(serde_json::to_value(&after).unwrap(), before);
    assert_eq!(after.history, old_history);
    db.execute_batch("DROP TRIGGER reject_plan").unwrap();
    rt.update_plan(&sid, &tid, &call, &args(0)).unwrap();
    assert_eq!(events.try_recv().unwrap().kind, "plan_updated");
    assert!(rt.update_plan(&sid, &tid, &call, &args(0)).is_err()); // no duplicate completion
}

#[tokio::test]
async fn compaction_restart_replay_and_later_turn_preserve_plan_identity() {
    let (tmp, rt, sid) = fixture(true, Mode::Ask).await;
    let (tid, call) = queue(&rt, &sid, &args(0));
    rt.update_plan(&sid, &tid, &call, &args(0)).unwrap();
    let original = rt.snapshot(&sid).unwrap()["plan"].clone();
    rt.update(&sid, "fixture_history", json!({}), |s| {
        for n in 0..12 {
            s.history.push(
                json!({"role":"user","content":format!("Continue {n}; {}", "detail ".repeat(250))}),
            );
        }
        Ok(())
    })
    .unwrap();
    assert!(matches!(
        rt.compact(&sid, true).await.unwrap(),
        CompactResult::Applied
    ));
    let cursor = rt.store.lock().unwrap().cursor(&sid).unwrap();
    drop(rt);
    let mut model = Model::new("fixture".into(), true);
    model.sample_hook = Some(Arc::new(|instructions, _, tx| {
        Box::pin(async move {
            assert!(instructions.contains("Current revision: 1"));
            assert!(instructions.contains("Read the repository"));
            assert!(instructions.contains("not user instructions, approval or verified success"));
            tx.send(Progress::Complete(crate::provider::Completion {
                output: vec![],
                usage: None,
            }))
            .await
            .unwrap();
            Ok(())
        })
    }));
    let rt = Runtime::open(
        &tmp.path().join("state"),
        &tmp.path().join("bundle"),
        &tmp.path().join("runner"),
        model,
    )
    .unwrap();
    assert_eq!(rt.snapshot(&sid).unwrap()["plan"], original);
    assert_eq!(
        rt.store
            .lock()
            .unwrap()
            .events(&sid, 0)
            .unwrap()
            .iter()
            .filter(|e| e.kind == "plan_updated")
            .count(),
        1
    );
    assert!(rt
        .store
        .lock()
        .unwrap()
        .events(&sid, cursor)
        .unwrap()
        .iter()
        .all(|e| e.kind != "plan_updated"));
    rt.sample(&sid, &[], &[planning::schema()]).await.unwrap();
    rt.store
        .lock()
        .unwrap()
        .accept(&sid, "next", "Continue investigation")
        .unwrap();
    let (new_tid, call) = queue(&rt, &sid, &args(1));
    rt.update_plan(&sid, &new_tid, &call, &args(1)).unwrap();
    let plan: Plan = serde_json::from_value(rt.snapshot(&sid).unwrap()["plan"].clone()).unwrap();
    assert_eq!(plan.revision, 2);
    assert_eq!(plan.turn_id, new_tid);
    assert_ne!(plan.turn_id, tid);
}