Skip to content

The fastest, cheapest, most efficient open-source agent harness. Run more than 500 agents on a $10 VPS.

refactor(doctor): simplify controller function definitions

Steven Enamakel3b857eb9aad0
diff --git a/crates/openhuman-core/src/platform/doctor/mod.rs b/crates/openhuman-core/src/platform/doctor/mod.rs
index a7ba45534a..51c75297d6 100644
--- a/crates/openhuman-core/src/platform/doctor/mod.rs
+++ b/crates/openhuman-core/src/platform/doctor/mod.rs
@@ -8,11 +8,11 @@ pub mod tools;
pub use core::*;
pub use ops as rpc;
pub use ops::*;
+pub(crate) use schemas::all_controller_entries as all_doctor_controller_entries;
pub use schemas::{
all_controller_schemas as all_doctor_controller_schemas,
all_registered_controllers as all_doctor_registered_controllers,
};
-pub(crate) use schemas::all_controller_entries as all_doctor_controller_entries;
#[cfg(test)]
pub(crate) use schemas::doctor_parameter_contracts;
diff --git a/crates/openhuman-core/src/platform/doctor/schemas.rs b/crates/openhuman-core/src/platform/doctor/schemas.rs
index 884abf4cc7..5536484563 100644
--- a/crates/openhuman-core/src/platform/doctor/schemas.rs
+++ b/crates/openhuman-core/src/platform/doctor/schemas.rs
@@ -94,21 +94,11 @@ fn handle_models(ctx: DispatchCtx, params: Map<String, Value>) -> ControllerFutu
}
fn report_controller() -> BoundRegisteredController {
- BoundRegisteredController::after_gate(
- schemas("report"),
- load_config,
- parse_report,
- run_report,
- )
+ BoundRegisteredController::after_gate(schemas("report"), load_config, parse_report, run_report)
}
fn models_controller() -> BoundRegisteredController {
- BoundRegisteredController::after_gate(
- schemas("models"),
- load_config,
- parse_models,
- run_models,
- )
+ BoundRegisteredController::after_gate(schemas("models"), load_config, parse_models, run_models)
}
fn load_config(ctx: DispatchCtx) -> ControllerTask<Config> {
@@ -124,9 +114,7 @@ fn parse_models(params: Map<String, Value>) -> Result<bool, String> {
}
fn run_report(_ctx: DispatchCtx, config: Config, (): ()) -> ControllerFuture {
- Box::pin(async move {
- to_json(crate::platform::doctor::rpc::doctor_report(&config).await?)
- })
+ Box::pin(async move { to_json(crate::platform::doctor::rpc::doctor_report(&config).await?) })
}
fn run_models(_ctx: DispatchCtx, config: Config, use_cache: bool) -> ControllerFuture {
diff --git a/crates/openhuman-core/src/platform/doctor/schemas_tests.rs b/crates/openhuman-core/src/platform/doctor/schemas_tests.rs
index 94e1a62542..b2afb4f8e9 100644
--- a/crates/openhuman-core/src/platform/doctor/schemas_tests.rs
+++ b/crates/openhuman-core/src/platform/doctor/schemas_tests.rs
@@ -38,25 +38,21 @@ fn models_schema_has_optional_use_cache() {
#[test]
fn optional_cache_flag_preserves_missing_null_and_boolean_values() {
for (case, input, expected) in [
- ("missing", None, None),
- ("null", Some(Value::Null), None),
- ("true", Some(Value::Bool(true)), Some(true)),
- ("false", Some(Value::Bool(false)), Some(false)),
+ ("missing", None, true),
+ ("null", Some(Value::Null), true),
+ ("true", Some(Value::Bool(true)), true),
+ ("false", Some(Value::Bool(false)), false),
] {
let mut params = Map::new();
if let Some(input) = input {
params.insert("use_cache".into(), input);
}
- assert_eq!(
- read_optional::<bool>(&params, "use_cache").unwrap(),
- expected,
- "{case}"
- );
+ assert_eq!(parse_models(params).unwrap(), expected, "{case}");
}
}
#[test]
-fn read_optional_errors_on_wrong_type() {
+fn model_parser_rejects_non_boolean_cache_flags() {
for value in [
Value::String("true".into()),
Value::Number(1.into()),
@@ -64,7 +60,7 @@ fn read_optional_errors_on_wrong_type() {
Value::Object(Map::new()),
] {
let params = Map::from_iter([("use_cache".into(), value)]);
- let error = read_optional::<bool>(&params, "use_cache").unwrap_err();
+ let error = parse_models(params).unwrap_err();
assert!(
error.starts_with("invalid 'use_cache':"),
"wrong type error keeps its field prefix: {error}"
@@ -72,6 +68,88 @@ fn read_optional_errors_on_wrong_type() {
}
}
+#[test]
+fn report_parser_ignores_the_entire_parameter_map() {
+ let params = Map::from_iter([
+ ("use_cache".into(), Value::String("wrong type".into())),
+ (
+ "unknown_nested".into(),
+ serde_json::json!({"ignored":[1, false]}),
+ ),
+ ]);
+ parse_report(params).expect("doctor.report ignores every supplied parameter");
+}
+
+async fn runtime_doctor_entries() -> Vec<crate::core::all::ControllerEntry> {
+ use crate::core::runtime::{CoreContext, DomainSet};
+
+ CoreContext::scope(CoreContext::for_test(DomainSet::full(), None), async {
+ crate::core::all::all_registered_controllers()
+ .into_iter()
+ .filter(|entry| entry.schema.namespace == "doctor")
+ .collect()
+ })
+ .await
+}
+
+#[tokio::test]
+async fn doctor_controllers_load_config_before_parsing_and_parse_before_running() {
+ use crate::config::test_env::EnvVarGuard;
+ use crate::core::runtime::{CoreContext, DispatchCtx, DomainSet};
+ use serde_json::json;
+
+ let tmp = tempfile::tempdir().unwrap();
+ std::fs::create_dir(tmp.path().join("config.toml")).unwrap();
+ let _env = EnvVarGuard::workspace_async(tmp.path()).await;
+ let entries = runtime_doctor_entries().await;
+ assert_eq!(entries.len(), 2, "both runtime Doctor entries exist");
+ let ctx = DispatchCtx::new(CoreContext::for_test(DomainSet::full(), None));
+
+ let report = entries
+ .iter()
+ .find(|entry| entry.schema.method_name() == "doctor.report")
+ .expect("runtime doctor.report entry");
+ let report_error = report
+ .invoke(
+ ctx.clone(),
+ Map::from_iter([("unexpected".into(), json!({"ignored":true}))]),
+ )
+ .await
+ .expect_err("invalid config stops diagnostics before the report runner");
+ assert!(
+ report_error.contains("is a directory") || report_error.contains("not a file"),
+ "report config gate error: {report_error}"
+ );
+
+ let models = entries
+ .iter()
+ .find(|entry| entry.schema.method_name() == "doctor.models")
+ .expect("runtime doctor.models entry");
+ let malformed = Map::from_iter([("use_cache".into(), json!("false"))]);
+ let gate_error = models
+ .invoke(ctx, malformed.clone())
+ .await
+ .expect_err("config gate runs before model parameter parsing");
+ assert!(
+ gate_error.contains("is a directory") || gate_error.contains("not a file"),
+ "models config gate error: {gate_error}"
+ );
+ assert!(!gate_error.starts_with("invalid 'use_cache':"));
+
+ let valid_ctx = DispatchCtx::new(CoreContext::for_test_with_config(
+ DomainSet::full(),
+ crate::config::Config::default(),
+ ));
+ let parse_error = models
+ .invoke(valid_ctx, malformed)
+ .await
+ .expect_err("invalid cache flag stops before the model probe runner");
+ assert!(
+ parse_error.starts_with("invalid 'use_cache':"),
+ "models parser error: {parse_error}"
+ );
+}
+
pub(crate) fn doctor_parameter_contracts() -> Vec<crate::core::all::ControllerParamContract> {
use serde_json::json;