feat: add adaptive plugin editor support

crates/adaptive/src/config.rs

@@ -52,7 +52,7 @@ impl Default for AdaptiveConfig {
 }
 
 /// Shared state configuration consumed by adaptive features that need persistence.
-#[derive(Debug, Clone, Serialize, Deserialize)]
+#[derive(Debug, Clone, Default, Serialize, Deserialize)]
 pub struct StateConfig {
     /// Backend selection for adaptive state.
     pub backend: BackendSpec,
@@ -68,6 +68,12 @@ pub struct BackendSpec {
     pub config: Map<String, Json>,
 }
 
+impl Default for BackendSpec {
+    fn default() -> Self {
+        Self::in_memory()
+    }
+}
+
 impl BackendSpec {
     /// Creates an in-memory backend spec.
     pub fn in_memory() -> Self {
@@ -209,6 +215,127 @@ fn default_acg_priority() -> i32 {
     50
 }
 
+nemo_flow::editor_config! {
+    impl AdaptiveConfig {
+        agent_id => { label: "agent_id", kind: String, optional: true },
+        state => {
+            label: "state",
+            kind: Section,
+            optional: true,
+            nested: StateConfig,
+            default: StateConfig,
+        },
+        telemetry => {
+            label: "telemetry",
+            kind: Section,
+            optional: true,
+            nested: TelemetryComponentConfig,
+            default: TelemetryComponentConfig,
+        },
+        adaptive_hints => {
+            label: "adaptive_hints",
+            kind: Section,
+            optional: true,
+            nested: AdaptiveHintsComponentConfig,
+            default: AdaptiveHintsComponentConfig,
+        },
+        tool_parallelism => {
+            label: "tool_parallelism",
+            kind: Section,
+            optional: true,
+            nested: ToolParallelismComponentConfig,
+            default: ToolParallelismComponentConfig,
+        },
+        acg => {
+            label: "acg",
+            kind: Section,
+            optional: true,
+            nested: AcgComponentConfig,
+            default: AcgComponentConfig,
+        },
+        policy => {
+            label: "policy",
+            kind: Section,
+            nested: ConfigPolicy,
+            default: ConfigPolicy,
+        },
+    }
+}
+
+nemo_flow::editor_config! {
+    impl StateConfig {
+        backend => {
+            label: "backend",
+            kind: Section,
+            nested: BackendSpec,
+            default: BackendSpec,
+        },
+    }
+}
+
+nemo_flow::editor_config! {
+    impl BackendSpec {
+        kind => { label: "kind", kind: Enum, values: ["in_memory", "redis"] },
+        config => { label: "config", kind: Json },
+    }
+}
+
+nemo_flow::editor_config! {
+    impl TelemetryComponentConfig {
+        subscriber_name => { label: "subscriber_name", kind: String, optional: true },
+        learners => { label: "learners", kind: Json },
+    }
+}
+
+nemo_flow::editor_config! {
+    impl AdaptiveHintsComponentConfig {
+        priority => { label: "priority", kind: Integer },
+        break_chain => { label: "break_chain", kind: Boolean },
+        inject_header => { label: "inject_header", kind: Boolean },
+        inject_body_path => { label: "inject_body_path", kind: String },
+    }
+}
+
+nemo_flow::editor_config! {
+    impl ToolParallelismComponentConfig {
+        priority => { label: "priority", kind: Integer },
+        mode => {
+            label: "mode",
+            kind: Enum,
+            values: ["observe_only", "inject_hints", "schedule"],
+        },
+    }
+}
+
+nemo_flow::editor_config! {
+    impl AcgComponentConfig {
+        provider => {
+            label: "provider",
+            kind: Enum,
+            values: ["passthrough", "anthropic", "openai"],
+        },
+        observation_window => { label: "observation_window", kind: Integer },
+        priority => { label: "priority", kind: Integer },
+        stability_thresholds => {
+            label: "stability_thresholds",
+            kind: Section,
+            nested: crate::acg::stability::StabilityThresholds,
+            default: crate::acg::stability::StabilityThresholds,
+        },
+    }
+}
+
+nemo_flow::editor_config! {
+    impl crate::acg::stability::StabilityThresholds {
+        stable_threshold => { label: "stable_threshold", kind: Float },
+        semi_stable_threshold => { label: "semi_stable_threshold", kind: Float },
+        min_observations_for_full_confidence => {
+            label: "min_observations_for_full_confidence",
+            kind: Integer,
+        },
+    }
+}
+
 #[cfg(test)]
 #[path = "../tests/unit/config_tests.rs"]
 mod tests;

crates/adaptive/tests/unit/config_tests.rs

@@ -4,6 +4,7 @@
 //! Unit tests for config in the NeMo Flow adaptive crate.
 
 use super::*;
+use nemo_flow::config_editor::{EditorConfig, EditorFieldKind};
 use serde_json::json;
 
 #[test]
@@ -71,3 +72,50 @@ fn test_component_configs_deserialize_with_default_helpers() {
     assert_eq!(tool_parallelism.priority, 100);
     assert_eq!(tool_parallelism.mode, "observe_only");
 }
+
+#[test]
+fn test_adaptive_editor_schema_covers_canonical_options() {
+    let schema = AdaptiveConfig::editor_schema();
+    let fields = schema
+        .fields
+        .iter()
+        .map(|field| field.name)
+        .collect::<Vec<_>>();
+    assert_eq!(
+        fields,
+        vec![
+            "agent_id",
+            "state",
+            "telemetry",
+            "adaptive_hints",
+            "tool_parallelism",
+            "acg",
+            "policy",
+        ]
+    );
+
+    let state = schema.field("state").unwrap().schema().unwrap();
+    let backend = state.field("backend").unwrap().schema().unwrap();
+    assert_eq!(backend.field("kind").unwrap().kind, EditorFieldKind::Enum);
+    assert_eq!(backend.field("config").unwrap().kind, EditorFieldKind::Json);
+
+    let telemetry = schema.field("telemetry").unwrap().schema().unwrap();
+    assert_eq!(
+        telemetry.field("learners").unwrap().kind,
+        EditorFieldKind::Json
+    );
+
+    let acg = schema.field("acg").unwrap().schema().unwrap();
+    let thresholds = acg.field("stability_thresholds").unwrap().schema().unwrap();
+    assert_eq!(
+        thresholds.field("stable_threshold").unwrap().kind,
+        EditorFieldKind::Float
+    );
+    assert_eq!(
+        thresholds
+            .field("min_observations_for_full_confidence")
+            .unwrap()
+            .kind,
+        EditorFieldKind::Integer
+    );
+}