Something went wrong. Try again.
Personal fork of prime agent. Mirror of: https://mnemosyne.sigilzero.dev/sigilzero/prime-agent
Something went wrong. Try again.
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694use super::*;use crate::kernel::shared::HostRequestPayload;use crate::session_engine::{ engine::{create_session, SessionEngineConfig}, session_commands::{execute_session_command, SessionCommandParams}, PromptOptions, PromptOutcome,};use pa_agent::scripted::ScriptedProvider;
const ALPHA: &str = r"local observed = 0local started = falselocal tick = 0local function report(input, ctx) return {config=config, identity=ctx.call('session.info', {}), input=input, observed=observed, started=started, tick=tick}endreturn { exports={ {name='report',run=report}, {name='busy',run=function() started=true; while true do tick=tick+1 end end}, {name='unsupported',run=function(input,ctx) return ctx.call('not.supported', {}) end}, {name='null_result',run=function() return null end}, {name='stream',mode='streaming',run=function(input,ctx) ctx.emit('update'); return 'done' end} }, commands={{name='alpha_command',description='Configured alpha command',run=report}}, hooks={{name='turn_settled',run=function(input) assert(input.stage=='turn_settled' and input.message.role=='assistant') assert(input.session~=nil and input.tool_results~=nil) observed=observed+1 return {observed=observed} end}}}";const BETA: &str = r"return {exports={{name='value',run=function(input,ctx) return {configured=config.value,session=ctx.call('session.info', {}).session}end}},commands={{name='beta_command',run=function(input) return input.args end}}}";
struct Fixture { _dir: tempfile::TempDir, cwd: PathBuf, agent: PathBuf, engine: SessionEngine, provider: Arc<ScriptedProvider>,}
impl Fixture { async fn new(alpha: &str) -> Self { let dir = tempfile::tempdir().unwrap(); let cwd = dir.path().join("project"); let agent = dir.path().join("agent"); std::fs::create_dir_all(cwd.join(".prime/agent")).unwrap(); std::fs::create_dir_all(&agent).unwrap(); std::fs::write(agent.join("alpha.lua"), alpha).unwrap(); std::fs::write(agent.join("beta.lua"), BETA).unwrap(); std::fs::write(agent.join("settings.json"), json!({ "enableBuiltinSkills":false,"bundledSkills":{"websearch":false}, "plugins":{ "harness":{"enabled":false}, "alpha":{"enabled":true,"path":"alpha.lua","config":{"value":"global","nested":{"kept":true}}}, "beta":{"enabled":true,"path":"beta.lua","config":{"value":"second"}} } }).to_string()).unwrap(); std::fs::write( cwd.join(".prime/agent/settings.json"), json!({ "plugins":{"alpha":{"config":{"value":"project"}}} }) .to_string(), ) .unwrap(); let model: pa_agent::types::Model = serde_json::from_value(json!({ "id":"test","name":"Test","api":"openai-completions","provider":"test","baseUrl":"http://localhost", "reasoning":false,"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0},"contextWindow":10000,"maxTokens":100 })).unwrap(); let provider = Arc::new(ScriptedProvider::new(model.clone())); let engine = create_session(SessionEngineConfig { cwd: cwd.clone(), agent_dir: agent.clone(), model: Some(model), stream_fn: Some(provider.stream_fn()), prewarm_ipython_kernel: Some(false), daemonless: true, ..Default::default() }) .await .unwrap(); Self { _dir: dir, cwd, agent, engine, provider, } }
fn configure(&self, value: &Value) { let path = self.agent.join("settings.json"); let Some(update) = value.as_object() else { std::fs::write(path, value.to_string()).unwrap(); return; }; let mut document: Value = serde_json::from_str(&std::fs::read_to_string(&path).unwrap_or_default()) .unwrap_or_else(|_| json!({})); if !document.is_object() { document = json!({}); } for (key, entry) in update { if key == "plugins" { let Some(plugins) = entry.as_object() else { document[key] = entry.clone(); continue; }; let target = document .as_object_mut() .unwrap() .entry("plugins") .or_insert_with(|| json!({})); for (name, plugin) in plugins { match (target.get_mut(name), plugin.as_object()) { (Some(existing), Some(fields)) if existing.is_object() => { let existing = existing.as_object_mut().unwrap(); for (field, value) in fields { existing.insert(field.clone(), value.clone()); } } _ => { target[name] = plugin.clone(); } } } } else { document[key] = entry.clone(); } } std::fs::write(path, document.to_string()).unwrap(); }}
async fn request(engine: &SessionEngine, kind: &str, data: Value) -> anyhow::Result<Value> { let handlers = engine.plugin_host_handlers(); let mut data = data; data["type"] = json!(kind); tokio::time::timeout( std::time::Duration::from_secs(5), handlers.get(kind).unwrap()(HostRequestPayload { data }), ) .await .unwrap()}
async fn catalog(engine: &SessionEngine) -> Value { request( engine, "plugin.catalog", json!({"session":engine.session.session_id().await}), ) .await .unwrap()}
fn descriptor(catalog: &Value, plugin: &str, name: &str) -> Value { catalog["exports"] .as_array() .unwrap() .iter() .find(|entry| entry["plugin"] == plugin && entry["name"] == name) .unwrap() .clone()}
fn payload(session: &str, descriptor: &Value, input: Value) -> Value { let mut request = json!({"session":session,"plugin":descriptor["plugin"],"generation":descriptor["generation"],"export":descriptor["name"]}); request["input"] = input; request}
async fn run_export( engine: &SessionEngine, plugin: &str, name: &str, input: Value,) -> anyhow::Result<Value> { let catalog = catalog(engine).await; request( engine, "plugin.invoke", payload( catalog["session"].as_str().unwrap(), &descriptor(&catalog, plugin, name), input, ), ) .await}
async fn history(engine: &SessionEngine) -> Value { json!({"entries":engine.session.entries().await,"messages":engine.session.agent().state().await.messages})}
async fn command( engine: &SessionEngine, text: &str,) -> super::super::session_commands::SessionCommandExecution { let PromptOutcome::SessionCommand(command) = engine.prompt(text, PromptOptions::default()).await.unwrap() else { panic!("not a core session command") }; let model = serde_json::from_value(json!({ "id":"test","name":"Test","api":"openai-completions","provider":"test","baseUrl":"http://localhost", "reasoning":false,"input":["text"],"cost":{"input":0,"output":0,"cacheRead":0,"cacheWrite":0},"contextWindow":10000,"maxTokens":100 })).unwrap(); execute_session_command( engine, &mut SessionCommandParams { model: &model, api_key: None, }, &command, &[], ) .await}
#[tokio::test]async fn configured_plugins_cross_engine_kernel_and_slash_surfaces() { let f = Fixture::new(ALPHA).await; let engine = &f.engine; assert_eq!(engine.plugin_diagnostic(), None); let session = engine.session.session_id().await; let inventory = catalog(engine).await; assert_eq!(inventory["session"], session); assert_eq!(inventory["exports"].as_array().unwrap().len(), 6); let info = run_export(engine, "alpha", "report", json!({"hello":"world"})) .await .unwrap(); assert_eq!( info, json!({"config":{"value":"global","nested":{"kept":true}},"identity":{"session":session,"cwd":f.cwd,"role":"root"},"input":{"hello":"world"},"observed":0,"started":false,"tick":0}) ); assert_eq!( run_export(engine, "beta", "value", json!({})) .await .unwrap(), json!({"configured":"second","session":session}) ); assert_eq!( run_export(engine, "alpha", "null_result", json!({})) .await .unwrap(), Value::Null ); assert!(run_export(engine, "alpha", "unsupported", json!({})) .await .unwrap_err() .to_string() .contains("unsupported plugin capability")); assert!(run_export(engine, "alpha", "stream", json!({})) .await .unwrap_err() .to_string() .contains("streaming")); // A Python tool call can arrive with the session already locked. The production // handler must not reacquire that lock or the enclosing tool turn deadlocks. let lock = engine.session.shared_persistence(); let guard = lock.lock().await; let report = descriptor(&inventory, "alpha", "report"); request( engine, "plugin.invoke", payload(&session, &report, json!({})), ) .await .unwrap(); drop(guard); assert!( request(engine, "plugin.catalog", json!({"session":"foreign"})) .await .is_err() ); let mut wrong = payload(&session, &report, json!({})); wrong["plugin"] = json!("beta"); assert!(request(engine, "plugin.invoke", wrong).await.is_err()); assert!(request( engine, "plugin.invoke", payload(&session, &report, json!([])) ) .await .is_err()); let listed = engine.session.session_command_inventory(); assert!(listed .iter() .any(|entry| entry.name == "alpha_command" && entry.plugin.is_some())); let result = command(engine, "/alpha_command some arguments").await; assert_eq!(result.error, None); assert!(result .messages .last() .unwrap() .content .text() .contains("some arguments")); assert!(f.provider.calls().is_empty()); f.provider.push_text_turn("settled"); engine .prompt("observe this actual turn", PromptOptions::default()) .await .unwrap(); assert_eq!( run_export(engine, "alpha", "report", json!({})) .await .unwrap()["observed"], 1 );}
#[tokio::test]async fn reload_is_atomic_config_sensitive_and_history_neutral() { let f = Fixture::new(ALPHA).await; let engine = &f.engine; let initial = catalog(engine).await; let before = history(engine).await; let result = command(engine, "/reload").await; assert_eq!(result.error, None); assert_eq!(result.messages.iter().skip(1).count(), 1); assert!(result.messages[1] .content .text() .contains("Plugins reloaded")); assert_eq!(catalog(engine).await, initial); assert_eq!(history(engine).await, before); f.configure(&json!({"plugins":{"alpha":{"config":{"value":"changed"}}}})); assert_eq!(command(engine, "/reload").await.error, None); let changed = catalog(engine).await; assert_ne!( descriptor(&changed, "alpha", "report")["generation"], descriptor(&initial, "alpha", "report")["generation"] ); assert_eq!( descriptor(&changed, "beta", "value"), descriptor(&initial, "beta", "value") ); assert_eq!( run_export(engine, "alpha", "report", json!({})) .await .unwrap()["config"]["value"], "changed" ); assert!(request( engine, "plugin.invoke", payload( initial["session"].as_str().unwrap(), &descriptor(&initial, "alpha", "report"), json!({}) ) ) .await .is_err()); // A malformed replacement must preserve the entire previous host, including // the unchanged second plugin. Settings errors must not masquerade as disable. std::fs::write(f.agent.join("alpha.lua"), "not Lua !").unwrap(); assert!(command(engine, "/reload").await.error.is_some()); assert_eq!(catalog(engine).await, changed); assert!(engine.plugin_diagnostic().is_some()); let baseline = std::fs::read_to_string(f.agent.join("settings.json")).unwrap(); for malformed in [Value::Null, json!([])] { f.configure(&malformed); assert!(engine.reload_plugins().await.is_err()); assert_eq!(catalog(engine).await, changed); } std::fs::write(f.agent.join("settings.json"), &baseline).unwrap(); f.configure(&json!({"plugins":{"alpha":{"config":null}}})); assert!(engine.reload_plugins().await.is_err()); assert_eq!(catalog(engine).await, changed); f.configure(&json!({"plugins":"malformed"})); assert!(engine.reload_plugins().await.is_err()); assert_eq!(catalog(engine).await, changed); std::fs::write(f.agent.join("settings.json"), "{malformed").unwrap(); assert!(engine.reload_plugins().await.is_err()); assert_eq!(catalog(engine).await, changed); std::fs::write(f.agent.join("settings.json"), &baseline).unwrap(); f.configure(&json!({"plugins":{"alpha":{"enabled":false}}})); assert_eq!(command(engine, "/reload").await.error, None); let disabled = catalog(engine).await; assert_eq!(disabled["exports"].as_array().unwrap().len(), 1); assert!(!engine .session .session_command_inventory() .iter() .any(|entry| entry.name == "alpha_command")); assert!(engine .session .classify_session_command("/alpha_command") .is_none()); assert_eq!( run_export(engine, "beta", "value", json!({})) .await .unwrap()["configured"], "second" ); assert_eq!(history(engine).await, before); assert_eq!(engine.plugin_diagnostic(), None); // No manager operation deletes files or saved data. assert!(f.agent.join("alpha.lua").is_file()); assert!(f.agent.join("settings.json").is_file());}
#[tokio::test]async fn disable_cancels_active_kernel_work_and_fences_saved_command() { let f = Fixture::new(ALPHA).await; let engine = &f.engine; let before = history(engine).await; let old_command = engine .session .classify_session_command("/alpha_command old") .unwrap(); let initial = catalog(engine).await; let handlers = engine.plugin_host_handlers(); let mut data = payload( initial["session"].as_str().unwrap(), &descriptor(&initial, "alpha", "busy"), json!({}), ); data["type"] = json!("plugin.invoke"); let future = handlers.get("plugin.invoke").unwrap()(HostRequestPayload { data }); let running = tokio::spawn(future); tokio::time::timeout(std::time::Duration::from_secs(5), async { loop { if run_export(engine, "alpha", "report", json!({})) .await .unwrap()["started"] == true { break; } tokio::task::yield_now().await; } }) .await .unwrap(); f.configure(&json!({"plugins":{"alpha":{"enabled":false}}})); engine.reload_plugins().await.unwrap(); assert!( tokio::time::timeout(std::time::Duration::from_secs(5), running) .await .unwrap() .unwrap() .unwrap_err() .to_string() .contains("retired") ); assert!(engine .invoke_plugin_command(old_command.plugin.as_ref().unwrap(), &old_command.args) .await .is_err()); assert!(request( engine, "plugin.invoke", payload( initial["session"].as_str().unwrap(), &descriptor(&initial, "alpha", "report"), json!({}) ) ) .await .is_err()); assert!(!engine .session .session_command_inventory() .iter() .any(|entry| entry.plugin.as_ref().is_some_and(|p| p.plugin == "alpha"))); assert_eq!(history(engine).await, before);}
#[tokio::test]async fn malformed_activation_does_not_kill_normal_startup_and_sessions_are_private() { let bad = Fixture::new("not valid Lua !").await; assert!(bad.engine.plugin_diagnostic().is_some()); assert_eq!(catalog(&bad.engine).await["exports"], json!([])); bad.provider.push_text_turn("normal operation"); bad.engine .prompt("still usable", PromptOptions::default()) .await .unwrap(); let first = Fixture::new(ALPHA).await; let second = Fixture::new(ALPHA).await; assert_ne!( catalog(&first.engine).await["session"], catalog(&second.engine).await["session"] ); first.configure(&json!({"plugins":{"alpha":{"enabled":false}}})); first.engine.reload_plugins().await.unwrap(); assert_eq!( catalog(&second.engine).await["exports"] .as_array() .unwrap() .len(), 6 ); second.configure(&json!({"plugins":{"beta":{"path":"missing.lua"}}})); let prior = catalog(&second.engine).await; assert!(second.engine.reload_plugins().await.is_err()); assert_eq!(catalog(&second.engine).await, prior);}
#[tokio::test]async fn namespace_incompatible_replacement_preserves_native_inventory() { let f = Fixture::new(ALPHA).await; let engine = &f.engine; let before = catalog(engine).await; let baseline = std::fs::read_to_string(f.agent.join("settings.json")).unwrap(); for name in [ "refresh", "inventory", "session", "revision", "async", "await", "class", "return", ] { f.configure(&json!({"plugins":{(name):{"enabled":true,"path":"beta.lua","config":{}}}})); assert!( engine.reload_plugins().await.is_err(), "accepted plugin name {name}" ); assert_eq!(catalog(engine).await, before); } std::fs::write(f.agent.join("settings.json"), &baseline).unwrap(); for name in ["return", "class", "await", "_private"] { std::fs::write( f.agent.join("alpha.lua"), format!("return {{exports={{{{name='{name}',run=function() return true end}}}}}}"), ) .unwrap(); assert!( engine.reload_plugins().await.is_err(), "accepted export name {name}" ); assert_eq!(catalog(engine).await, before); } // Python root-manager names are valid on a plugin view; soft keywords are // valid identifiers. Native command/hook names do not inherit Python bans. std::fs::write(f.agent.join("alpha.lua"),"return {exports={{name='refresh',run=function() return true end},{name='match',run=function() return true end}},commands={{name='class',run=function() return true end}},hooks={{name='return',run=function() return true end}}}").unwrap(); engine.reload_plugins().await.unwrap(); assert_eq!( run_export(engine, "alpha", "refresh", json!({})) .await .unwrap(), json!(true) );}
#[tokio::test]async fn active_inventory_is_a_live_model_prompt_tail_not_canonical_history() { let f = Fixture::new(ALPHA).await; let engine = &f.engine; let base = engine.system_prompt.clone(); let expected = engine.assembled_system_prompt(); assert!(expected.starts_with(&base)); assert!(expected.contains("plugin.alpha.report(**kwargs)")); assert!(expected.contains("plugin.beta.value(**kwargs)")); assert!(!expected.contains("plugin.alpha.stream(**kwargs)")); f.provider.push_text_turn("first"); engine .prompt("first", PromptOptions::default()) .await .unwrap(); assert_eq!( f.provider.calls()[0].system_prompt.as_deref(), Some(expected.as_str()) ); let before = history(engine).await; f.configure(&json!({"plugins":{"alpha":{"enabled":false},"beta":{"enabled":false}}})); engine.reload_plugins().await.unwrap(); assert_eq!(history(engine).await, before); assert_eq!(engine.assembled_system_prompt(), base); f.provider.push_text_turn("second"); engine .prompt("second", PromptOptions::default()) .await .unwrap(); assert_eq!( f.provider.calls()[1].system_prompt.as_deref(), Some(base.as_str()) );}
#[tokio::test]async fn actual_kernel_preimports_refreshes_and_fences_plugin_callables() { tokio::time::timeout(std::time::Duration::from_secs(45), async { use crate::kernel::shared::{ExecuteOptions, ExecuteStatus}; let f = Fixture::new(ALPHA).await; let engine = &f.engine; let before = history(engine).await; let manager = tokio::time::timeout( std::time::Duration::from_secs(30), engine.provisioner.ensure(None, None), ) .await .unwrap() .unwrap(); let persistence = engine.session.shared_persistence(); let session_guard = persistence.lock().await; let first = tokio::time::timeout(std::time::Duration::from_secs(10),manager.execute(r#"import jsonsaved = plugin.alpha.reportassert len(plugin.inventory) == 6assert plugin.session == (await plugin.alpha.report())["identity"]["session"]print(json.dumps({"alpha":await plugin.alpha.report(hello="kernel"),"beta":await plugin.beta.value()}))"#,ExecuteOptions::default())).await.unwrap().unwrap(); drop(session_guard); assert_eq!(first.status, ExecuteStatus::Ok, "{:?}", first.error); let output: Value = serde_json::from_str(first.stdout.trim()).unwrap(); assert_eq!(output["alpha"]["input"], json!({"hello":"kernel"})); assert_eq!(output["alpha"]["config"]["value"], "global"); assert_eq!(output["beta"]["configured"], "second"); assert_eq!( output["alpha"]["identity"]["session"], engine.session.session_id().await ); f.configure(&json!({"plugins":{"alpha":{"config":{"value":"kernel-change"}}}})); engine.reload_plugins().await.unwrap(); let changed = manager .execute( r#"try: await saved()except RuntimeError as error: assert "generation" in str(error)else: raise AssertionError("saved callable silently retargeted")assert (await plugin.alpha.report())["config"]["value"] == "kernel-change"print("NEW_GENERATION_OK")"#, ExecuteOptions::default(), ) .await .unwrap(); assert_eq!(changed.status, ExecuteStatus::Ok, "{:?}", changed.error); assert!(changed.stdout.contains("NEW_GENERATION_OK")); std::fs::write( f.agent.join("alpha.lua"), "return {exports={{name='class',run=function() return true end}}}", ) .unwrap(); assert!(engine.reload_plugins().await.is_err()); let preserved = manager .execute( "assert (await plugin.alpha.report())['config']['value'] == 'kernel-change'", ExecuteOptions::default(), ) .await .unwrap(); assert_eq!(preserved.status, ExecuteStatus::Ok, "{:?}", preserved.error); f.configure(&json!({"plugins":{"alpha":{"enabled":false},"beta":{"enabled":false}}})); engine.reload_plugins().await.unwrap(); std::fs::write(f.agent.join("alpha.lua"), "return {exports={{name='refresh',run=function() return true end},{name='match',run=function() return true end},{name='case',run=function() return true end},{name='type',run=function() return true end}}}").unwrap(); f.configure(&json!({"plugins":{"alpha":{"enabled":true,"path":"alpha.lua"},"beta":{"enabled":true,"path":"beta.lua"}}})); engine.reload_plugins().await.unwrap(); let accepted = manager.execute("assert await plugin.alpha.refresh() is True\nassert await plugin.alpha.match() is True\nassert await plugin.alpha.case() is True\nassert await plugin.alpha.type() is True",ExecuteOptions::default()).await.unwrap(); assert_eq!(accepted.status, ExecuteStatus::Ok, "{:?}", accepted.error); f.configure(&json!({"plugins":{"alpha":{"enabled":false},"beta":{"enabled":false}}})); engine.reload_plugins().await.unwrap(); let disabled = manager .execute( r"assert plugin.inventory == ()assert not hasattr(plugin, 'alpha')assert not hasattr(plugin, 'beta')try: await saved()except RuntimeError: passelse: raise AssertionError('disabled saved callable still works')print('DISABLED_OK')", ExecuteOptions::default(), ) .await .unwrap(); assert_eq!(disabled.status, ExecuteStatus::Ok, "{:?}", disabled.error); assert!(disabled.stdout.contains("DISABLED_OK")); assert_eq!(history(engine).await, before); engine.provisioner.kill(); }).await.expect("real plugin kernel scenario timed out");}