From aa3926d474ab8bf47070058579e4891709fd86f6 Mon Sep 17 00:00:00 2001
From: Alexey Puzik <alexey.puzik@devpulse.io>
Date: Wed, 4 Feb 2026 21:12:20 +0200
Subject: [PATCH 01/10] WASM guards WIP

---
 crates/agentgateway/src/mcp/handler.rs        |  55 ++++++
 crates/agentgateway/src/mcp/security/mod.rs   |  58 +++++++
 .../src/mcp/security/native/mod.rs            |  13 ++
 crates/agentgateway/src/mcp/security/wasm.rs  | 163 +++++++++++++++++-
 .../simple-pattern-guard/wit/guard.wit        |   8 +-
 5 files changed, 291 insertions(+), 6 deletions(-)

diff --git a/crates/agentgateway/src/mcp/handler.rs b/crates/agentgateway/src/mcp/handler.rs
index b69a75d10..f39bd4c29 100644
--- a/crates/agentgateway/src/mcp/handler.rs
+++ b/crates/agentgateway/src/mcp/handler.rs
@@ -65,6 +65,61 @@ impl Relay {
 		} else {
 			Some(backend.targets[0].name.to_string())
 		};
+		// Evaluate connection guards BEFORE establishing connections
+		// This allows blocking connections to malicious/unknown servers
+		for target in &backend.targets {
+			// Get server URL from backend (SimpleBackend uses hostport() method)
+			let server_url_string = target.backend.as_ref().map(|b| b.hostport());
+			let server_url = server_url_string.as_deref();
+			let context = crate::mcp::security::GuardContext {
+				server_name: target.name.to_string(),
+				identity: None,
+				metadata: serde_json::Value::Null,
+			};
+
+			match security_guards.evaluate_connection(&target.name, server_url, &context) {
+				Ok(crate::mcp::security::GuardDecision::Allow) => {
+					tracing::debug!(
+						target = %target.name,
+						"Connection guard allowed"
+					);
+				},
+				Ok(crate::mcp::security::GuardDecision::Deny(reason)) => {
+					tracing::warn!(
+						target = %target.name,
+						code = %reason.code,
+						message = %reason.message,
+						"Connection guard denied - blocking connection"
+					);
+					return Err(anyhow::anyhow!(
+						"Connection to {} blocked by security guard: {} - {}",
+						target.name,
+						reason.code,
+						reason.message
+					));
+				},
+				Ok(crate::mcp::security::GuardDecision::Modify(_)) => {
+					// Modify not applicable for connection phase
+					tracing::debug!(
+						target = %target.name,
+						"Connection guard returned Modify (treating as Allow)"
+					);
+				},
+				Err(e) => {
+					tracing::error!(
+						target = %target.name,
+						error = %e,
+						"Connection guard error"
+					);
+					return Err(anyhow::anyhow!(
+						"Connection guard failed for {}: {}",
+						target.name,
+						e
+					));
+				},
+			}
+		}
+
 		Ok(Self {
 			upstreams: Arc::new(upstream::UpstreamGroup::new(client, backend)?),
 			policies,
diff --git a/crates/agentgateway/src/mcp/security/mod.rs b/crates/agentgateway/src/mcp/security/mod.rs
index daea33bda..0b367c704 100644
--- a/crates/agentgateway/src/mcp/security/mod.rs
+++ b/crates/agentgateway/src/mcp/security/mod.rs
@@ -95,6 +95,10 @@ pub enum McpGuardKind {
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
 #[serde(rename_all = "snake_case")]
 pub enum GuardPhase {
+    /// Before establishing connection to MCP server
+    /// Used for server whitelisting, typosquat detection, TLS validation
+    Connection,
+
     /// Before forwarding client request to MCP server
     Request,
 
@@ -398,6 +402,60 @@ impl GuardExecutor {
 		Ok(())
 	}
 
+	/// Execute guards before establishing connection to an MCP server
+	/// Used for server whitelisting, typosquat detection, TLS validation
+	pub fn evaluate_connection(
+		&self,
+		server_name: &str,
+		server_url: Option<&str>,
+		context: &GuardContext,
+	) -> GuardResult {
+		let guards = self.guards.read().expect("guards lock poisoned");
+		tracing::info!(
+			guard_count = guards.len(),
+			server = %server_name,
+			server_url = ?server_url,
+			"GuardExecutor::evaluate_connection called"
+		);
+		for guard_entry in guards.iter() {
+			// Only run guards configured for Connection phase
+			if !guard_entry.config.runs_on.contains(&GuardPhase::Connection) {
+				continue;
+			}
+
+			// Execute guard with timeout
+			let result = self.execute_with_timeout(
+				|| guard_entry.guard.evaluate_connection(server_name, server_url, context),
+				Duration::from_millis(guard_entry.config.timeout_ms),
+				&guard_entry.config,
+			);
+
+			// Handle result based on failure mode
+			match result {
+				Ok(GuardDecision::Allow) => continue,
+				Ok(decision) => return Ok(decision),
+				Err(e) => {
+					match guard_entry.config.failure_mode {
+						FailureMode::FailClosed => {
+							return Err(GuardError::ExecutionError(format!(
+								"Guard {} failed: {}",
+								guard_entry.config.id,
+								e
+							)));
+						},
+						FailureMode::FailOpen => {
+							tracing::warn!("Guard {} failed but continuing due to fail_open: {}",
+								guard_entry.config.id, e);
+							continue;
+						},
+					}
+				},
+			}
+		}
+
+		Ok(GuardDecision::Allow)
+	}
+
 	/// Execute guards on a tools/list response
 	pub fn evaluate_tools_list(
 		&self,
diff --git a/crates/agentgateway/src/mcp/security/native/mod.rs b/crates/agentgateway/src/mcp/security/native/mod.rs
index 8a9d83ad1..1cb767594 100644
--- a/crates/agentgateway/src/mcp/security/native/mod.rs
+++ b/crates/agentgateway/src/mcp/security/native/mod.rs
@@ -21,6 +21,19 @@ use super::{GuardContext, GuardDecision, GuardResult};
 
 /// Common trait for all native guards
 pub trait NativeGuard: Send + Sync {
+    /// Evaluate before establishing connection to an MCP server
+    /// Used for server whitelisting, typosquat detection, TLS validation
+    fn evaluate_connection(
+        &self,
+        server_name: &str,
+        server_url: Option<&str>,
+        context: &GuardContext,
+    ) -> GuardResult {
+        // Default: allow
+        let _ = (server_name, server_url, context);
+        Ok(GuardDecision::Allow)
+    }
+
     /// Evaluate a tools/list response
     fn evaluate_tools_list(
         &self,
diff --git a/crates/agentgateway/src/mcp/security/wasm.rs b/crates/agentgateway/src/mcp/security/wasm.rs
index 3b8686a3c..0647f5f9e 100644
--- a/crates/agentgateway/src/mcp/security/wasm.rs
+++ b/crates/agentgateway/src/mcp/security/wasm.rs
@@ -31,6 +31,13 @@ pub struct WasmGuardConfig {
     #[serde(default = "default_max_memory")]
     pub max_memory: usize,
 
+    /// Maximum WebAssembly stack size (bytes).
+    /// Python WASM components require significantly more stack space (2-4 MB)
+    /// due to the embedded Python interpreter.
+    /// Default: 2 MB (sufficient for most Python guards)
+    #[serde(default = "default_max_wasm_stack")]
+    pub max_wasm_stack: usize,
+
     /// Timeout for guard execution (milliseconds)
     #[serde(default = "default_timeout_ms")]
     pub timeout_ms: u64,
@@ -44,10 +51,36 @@ fn default_max_memory() -> usize {
     10 * 1024 * 1024 // 10 MB
 }
 
+fn default_max_wasm_stack() -> usize {
+    2 * 1024 * 1024 // 2 MB - sufficient for Python WASM guards
+}
+
 fn default_timeout_ms() -> u64 {
     100
 }
 
+/// Run a closure on a thread with a large stack.
+/// Python WASM components require significant native stack space that exceeds
+/// the default thread stack size, especially on Windows where the main thread
+/// stack cannot be grown dynamically.
+/// Uses scoped threads to avoid 'static lifetime requirements.
+#[cfg(feature = "wasm-guards")]
+fn run_with_large_stack<F, T>(stack_size: usize, f: F) -> T
+where
+    F: FnOnce() -> T + Send,
+    T: Send,
+{
+    std::thread::scope(|scope| {
+        scope
+            .spawn(|| {
+                // Grow the stack on this thread before executing
+                stacker::grow(stack_size, f)
+            })
+            .join()
+            .expect("WASM thread panicked")
+    })
+}
+
 /// State stored in the wasmtime Store for host functions
 #[cfg(feature = "wasm-guards")]
 struct WasmState {
@@ -120,15 +153,24 @@ impl WasmGuard {
         // Configure wasmtime engine
         let mut engine_config = Config::new();
         engine_config.wasm_component_model(true);
+        // Set maximum WASM stack size - Python WASM components require larger stacks
+        // due to the embedded interpreter
+        engine_config.max_wasm_stack(config.max_wasm_stack);
 
         let engine = Engine::new(&engine_config).map_err(|e| {
             GuardError::WasmError(format!("Failed to create wasmtime engine: {}", e))
         })?;
 
         // Load and compile the WASM component
-        let component = Component::from_file(&engine, expanded_path.as_ref()).map_err(|e| {
-            GuardError::WasmError(format!("Failed to load WASM component: {}", e))
-        })?;
+        // Python WASM components require significant native stack space during compilation
+        // due to the embedded interpreter. On Windows, the main thread stack cannot be grown,
+        // so we spawn a dedicated thread with a large stack (8MB) for compilation.
+        let path_for_thread = expanded_path.to_string();
+        let engine_clone = engine.clone();
+        let component = run_with_large_stack(8 * 1024 * 1024, move || {
+            Component::from_file(&engine_clone, &path_for_thread)
+        })
+        .map_err(|e| GuardError::WasmError(format!("Failed to load WASM component: {}", e)))?;
 
         tracing::info!(
             guard_id = %guard_id,
@@ -263,6 +305,20 @@ impl WasmGuard {
                         )))
                     }
                 }
+                "warn" => {
+                    // Warn means allow but log the warnings
+                    if let Some(Val::List(warnings)) = payload.as_deref() {
+                        for warning in warnings {
+                            if let Val::String(msg) = warning {
+                                tracing::warn!(
+                                    warning = %msg,
+                                    "WASM guard returned warning"
+                                );
+                            }
+                        }
+                    }
+                    Ok(GuardDecision::Allow)
+                }
                 _ => Err(GuardError::WasmError(format!(
                     "Unknown decision variant: {}",
                     name
@@ -319,7 +375,7 @@ impl WasmGuard {
         }
     }
 
-    /// Execute the guard with timeout protection
+    /// Execute the guard with timeout protection and sufficient stack space
     fn execute_with_timeout<F>(&self, f: F) -> GuardResult
     where
         F: FnOnce() -> GuardResult,
@@ -327,7 +383,10 @@ impl WasmGuard {
         // For synchronous execution, we use a simple approach
         // In production, this could be enhanced with proper async timeout
         let start = std::time::Instant::now();
-        let result = f();
+        // Python WASM components require significant native stack space due to the
+        // embedded interpreter. Use stacker to grow the native stack when needed.
+        // Use stacker::grow to force allocation of a large stack segment (8MB).
+        let result = stacker::grow(8 * 1024 * 1024, f);
         let elapsed = start.elapsed();
 
         if elapsed.as_millis() as u64 > self.config.timeout_ms {
@@ -430,6 +489,7 @@ impl NativeGuard for WasmGuard {
             // Build context as WIT record
             let context_record = Val::Record(vec![
                 ("server-name".into(), Val::String(context.server_name.clone().into())),
+                ("server-url".into(), Val::Option(None)), // Not applicable for tools_list evaluation
                 (
                     "identity".into(),
                     match &context.identity {
@@ -493,6 +553,95 @@ impl NativeGuard for WasmGuard {
         Ok(GuardDecision::Allow)
     }
 
+    fn evaluate_connection(
+        &self,
+        server_name: &str,
+        server_url: Option<&str>,
+        context: &GuardContext,
+    ) -> GuardResult {
+        self.execute_with_timeout(|| {
+            tracing::debug!(
+                guard_id = %self.guard_id,
+                server = %server_name,
+                server_url = ?server_url,
+                "Evaluating connection with WASM guard"
+            );
+
+            let linker = self.create_linker()?;
+            let state = WasmState::new(self.config.config.clone());
+            let mut store = Store::new(&self.engine, state);
+
+            // Instantiate the component
+            let instance = linker
+                .instantiate(&mut store, &self.component)
+                .map_err(|e| GuardError::WasmError(format!("Failed to instantiate component: {}", e)))?;
+
+            // Get the exported function from the guard interface
+            let guard_export_idx = instance
+                .get_export(&mut store, None, "mcp:security-guard/guard@0.1.0")
+                .ok_or_else(|| {
+                    GuardError::WasmError(
+                        "Guard interface not found in component exports".to_string(),
+                    )
+                })?;
+
+            // Get the evaluate-server-connection function
+            let func_export_idx = instance
+                .get_export(&mut store, Some(&guard_export_idx), "evaluate-server-connection")
+                .ok_or_else(|| {
+                    GuardError::WasmError(
+                        "Function evaluate-server-connection not found in guard interface".to_string(),
+                    )
+                })?;
+
+            let func = instance
+                .get_func(&mut store, &func_export_idx)
+                .ok_or_else(|| {
+                    GuardError::WasmError(
+                        "Could not get function from export index".to_string(),
+                    )
+                })?;
+
+            // Build context as WIT record with server_url
+            let context_record = Val::Record(vec![
+                ("server-name".into(), Val::String(context.server_name.clone().into())),
+                (
+                    "server-url".into(),
+                    match server_url {
+                        Some(url) => Val::Option(Some(Box::new(Val::String(url.to_string().into())))),
+                        None => Val::Option(None),
+                    },
+                ),
+                (
+                    "identity".into(),
+                    match &context.identity {
+                        Some(id) => Val::Option(Some(Box::new(Val::String(id.clone().into())))),
+                        None => Val::Option(None),
+                    },
+                ),
+                (
+                    "metadata".into(),
+                    Val::String(
+                        serde_json::to_string(&context.metadata)
+                            .unwrap_or_else(|_| "{}".to_string())
+                            .into(),
+                    ),
+                ),
+            ]);
+
+            // Call the function
+            let mut results = vec![Val::Bool(false)]; // Placeholder for result
+            func.call(&mut store, &[context_record], &mut results)
+                .map_err(|e| GuardError::WasmError(format!("WASM function call failed: {}", e)))?;
+
+            // Post-call cleanup
+            func.post_return(&mut store)
+                .map_err(|e| GuardError::WasmError(format!("WASM post-return failed: {}", e)))?;
+
+            Self::parse_decision(&results)
+        })
+    }
+
     fn reset_server(&self, server_name: &str) {
         // WASM guards are stateless by design - no per-server state to reset
         tracing::debug!(
@@ -525,6 +674,7 @@ mod tests {
         let invalid_config = WasmGuardConfig {
             module_path: String::new(),
             max_memory: 1024 * 1024,
+            max_wasm_stack: default_max_wasm_stack(),
             timeout_ms: 100,
             config: HashMap::new(),
         };
@@ -538,6 +688,7 @@ mod tests {
         let valid_config = WasmGuardConfig {
             module_path: "/path/to/probe.wasm".to_string(),
             max_memory: 10 * 1024 * 1024,
+            max_wasm_stack: default_max_wasm_stack(),
             timeout_ms: 100,
             config: HashMap::new(),
         };
@@ -559,6 +710,7 @@ mod tests {
     #[test]
     fn test_default_config_values() {
         assert_eq!(default_max_memory(), 10 * 1024 * 1024);
+        assert_eq!(default_max_wasm_stack(), 2 * 1024 * 1024);
         assert_eq!(default_timeout_ms(), 100);
     }
 
@@ -647,6 +799,7 @@ module_path: ./guards/test.wasm
         let config = WasmGuardConfig {
             module_path: wasm_path.to_str().unwrap().to_string(),
             max_memory: 10 * 1024 * 1024,
+            max_wasm_stack: default_max_wasm_stack(),
             timeout_ms: 1000,
             config: HashMap::new(), // Use default patterns
         };
diff --git a/examples/wasm-guards/simple-pattern-guard/wit/guard.wit b/examples/wasm-guards/simple-pattern-guard/wit/guard.wit
index 2fc28bc13..07c9085d2 100644
--- a/examples/wasm-guards/simple-pattern-guard/wit/guard.wit
+++ b/examples/wasm-guards/simple-pattern-guard/wit/guard.wit
@@ -20,6 +20,7 @@ interface guard {
     /// Context provided by the host
     record guard-context {
         server-name: string,
+        server-url: option<string>,  /// URL of the MCP server (for connection validation)
         identity: option<string>,
         metadata: string,  /// JSON-serialized metadata
     }
@@ -28,7 +29,8 @@ interface guard {
     variant decision {
         allow,
         deny(deny-reason),
-        modify(string),  /// JSON-serialized modification
+        modify(string),  /// JSON-serialized modification (for PII masking, etc.)
+        warn(list<string>),  /// Allow with warnings
     }
 
     /// Reason for denying a request
@@ -41,6 +43,10 @@ interface guard {
     /// Main guard evaluation function
     /// Called by the host for every tools/list response
     evaluate-tools-list: func(tools: list<tool>, context: guard-context) -> result<decision, string>;
+
+    /// Evaluate server connection before establishing
+    /// Called by the host before connecting to an MCP server
+    evaluate-server-connection: func(context: guard-context) -> result<decision, string>;
 }
 
 /// Host interface - functions provided by AgentGateway to the WASM module

From 652bf4bdb0dd0c3748f9deb010bd6e98d547e61c Mon Sep 17 00:00:00 2001
From: Alexey Puzik <alexey.puzik@devpulse.io>
Date: Thu, 5 Feb 2026 14:05:49 +0200
Subject: [PATCH 02/10] Expose UI for wasm guards WIP

---
 .../simple-pattern-guard/src/lib.rs           |  63 +++
 .../simple-pattern-guard/wit/guard.wit        |   9 +
 ui/src/components/policy/form-renderers.tsx   |  33 +-
 ui/src/components/schema-form/SchemaField.tsx |  90 ++++
 ui/src/components/schema-form/SchemaForm.tsx  | 185 ++++++++
 .../schema-form/fields/CheckboxField.tsx      |  45 ++
 .../schema-form/fields/InputField.tsx         |  68 +++
 .../schema-form/fields/KeyValueField.tsx      | 102 +++++
 .../schema-form/fields/MultiselectField.tsx   |  68 +++
 .../schema-form/fields/ObjectArrayField.tsx   | 192 ++++++++
 .../schema-form/fields/SelectField.tsx        |  74 +++
 .../schema-form/fields/SliderField.tsx        |  93 ++++
 .../schema-form/fields/TagsField.tsx          | 100 +++++
 .../schema-form/fields/TextareaField.tsx      |  47 ++
 ui/src/components/schema-form/index.ts        |  21 +
 ui/src/hooks/useGuardSchemas.ts               | 379 ++++++++++++++++
 ui/src/lib/guard-schema-types.ts              | 421 ++++++++++++++++++
 17 files changed, 1982 insertions(+), 8 deletions(-)
 create mode 100644 ui/src/components/schema-form/SchemaField.tsx
 create mode 100644 ui/src/components/schema-form/SchemaForm.tsx
 create mode 100644 ui/src/components/schema-form/fields/CheckboxField.tsx
 create mode 100644 ui/src/components/schema-form/fields/InputField.tsx
 create mode 100644 ui/src/components/schema-form/fields/KeyValueField.tsx
 create mode 100644 ui/src/components/schema-form/fields/MultiselectField.tsx
 create mode 100644 ui/src/components/schema-form/fields/ObjectArrayField.tsx
 create mode 100644 ui/src/components/schema-form/fields/SelectField.tsx
 create mode 100644 ui/src/components/schema-form/fields/SliderField.tsx
 create mode 100644 ui/src/components/schema-form/fields/TagsField.tsx
 create mode 100644 ui/src/components/schema-form/fields/TextareaField.tsx
 create mode 100644 ui/src/components/schema-form/index.ts
 create mode 100644 ui/src/hooks/useGuardSchemas.ts
 create mode 100644 ui/src/lib/guard-schema-types.ts

diff --git a/examples/wasm-guards/simple-pattern-guard/src/lib.rs b/examples/wasm-guards/simple-pattern-guard/src/lib.rs
index 67f13464b..aa875726a 100644
--- a/examples/wasm-guards/simple-pattern-guard/src/lib.rs
+++ b/examples/wasm-guards/simple-pattern-guard/src/lib.rs
@@ -88,6 +88,69 @@ impl Guest for SimplePatternGuard {
         log_info("All tools passed pattern check");
         Ok(Decision::Allow)
     }
+
+    fn evaluate_server_connection(context: GuardContext) -> Result<Decision, String> {
+        // This guard focuses on tool patterns, so we allow all connections
+        log_info(&format!(
+            "Allowing connection to server '{}'",
+            context.server_name
+        ));
+        Ok(Decision::Allow)
+    }
+
+    fn get_settings_schema() -> String {
+        serde_json::json!({
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "$id": "agentgateway://guards/simple-pattern/v1",
+            "title": "Simple Pattern Guard",
+            "description": "Blocks tools matching configurable patterns in name or description",
+            "type": "object",
+            "properties": {
+                "blocked_patterns": {
+                    "type": "array",
+                    "title": "Blocked Patterns",
+                    "description": "List of substrings to block (case-insensitive)",
+                    "items": { "type": "string" },
+                    "default": ["delete", "rm -rf", "drop table", "eval", "exec"],
+                    "x-ui": {
+                        "component": "tags",
+                        "placeholder": "Enter pattern and press Enter",
+                        "order": 1
+                    }
+                },
+                "scan_descriptions": {
+                    "type": "boolean",
+                    "title": "Scan Descriptions",
+                    "description": "Also check tool descriptions for blocked patterns",
+                    "default": true,
+                    "x-ui": { "order": 2 }
+                },
+                "max_tool_count": {
+                    "type": "integer",
+                    "title": "Max Tool Count",
+                    "description": "Maximum allowed tools per server (0 = unlimited)",
+                    "default": 0,
+                    "minimum": 0,
+                    "x-ui": { "order": 3, "advanced": true }
+                }
+            },
+            "x-guard-meta": {
+                "guardType": "simple_pattern",
+                "version": "1.0.0",
+                "category": "detection",
+                "defaultRunsOn": ["tools_list"],
+                "icon": "filter"
+            }
+        }).to_string()
+    }
+
+    fn get_default_config() -> String {
+        serde_json::json!({
+            "blocked_patterns": ["delete", "rm -rf", "drop table", "eval", "exec"],
+            "scan_descriptions": true,
+            "max_tool_count": 0
+        }).to_string()
+    }
 }
 
 // Helper: Get blocked patterns from config or use defaults
diff --git a/examples/wasm-guards/simple-pattern-guard/wit/guard.wit b/examples/wasm-guards/simple-pattern-guard/wit/guard.wit
index 07c9085d2..0df40fe37 100644
--- a/examples/wasm-guards/simple-pattern-guard/wit/guard.wit
+++ b/examples/wasm-guards/simple-pattern-guard/wit/guard.wit
@@ -47,6 +47,15 @@ interface guard {
     /// Evaluate server connection before establishing
     /// Called by the host before connecting to an MCP server
     evaluate-server-connection: func(context: guard-context) -> result<decision, string>;
+
+    /// Get JSON Schema describing guard's configurable parameters
+    /// Returns JSON-serialized JSON Schema (Draft 2020-12)
+    /// Schema describes guard-specific settings only (not common settings like priority, timeout)
+    get-settings-schema: func() -> string;
+
+    /// Get default configuration as JSON
+    /// Returns JSON-serialized default config values
+    get-default-config: func() -> string;
 }
 
 /// Host interface - functions provided by AgentGateway to the WASM module
diff --git a/ui/src/components/policy/form-renderers.tsx b/ui/src/components/policy/form-renderers.tsx
index 54054f312..3e58327ba 100644
--- a/ui/src/components/policy/form-renderers.tsx
+++ b/ui/src/components/policy/form-renderers.tsx
@@ -11,9 +11,10 @@ import {
   SelectValue,
 } from "@/components/ui/select";
 import { RadioGroup, RadioGroupItem } from "@/components/ui/radio-group";
-import { Trash2, Plus } from "lucide-react";
+import { Trash2, Plus, Wand2 } from "lucide-react";
 import { formatArrayForInput, handleNumberArrayInput } from "@/lib/policy-utils";
 import { McpAuthorizationRule } from "@/lib/types";
+import { MCP_CORS_DEFAULTS } from "@/lib/policy-defaults";
 import {
   ArrayInput,
   TargetInput,
@@ -86,15 +87,31 @@ export function renderJwtAuthForm({ data, onChange }: FormRendererProps) {
 }
 
 export function renderCorsForm({ data, onChange }: FormRendererProps) {
+  const applyMcpDefaults = () => {
+    onChange({ ...MCP_CORS_DEFAULTS });
+  };
+
   return (
     <div className="space-y-6">
-      <div className="flex items-center space-x-2">
-        <Checkbox
-          id="allowCredentials"
-          checked={data.allowCredentials || false}
-          onCheckedChange={(checked: boolean) => onChange({ ...data, allowCredentials: checked })}
-        />
-        <Label htmlFor="allowCredentials">Allow Credentials</Label>
+      <div className="flex items-center justify-between">
+        <div className="flex items-center space-x-2">
+          <Checkbox
+            id="allowCredentials"
+            checked={data.allowCredentials || false}
+            onCheckedChange={(checked: boolean) => onChange({ ...data, allowCredentials: checked })}
+          />
+          <Label htmlFor="allowCredentials">Allow Credentials</Label>
+        </div>
+        <Button
+          type="button"
+          variant="outline"
+          size="sm"
+          onClick={applyMcpDefaults}
+          className="flex items-center gap-2"
+        >
+          <Wand2 className="h-4 w-4" />
+          Set MCP Defaults
+        </Button>
       </div>
 
       <ArrayInput
diff --git a/ui/src/components/schema-form/SchemaField.tsx b/ui/src/components/schema-form/SchemaField.tsx
new file mode 100644
index 000000000..e40eee1b8
--- /dev/null
+++ b/ui/src/components/schema-form/SchemaField.tsx
@@ -0,0 +1,90 @@
+/**
+ * SchemaField - Routes schema properties to appropriate field components
+ */
+
+import {
+  type SchemaProperty,
+  inferUIComponent,
+} from "@/lib/guard-schema-types";
+import { InputField } from "./fields/InputField";
+import { CheckboxField } from "./fields/CheckboxField";
+import { SelectField } from "./fields/SelectField";
+import { SliderField } from "./fields/SliderField";
+import { TagsField } from "./fields/TagsField";
+import { MultiselectField } from "./fields/MultiselectField";
+import { ObjectArrayField } from "./fields/ObjectArrayField";
+import { KeyValueField } from "./fields/KeyValueField";
+import { TextareaField } from "./fields/TextareaField";
+
+export interface SchemaFieldProps {
+  /** Field name (property key) */
+  name: string;
+
+  /** Schema definition for this field */
+  schema: SchemaProperty;
+
+  /** Current value */
+  value: unknown;
+
+  /** Change handler */
+  onChange: (value: unknown) => void;
+
+  /** Error message */
+  error?: string;
+
+  /** Disable the field */
+  disabled?: boolean;
+}
+
+/**
+ * Routes a schema property to the appropriate field component
+ */
+export function SchemaField({
+  name,
+  schema,
+  value,
+  onChange,
+  error,
+  disabled = false,
+}: SchemaFieldProps) {
+  const component = inferUIComponent(schema);
+
+  const commonProps = {
+    name,
+    schema,
+    value,
+    onChange,
+    error,
+    disabled,
+  };
+
+  switch (component) {
+    case "checkbox":
+      return <CheckboxField {...commonProps} value={value as boolean} />;
+
+    case "select":
+      return <SelectField {...commonProps} value={value as string | number} />;
+
+    case "slider":
+      return <SliderField {...commonProps} value={value as number} />;
+
+    case "tags":
+      return <TagsField {...commonProps} value={value as string[]} />;
+
+    case "multiselect":
+      return <MultiselectField {...commonProps} value={value as string[]} />;
+
+    case "object-array":
+      return <ObjectArrayField {...commonProps} value={value as Record<string, unknown>[]} />;
+
+    case "key-value":
+      return <KeyValueField {...commonProps} value={value as Record<string, string>} />;
+
+    case "textarea":
+      return <TextareaField {...commonProps} value={value as string} />;
+
+    case "input":
+    default:
+      return <InputField {...commonProps} />;
+  }
+}
diff --git a/ui/src/components/schema-form/SchemaForm.tsx b/ui/src/components/schema-form/SchemaForm.tsx
new file mode 100644
index 000000000..ef972558e
--- /dev/null
+++ b/ui/src/components/schema-form/SchemaForm.tsx
@@ -0,0 +1,185 @@
+/**
+ * SchemaForm - Dynamic form generator from JSON Schema
+ *
+ * This component renders a form based on a JSON Schema definition,
+ * automatically selecting appropriate field components based on type
+ * and UI hints.
+ */
+
+import { useMemo, useState } from "react";
+import {
+  type GuardSettingsSchema,
+  type SchemaProperty,
+  getSortedProperties,
+  getGroupedProperties,
+} from "@/lib/guard-schema-types";
+import { SchemaField } from "./SchemaField";
+import {
+  Collapsible,
+  CollapsibleContent,
+  CollapsibleTrigger,
+} from "@/components/ui/collapsible";
+import { Button } from "@/components/ui/button";
+import { ChevronDown, ChevronRight } from "lucide-react";
+
+interface SchemaFormProps {
+  /** JSON Schema defining the form fields */
+  schema: GuardSettingsSchema;
+
+  /** Current form values */
+  value: Record<string, unknown>;
+
+  /** Callback when any value changes */
+  onChange: (value: Record<string, unknown>) => void;
+
+  /** Validation errors by field path */
+  errors?: Record<string, string>;
+
+  /** Show advanced fields by default */
+  showAdvanced?: boolean;
+
+  /** Disable all fields */
+  disabled?: boolean;
+}
+
+/**
+ * Dynamic form component that renders fields from a JSON Schema
+ */
+export function SchemaForm({
+  schema,
+  value,
+  onChange,
+  errors = {},
+  showAdvanced = false,
+  disabled = false,
+}: SchemaFormProps) {
+  const [advancedExpanded, setAdvancedExpanded] = useState(showAdvanced);
+
+  // Group properties by their x-ui.group value
+  const groupedProperties = useMemo(() => getGroupedProperties(schema), [schema]);
+
+  // Get group definitions from schema
+  const groupDefs = schema["x-ui-groups"] || {};
+
+  // Sort groups by their order
+  const sortedGroups = useMemo(() => {
+    const groups = Array.from(groupedProperties.keys());
+    return groups.sort((a, b) => {
+      const orderA = a ? groupDefs[a]?.order ?? 999 : 0;
+      const orderB = b ? groupDefs[b]?.order ?? 999 : 0;
+      return orderA - orderB;
+    });
+  }, [groupedProperties, groupDefs]);
+
+  // Separate advanced fields
+  const { regularFields, advancedFields } = useMemo(() => {
+    const regular: Array<[string, SchemaProperty]> = [];
+    const advanced: Array<[string, SchemaProperty]> = [];
+
+    for (const [key, prop] of getSortedProperties(schema)) {
+      if (prop["x-ui"]?.advanced) {
+        advanced.push([key, prop]);
+      } else {
+        regular.push([key, prop]);
+      }
+    }
+
+    return { regularFields: regular, advancedFields: advanced };
+  }, [schema]);
+
+  const handleFieldChange = (key: string, newValue: unknown) => {
+    onChange({ ...value, [key]: newValue });
+  };
+
+  const renderField = (key: string, prop: SchemaProperty) => (
+    <SchemaField
+      key={key}
+      name={key}
+      schema={prop}
+      value={value[key] ?? prop.default}
+      onChange={(newValue) => handleFieldChange(key, newValue)}
+      error={errors[key]}
+      disabled={disabled}
+    />
+  );
+
+  // Check if we're using groups
+  const hasGroups = sortedGroups.some((g) => g !== undefined);
+
+  if (hasGroups) {
+    return (
+      <div className="space-y-6">
+        {sortedGroups.map((groupName) => {
+          const groupProps = groupedProperties.get(groupName) || [];
+          const groupDef = groupName ? groupDefs[groupName] : null;
+
+          // Separate regular and advanced within group
+          const regular = groupProps.filter(([, p]) => !p["x-ui"]?.advanced);
+          const advanced = groupProps.filter(([, p]) => p["x-ui"]?.advanced);
+
+          if (regular.length === 0 && advanced.length === 0) return null;
+
+          return (
+            <div key={groupName ?? "default"} className="space-y-4">
+              {groupDef && (
+                <div className="border-b pb-2">
+                  <h4 className="text-sm font-medium">{groupDef.title}</h4>
+                  {groupDef.description && (
+                    <p className="text-xs text-muted-foreground mt-1">
+                      {groupDef.description}
+                    </p>
+                  )}
+                </div>
+              )}
+              <div className="space-y-4 pl-1">
+                {regular.map(([key, prop]) => renderField(key, prop))}
+              </div>
+              {advanced.length > 0 && (
+                <Collapsible open={advancedExpanded} onOpenChange={setAdvancedExpanded}>
+                  <CollapsibleTrigger asChild>
+                    <Button variant="ghost" size="sm" className="text-xs text-muted-foreground">
+                      {advancedExpanded ? (
+                        <ChevronDown className="h-3 w-3 mr-1" />
+                      ) : (
+                        <ChevronRight className="h-3 w-3 mr-1" />
+                      )}
+                      Advanced options ({advanced.length})
+                    </Button>
+                  </CollapsibleTrigger>
+                  <CollapsibleContent className="space-y-4 pl-1 pt-2">
+                    {advanced.map(([key, prop]) => renderField(key, prop))}
+                  </CollapsibleContent>
+                </Collapsible>
+              )}
+            </div>
+          );
+        })}
+      </div>
+    );
+  }
+
+  // No groups - render flat list
+  return (
+    <div className="space-y-4">
+      {regularFields.map(([key, prop]) => renderField(key, prop))}
+
+      {advancedFields.length > 0 && (
+        <Collapsible open={advancedExpanded} onOpenChange={setAdvancedExpanded}>
+          <CollapsibleTrigger asChild>
+            <Button variant="ghost" size="sm" className="text-xs text-muted-foreground">
+              {advancedExpanded ? (
+                <ChevronDown className="h-3 w-3 mr-1" />
+              ) : (
+                <ChevronRight className="h-3 w-3 mr-1" />
+              )}
+              Advanced options ({advancedFields.length})
+            </Button>
+          </CollapsibleTrigger>
+          <CollapsibleContent className="space-y-4 pt-2">
+            {advancedFields.map(([key, prop]) => renderField(key, prop))}
+          </CollapsibleContent>
+        </Collapsible>
+      )}
+    </div>
+  );
+}
diff --git a/ui/src/components/schema-form/fields/CheckboxField.tsx b/ui/src/components/schema-form/fields/CheckboxField.tsx
new file mode 100644
index 000000000..fe461133b
--- /dev/null
+++ b/ui/src/components/schema-form/fields/CheckboxField.tsx
@@ -0,0 +1,45 @@
+/**
+ * CheckboxField - Boolean toggle for boolean schema types
+ */
+
+import { Checkbox } from "@/components/ui/checkbox";
+import { Label } from "@/components/ui/label";
+import { type SchemaProperty } from "@/lib/guard-schema-types";
+
+interface CheckboxFieldProps {
+  name: string;
+  schema: SchemaProperty;
+  value: boolean;
+  onChange: (value: boolean) => void;
+  error?: string;
+  disabled?: boolean;
+}
+
+export function CheckboxField({
+  name,
+  schema,
+  value,
+  onChange,
+  error,
+  disabled,
+}: CheckboxFieldProps) {
+  return (
+    <div className="space-y-2">
+      <div className="flex items-center space-x-2">
+        <Checkbox
+          id={name}
+          checked={value ?? false}
+          onCheckedChange={(checked) => onChange(checked === true)}
+          disabled={disabled}
+        />
+        <Label htmlFor={name} className="cursor-pointer">
+          {schema.title || name}
+        </Label>
+      </div>
+      {schema.description && (
+        <p className="text-xs text-muted-foreground ml-6">{schema.description}</p>
+      )}
+      {error && <p className="text-xs text-destructive ml-6">{error}</p>}
+    </div>
+  );
+}
diff --git a/ui/src/components/schema-form/fields/InputField.tsx b/ui/src/components/schema-form/fields/InputField.tsx
new file mode 100644
index 000000000..1840a56fc
--- /dev/null
+++ b/ui/src/components/schema-form/fields/InputField.tsx
@@ -0,0 +1,68 @@
+/**
+ * InputField - Text/number input for string and number schema types
+ */
+
+import { Input } from "@/components/ui/input";
+import { Label } from "@/components/ui/label";
+import { type SchemaProperty } from "@/lib/guard-schema-types";
+
+interface InputFieldProps {
+  name: string;
+  schema: SchemaProperty;
+  value: unknown;
+  onChange: (value: unknown) => void;
+  error?: string;
+  disabled?: boolean;
+}
+
+export function InputField({
+  name,
+  schema,
+  value,
+  onChange,
+  error,
+  disabled,
+}: InputFieldProps) {
+  const isNumber = schema.type === "number" || schema.type === "integer";
+  const placeholder = schema["x-ui"]?.placeholder;
+
+  const handleChange = (e: React.ChangeEvent<HTMLInputElement>) => {
+    const rawValue = e.target.value;
+    if (isNumber) {
+      if (rawValue === "") {
+        onChange(undefined);
+      } else {
+        const num = schema.type === "integer" ? parseInt(rawValue, 10) : parseFloat(rawValue);
+        if (!isNaN(num)) {
+          onChange(num);
+        }
+      }
+    } else {
+      onChange(rawValue);
+    }
+  };
+
+  return (
+    <div className="space-y-2">
+      <Label htmlFor={name}>
+        {schema.title || name}
+      </Label>
+      {schema.description && (
+        <p className="text-xs text-muted-foreground">{schema.description}</p>
+      )}
+      <Input
+        id={name}
+        type={isNumber ? "number" : "text"}
+        value={value !== undefined && value !== null ? String(value) : ""}
+        onChange={handleChange}
+        placeholder={placeholder}
+        disabled={disabled}
+        min={isNumber && "minimum" in schema ? schema.minimum : undefined}
+        max={isNumber && "maximum" in schema ? schema.maximum : undefined}
+        step={schema.type === "integer" ? 1 : "any"}
+        className={error ? "border-destructive" : ""}
+      />
+      {error && <p className="text-xs text-destructive">{error}</p>}
+    </div>
+  );
+}
diff --git a/ui/src/components/schema-form/fields/KeyValueField.tsx b/ui/src/components/schema-form/fields/KeyValueField.tsx
new file mode 100644
index 000000000..75a0a0ee2
--- /dev/null
+++ b/ui/src/components/schema-form/fields/KeyValueField.tsx
@@ -0,0 +1,102 @@
+/**
+ * KeyValueField - Key-value pair editor for object maps
+ */
+
+import { Button } from "@/components/ui/button";
+import { Input } from "@/components/ui/input";
+import { Label } from "@/components/ui/label";
+import { Plus, Trash2 } from "lucide-react";
+import { type SchemaProperty } from "@/lib/guard-schema-types";
+
+interface KeyValueFieldProps {
+  name: string;
+  schema: SchemaProperty;
+  value: Record<string, string>;
+  onChange: (value: Record<string, string>) => void;
+  error?: string;
+  disabled?: boolean;
+}
+
+export function KeyValueField({
+  name,
+  schema,
+  value,
+  onChange,
+  error,
+  disabled,
+}: KeyValueFieldProps) {
+  const entries = Object.entries(value || {});
+
+  const addEntry = () => {
+    const newKey = `key${entries.length + 1}`;
+    onChange({ ...value, [newKey]: "" });
+  };
+
+  const removeEntry = (key: string) => {
+    const newValue = { ...value };
+    delete newValue[key];
+    onChange(newValue);
+  };
+
+  const updateKey = (oldKey: string, newKey: string) => {
+    if (oldKey === newKey) return;
+    const newValue: Record<string, string> = {};
+    for (const [k, v] of Object.entries(value || {})) {
+      if (k === oldKey) {
+        newValue[newKey] = v;
+      } else {
+        newValue[k] = v;
+      }
+    }
+    onChange(newValue);
+  };
+
+  const updateValue = (key: string, newVal: string) => {
+    onChange({ ...value, [key]: newVal });
+  };
+
+  return (
+    <div className="space-y-2">
+      <Label>{schema.title || name}</Label>
+      {schema.description && (
+        <p className="text-xs text-muted-foreground">{schema.description}</p>
+      )}
+      <div className="space-y-2">
+        {entries.map(([key, val], index) => (
+          <div key={index} className="flex items-center space-x-2">
+            <Input
+              value={key}
+              onChange={(e) => updateKey(key, e.target.value)}
+              placeholder="Key"
+              disabled={disabled}
+              className="flex-1"
+            />
+            <Input
+              value={val}
+              onChange={(e) => updateValue(key, e.target.value)}
+              placeholder="Value"
+              disabled={disabled}
+              className="flex-1"
+            />
+            {!disabled && (
+              <Button
+                variant="ghost"
+                size="sm"
+                onClick={() => removeEntry(key)}
+              >
+                <Trash2 className="h-4 w-4" />
+              </Button>
+            )}
+          </div>
+        ))}
+        {!disabled && (
+          <Button variant="outline" size="sm" onClick={addEntry}>
+            <Plus className="h-4 w-4 mr-2" />
+            Add Entry
+          </Button>
+        )}
+      </div>
+      {error && <p className="text-xs text-destructive">{error}</p>}
+    </div>
+  );
+}
diff --git a/ui/src/components/schema-form/fields/MultiselectField.tsx b/ui/src/components/schema-form/fields/MultiselectField.tsx
new file mode 100644
index 000000000..036d4e6d1
--- /dev/null
+++ b/ui/src/components/schema-form/fields/MultiselectField.tsx
@@ -0,0 +1,68 @@
+/**
+ * MultiselectField - Checkbox group for enum array schema types
+ */
+
+import { Checkbox } from "@/components/ui/checkbox";
+import { Label } from "@/components/ui/label";
+import { type SchemaProperty, type ArraySchemaProperty, type StringSchemaProperty } from "@/lib/guard-schema-types";
+
+interface MultiselectFieldProps {
+  name: string;
+  schema: SchemaProperty;
+  value: string[];
+  onChange: (value: string[]) => void;
+  error?: string;
+  disabled?: boolean;
+}
+
+export function MultiselectField({
+  name,
+  schema,
+  value,
+  onChange,
+  error,
+  disabled,
+}: MultiselectFieldProps) {
+  const items = Array.isArray(value) ? value : [];
+
+  // Get enum values from items schema
+  const arraySchema = schema as ArraySchemaProperty;
+  const itemsSchema = arraySchema.items as StringSchemaProperty | undefined;
+  const enumValues = itemsSchema?.enum || [];
+
+  // Get display labels from UI hints
+  const labels = schema["x-ui"]?.labels || {};
+
+  const handleToggle = (enumValue: string, checked: boolean) => {
+    if (checked) {
+      onChange([...items, enumValue]);
+    } else {
+      onChange(items.filter((item) => item !== enumValue));
+    }
+  };
+
+  return (
+    <div className="space-y-2">
+      <Label>{schema.title || name}</Label>
+      {schema.description && (
+        <p className="text-xs text-muted-foreground">{schema.description}</p>
+      )}
+      <div className="space-y-2">
+        {enumValues.map((enumValue) => (
+          <div key={enumValue} className="flex items-center space-x-2">
+            <Checkbox
+              id={`${name}-${enumValue}`}
+              checked={items.includes(enumValue)}
+              onCheckedChange={(checked) => handleToggle(enumValue, checked === true)}
+              disabled={disabled}
+            />
+            <Label htmlFor={`${name}-${enumValue}`} className="cursor-pointer font-normal">
+              {labels[enumValue] || enumValue}
+            </Label>
+          </div>
+        ))}
+      </div>
+      {error && <p className="text-xs text-destructive">{error}</p>}
+    </div>
+  );
+}
diff --git a/ui/src/components/schema-form/fields/ObjectArrayField.tsx b/ui/src/components/schema-form/fields/ObjectArrayField.tsx
new file mode 100644
index 000000000..dda35a21b
--- /dev/null
+++ b/ui/src/components/schema-form/fields/ObjectArrayField.tsx
@@ -0,0 +1,192 @@
+/**
+ * ObjectArrayField - Expandable list for array of objects schema types
+ */
+
+import { useState } from "react";
+import { Button } from "@/components/ui/button";
+import { Input } from "@/components/ui/input";
+import { Label } from "@/components/ui/label";
+import { Card, CardContent } from "@/components/ui/card";
+import {
+  Collapsible,
+  CollapsibleContent,
+  CollapsibleTrigger,
+} from "@/components/ui/collapsible";
+import { ChevronDown, ChevronRight, Plus, Trash2 } from "lucide-react";
+import {
+  type SchemaProperty,
+  type ArraySchemaProperty,
+  type ObjectSchemaProperty,
+} from "@/lib/guard-schema-types";
+
+interface ObjectArrayFieldProps {
+  name: string;
+  schema: SchemaProperty;
+  value: Record<string, unknown>[];
+  onChange: (value: Record<string, unknown>[]) => void;
+  error?: string;
+  disabled?: boolean;
+}
+
+export function ObjectArrayField({
+  name,
+  schema,
+  value,
+  onChange,
+  error,
+  disabled,
+}: ObjectArrayFieldProps) {
+  const [expandedItems, setExpandedItems] = useState<Set<number>>(new Set([0]));
+  const items = Array.isArray(value) ? value : [];
+
+  // Get item schema
+  const arraySchema = schema as ArraySchemaProperty;
+  const itemSchema = arraySchema.items as ObjectSchemaProperty | undefined;
+  const itemProperties = itemSchema?.properties || {};
+  const requiredFields = itemSchema?.required || [];
+
+  const toggleExpanded = (index: number) => {
+    const newExpanded = new Set(expandedItems);
+    if (newExpanded.has(index)) {
+      newExpanded.delete(index);
+    } else {
+      newExpanded.add(index);
+    }
+    setExpandedItems(newExpanded);
+  };
+
+  const addItem = () => {
+    // Create new item with defaults
+    const newItem: Record<string, unknown> = {};
+    for (const [key, prop] of Object.entries(itemProperties)) {
+      if (prop.default !== undefined) {
+        newItem[key] = prop.default;
+      }
+    }
+    const newItems = [...items, newItem];
+    onChange(newItems);
+    setExpandedItems(new Set([...expandedItems, newItems.length - 1]));
+  };
+
+  const removeItem = (index: number) => {
+    const newItems = items.filter((_, i) => i !== index);
+    onChange(newItems);
+    const newExpanded = new Set(expandedItems);
+    newExpanded.delete(index);
+    setExpandedItems(newExpanded);
+  };
+
+  const updateItem = (index: number, key: string, newValue: unknown) => {
+    const newItems = [...items];
+    newItems[index] = { ...newItems[index], [key]: newValue };
+    onChange(newItems);
+  };
+
+  const getItemLabel = (item: Record<string, unknown>, index: number): string => {
+    // Try to find a name/title field for display
+    const labelField = Object.keys(itemProperties).find(
+      (k) => k === "name" || k === "title" || k === "id"
+    );
+    if (labelField && item[labelField]) {
+      return String(item[labelField]);
+    }
+    return `Item ${index + 1}`;
+  };
+
+  return (
+    <div className="space-y-2">
+      <Label>{schema.title || name}</Label>
+      {schema.description && (
+        <p className="text-xs text-muted-foreground">{schema.description}</p>
+      )}
+      <div className="space-y-2">
+        {items.map((item, index) => (
+          <Card key={index} className="overflow-hidden">
+            <Collapsible
+              open={expandedItems.has(index)}
+              onOpenChange={() => toggleExpanded(index)}
+            >
+              <CollapsibleTrigger asChild>
+                <div className="flex items-center justify-between p-3 cursor-pointer hover:bg-accent/50">
+                  <div className="flex items-center gap-2">
+                    {expandedItems.has(index) ? (
+                      <ChevronDown className="h-4 w-4" />
+                    ) : (
+                      <ChevronRight className="h-4 w-4" />
+                    )}
+                    <span className="text-sm font-medium">{getItemLabel(item, index)}</span>
+                  </div>
+                  {!disabled && (
+                    <Button
+                      variant="ghost"
+                      size="sm"
+                      onClick={(e) => {
+                        e.stopPropagation();
+                        removeItem(index);
+                      }}
+                    >
+                      <Trash2 className="h-4 w-4" />
+                    </Button>
+                  )}
+                </div>
+              </CollapsibleTrigger>
+              <CollapsibleContent>
+                <CardContent className="pt-0 pb-3 space-y-3">
+                  {Object.entries(itemProperties).map(([key, prop]) => (
+                    <div key={key} className="space-y-1">
+                      <Label htmlFor={`${name}-${index}-${key}`} className="text-xs">
+                        {prop.title || key}
+                        {requiredFields.includes(key) && " *"}
+                      </Label>
+                      {prop.type === "boolean" ? (
+                        <div className="flex items-center space-x-2">
+                          <input
+                            type="checkbox"
+                            id={`${name}-${index}-${key}`}
+                            checked={item[key] as boolean ?? false}
+                            onChange={(e) => updateItem(index, key, e.target.checked)}
+                            disabled={disabled}
+                            className="h-4 w-4"
+                          />
+                          {prop.description && (
+                            <span className="text-xs text-muted-foreground">
+                              {prop.description}
+                            </span>
+                          )}
+                        </div>
+                      ) : (
+                        <Input
+                          id={`${name}-${index}-${key}`}
+                          type={prop.type === "number" || prop.type === "integer" ? "number" : "text"}
+                          value={item[key] !== undefined ? String(item[key]) : ""}
+                          onChange={(e) => {
+                            const rawValue = e.target.value;
+                            if (prop.type === "number" || prop.type === "integer") {
+                              const num = parseFloat(rawValue);
+                              updateItem(index, key, isNaN(num) ? undefined : num);
+                            } else {
+                              updateItem(index, key, rawValue);
+                            }
+                          }}
+                          placeholder={prop["x-ui"]?.placeholder || prop.description}
+                          disabled={disabled}
+                        />
+                      )}
+                    </div>
+                  ))}
+                </CardContent>
+              </CollapsibleContent>
+            </Collapsible>
+          </Card>
+        ))}
+        {!disabled && (
+          <Button variant="outline" size="sm" onClick={addItem} className="w-full">
+            <Plus className="h-4 w-4 mr-2" />
+            Add {itemSchema?.title || "Item"}
+          </Button>
+        )}
+      </div>
+      {error && <p className="text-xs text-destructive">{error}</p>}
+    </div>
+  );
+}
diff --git a/ui/src/components/schema-form/fields/SelectField.tsx b/ui/src/components/schema-form/fields/SelectField.tsx
new file mode 100644
index 000000000..6fd1f93c3
--- /dev/null
+++ b/ui/src/components/schema-form/fields/SelectField.tsx
@@ -0,0 +1,74 @@
+/**
+ * SelectField - Dropdown select for enum schema types
+ */
+
+import { Label } from "@/components/ui/label";
+import {
+  Select,
+  SelectContent,
+  SelectItem,
+  SelectTrigger,
+  SelectValue,
+} from "@/components/ui/select";
+import { type SchemaProperty, type StringSchemaProperty, type NumberSchemaProperty } from "@/lib/guard-schema-types";
+
+interface SelectFieldProps {
+  name: string;
+  schema: SchemaProperty;
+  value: string | number;
+  onChange: (value: string | number) => void;
+  error?: string;
+  disabled?: boolean;
+}
+
+export function SelectField({
+  name,
+  schema,
+  value,
+  onChange,
+  error,
+  disabled,
+}: SelectFieldProps) {
+  // Get enum values from schema
+  const enumValues: (string | number)[] =
+    schema.type === "string"
+      ? (schema as StringSchemaProperty).enum || []
+      : (schema as NumberSchemaProperty).enum || [];
+
+  // Get display labels from UI hints
+  const labels = schema["x-ui"]?.labels || {};
+
+  const handleChange = (newValue: string) => {
+    if (schema.type === "number" || schema.type === "integer") {
+      onChange(parseFloat(newValue));
+    } else {
+      onChange(newValue);
+    }
+  };
+
+  return (
+    <div className="space-y-2">
+      <Label htmlFor={name}>{schema.title || name}</Label>
+      {schema.description && (
+        <p className="text-xs text-muted-foreground">{schema.description}</p>
+      )}
+      <Select
+        value={value !== undefined ? String(value) : undefined}
+        onValueChange={handleChange}
+        disabled={disabled}
+      >
+        <SelectTrigger id={name} className={error ? "border-destructive" : ""}>
+          <SelectValue placeholder={schema["x-ui"]?.placeholder || "Select..."} />
+        </SelectTrigger>
+        <SelectContent>
+          {enumValues.map((enumValue) => (
+            <SelectItem key={String(enumValue)} value={String(enumValue)}>
+              {labels[String(enumValue)] || String(enumValue)}
+            </SelectItem>
+          ))}
+        </SelectContent>
+      </Select>
+      {error && <p className="text-xs text-destructive">{error}</p>}
+    </div>
+  );
+}
diff --git a/ui/src/components/schema-form/fields/SliderField.tsx b/ui/src/components/schema-form/fields/SliderField.tsx
new file mode 100644
index 000000000..51f5f109b
--- /dev/null
+++ b/ui/src/components/schema-form/fields/SliderField.tsx
@@ -0,0 +1,93 @@
+/**
+ * SliderField - Range slider for bounded number schema types
+ */
+
+import { useState } from "react";
+import { Input } from "@/components/ui/input";
+import { Label } from "@/components/ui/label";
+import { type SchemaProperty, type NumberSchemaProperty } from "@/lib/guard-schema-types";
+
+interface SliderFieldProps {
+  name: string;
+  schema: SchemaProperty;
+  value: number;
+  onChange: (value: number) => void;
+  error?: string;
+  disabled?: boolean;
+}
+
+export function SliderField({
+  name,
+  schema,
+  value,
+  onChange,
+  error,
+  disabled,
+}: SliderFieldProps) {
+  const numSchema = schema as NumberSchemaProperty;
+  const min = numSchema.minimum ?? 0;
+  const max = numSchema.maximum ?? 100;
+  const step = numSchema.multipleOf ?? (schema.type === "integer" ? 1 : 0.01);
+
+  // Local state for the input field to allow typing
+  const [inputValue, setInputValue] = useState(String(value ?? min));
+
+  const handleSliderChange = (e: React.ChangeEvent<HTMLInputElement>) => {
+    const num = parseFloat(e.target.value);
+    onChange(num);
+    setInputValue(String(num));
+  };
+
+  const handleInputChange = (e: React.ChangeEvent<HTMLInputElement>) => {
+    setInputValue(e.target.value);
+  };
+
+  const handleInputBlur = () => {
+    let num = parseFloat(inputValue);
+    if (isNaN(num)) {
+      num = value ?? min;
+    }
+    // Clamp to range
+    num = Math.max(min, Math.min(max, num));
+    onChange(num);
+    setInputValue(String(num));
+  };
+
+  return (
+    <div className="space-y-2">
+      <div className="flex items-center justify-between">
+        <Label htmlFor={name}>{schema.title || name}</Label>
+        <Input
+          type="number"
+          value={inputValue}
+          onChange={handleInputChange}
+          onBlur={handleInputBlur}
+          disabled={disabled}
+          min={min}
+          max={max}
+          step={step}
+          className="w-20 h-7 text-sm text-right"
+        />
+      </div>
+      {schema.description && (
+        <p className="text-xs text-muted-foreground">{schema.description}</p>
+      )}
+      <div className="flex items-center space-x-2">
+        <span className="text-xs text-muted-foreground w-8">{min}</span>
+        <input
+          type="range"
+          id={name}
+          value={value ?? min}
+          onChange={handleSliderChange}
+          disabled={disabled}
+          min={min}
+          max={max}
+          step={step}
+          className="flex-1 h-2 bg-secondary rounded-lg appearance-none cursor-pointer accent-primary disabled:opacity-50 disabled:cursor-not-allowed"
+        />
+        <span className="text-xs text-muted-foreground w-8 text-right">{max}</span>
+      </div>
+      {error && <p className="text-xs text-destructive">{error}</p>}
+    </div>
+  );
+}
diff --git a/ui/src/components/schema-form/fields/TagsField.tsx b/ui/src/components/schema-form/fields/TagsField.tsx
new file mode 100644
index 000000000..e826e82e7
--- /dev/null
+++ b/ui/src/components/schema-form/fields/TagsField.tsx
@@ -0,0 +1,100 @@
+/**
+ * TagsField - Tag input for string array schema types
+ */
+
+import { useState, KeyboardEvent } from "react";
+import { Input } from "@/components/ui/input";
+import { Label } from "@/components/ui/label";
+import { Badge } from "@/components/ui/badge";
+import { X } from "lucide-react";
+import { type SchemaProperty } from "@/lib/guard-schema-types";
+
+interface TagsFieldProps {
+  name: string;
+  schema: SchemaProperty;
+  value: string[];
+  onChange: (value: string[]) => void;
+  error?: string;
+  disabled?: boolean;
+}
+
+export function TagsField({
+  name,
+  schema,
+  value,
+  onChange,
+  error,
+  disabled,
+}: TagsFieldProps) {
+  const [inputValue, setInputValue] = useState("");
+  const items = Array.isArray(value) ? value : [];
+  const placeholder = schema["x-ui"]?.placeholder || "Type and press Enter";
+
+  const addTag = (tag: string) => {
+    const trimmed = tag.trim();
+    if (trimmed && !items.includes(trimmed)) {
+      onChange([...items, trimmed]);
+    }
+    setInputValue("");
+  };
+
+  const removeTag = (index: number) => {
+    const newItems = items.filter((_, i) => i !== index);
+    onChange(newItems);
+  };
+
+  const handleKeyDown = (e: KeyboardEvent<HTMLInputElement>) => {
+    if (e.key === "Enter") {
+      e.preventDefault();
+      addTag(inputValue);
+    } else if (e.key === "Backspace" && inputValue === "" && items.length > 0) {
+      removeTag(items.length - 1);
+    }
+  };
+
+  const handleBlur = () => {
+    if (inputValue.trim()) {
+      addTag(inputValue);
+    }
+  };
+
+  return (
+    <div className="space-y-2">
+      <Label htmlFor={name}>{schema.title || name}</Label>
+      {schema.description && (
+        <p className="text-xs text-muted-foreground">{schema.description}</p>
+      )}
+      <div className="space-y-2">
+        {items.length > 0 && (
+          <div className="flex flex-wrap gap-1">
+            {items.map((item, index) => (
+              <Badge key={index} variant="secondary" className="gap-1">
+                {item}
+                {!disabled && (
+                  <button
+                    type="button"
+                    onClick={() => removeTag(index)}
+                    className="ml-1 hover:text-destructive"
+                  >
+                    <X className="h-3 w-3" />
+                  </button>
+                )}
+              </Badge>
+            ))}
+          </div>
+        )}
+        <Input
+          id={name}
+          value={inputValue}
+          onChange={(e) => setInputValue(e.target.value)}
+          onKeyDown={handleKeyDown}
+          onBlur={handleBlur}
+          placeholder={placeholder}
+          disabled={disabled}
+          className={error ? "border-destructive" : ""}
+        />
+      </div>
+      {error && <p className="text-xs text-destructive">{error}</p>}
+    </div>
+  );
+}
diff --git a/ui/src/components/schema-form/fields/TextareaField.tsx b/ui/src/components/schema-form/fields/TextareaField.tsx
new file mode 100644
index 000000000..9f21de867
--- /dev/null
+++ b/ui/src/components/schema-form/fields/TextareaField.tsx
@@ -0,0 +1,47 @@
+/**
+ * TextareaField - Multi-line text input for long string schema types
+ */
+
+import { Textarea } from "@/components/ui/textarea";
+import { Label } from "@/components/ui/label";
+import { type SchemaProperty } from "@/lib/guard-schema-types";
+
+interface TextareaFieldProps {
+  name: string;
+  schema: SchemaProperty;
+  value: string;
+  onChange: (value: string) => void;
+  error?: string;
+  disabled?: boolean;
+}
+
+export function TextareaField({
+  name,
+  schema,
+  value,
+  onChange,
+  error,
+  disabled,
+}: TextareaFieldProps) {
+  const placeholder = schema["x-ui"]?.placeholder;
+  const rows = schema["x-ui"]?.rows ?? 4;
+
+  return (
+    <div className="space-y-2">
+      <Label htmlFor={name}>{schema.title || name}</Label>
+      {schema.description && (
+        <p className="text-xs text-muted-foreground">{schema.description}</p>
+      )}
+      <Textarea
+        id={name}
+        value={value ?? ""}
+        onChange={(e) => onChange(e.target.value)}
+        placeholder={placeholder}
+        disabled={disabled}
+        rows={rows}
+        className={error ? "border-destructive" : ""}
+      />
+      {error && <p className="text-xs text-destructive">{error}</p>}
+    </div>
+  );
+}
diff --git a/ui/src/components/schema-form/index.ts b/ui/src/components/schema-form/index.ts
new file mode 100644
index 000000000..a52fa154f
--- /dev/null
+++ b/ui/src/components/schema-form/index.ts
@@ -0,0 +1,21 @@
+/**
+ * Schema Form Components
+ *
+ * Dynamic form generator from JSON Schema definitions.
+ * Used to render guard configuration forms based on schemas
+ * exported by WASM guards.
+ */
+
+export { SchemaForm } from "./SchemaForm";
+export { SchemaField } from "./SchemaField";
+
+// Field components (usually not imported directly)
+export { InputField } from "./fields/InputField";
+export { CheckboxField } from "./fields/CheckboxField";
+export { SelectField } from "./fields/SelectField";
+export { SliderField } from "./fields/SliderField";
+export { TagsField } from "./fields/TagsField";
+export { MultiselectField } from "./fields/MultiselectField";
+export { ObjectArrayField } from "./fields/ObjectArrayField";
+export { KeyValueField } from "./fields/KeyValueField";
+export { TextareaField } from "./fields/TextareaField";
diff --git a/ui/src/hooks/useGuardSchemas.ts b/ui/src/hooks/useGuardSchemas.ts
new file mode 100644
index 000000000..321e80d5f
--- /dev/null
+++ b/ui/src/hooks/useGuardSchemas.ts
@@ -0,0 +1,379 @@
+/**
+ * useGuardSchemas - Hook for fetching and managing guard schemas
+ *
+ * Provides access to JSON Schemas exported by guards for dynamic
+ * form generation. Falls back to embedded schemas when API is unavailable.
+ */
+
+import { useState, useEffect, useCallback } from "react";
+import {
+  type GuardSettingsSchema,
+  type GuardSchemasResponse,
+  type GuardTypeSummary,
+  resolveWithDefaults,
+} from "@/lib/guard-schema-types";
+
+// API URL - use relative for same-origin requests
+const API_URL = "";
+
+// =============================================================================
+// Embedded Schemas (fallback when API unavailable)
+// =============================================================================
+
+/**
+ * Native guard schemas embedded in the UI.
+ * These match the Rust guard implementations.
+ */
+const NATIVE_GUARD_SCHEMAS: Record<string, GuardSettingsSchema> = {
+  tool_poisoning: {
+    $id: "agentgateway://guards/tool-poisoning/v1",
+    title: "Tool Poisoning Detection",
+    description: "Detects malicious patterns in MCP tool descriptions",
+    type: "object",
+    properties: {
+      strict_mode: {
+        type: "boolean",
+        title: "Strict Mode",
+        description: "Block on any suspicious pattern match",
+        default: true,
+        "x-ui": { order: 1 },
+      },
+      custom_patterns: {
+        type: "array",
+        title: "Custom Patterns",
+        description: "Additional regex patterns to detect",
+        items: { type: "string" },
+        default: [],
+        "x-ui": { component: "tags", placeholder: "(?i)custom_pattern", order: 2 },
+      },
+      scan_fields: {
+        type: "array",
+        title: "Scan Fields",
+        description: "Which tool fields to scan for patterns",
+        items: {
+          type: "string",
+          enum: ["name", "description", "input_schema"],
+        },
+        default: ["name", "description", "input_schema"],
+        "x-ui": {
+          component: "multiselect",
+          labels: {
+            name: "Tool Name",
+            description: "Tool Description",
+            input_schema: "Input Schema",
+          },
+          order: 3,
+        },
+      },
+      alert_threshold: {
+        type: "integer",
+        title: "Alert Threshold",
+        description: "Number of pattern matches to trigger alert",
+        default: 1,
+        minimum: 1,
+        "x-ui": { order: 4 },
+      },
+    },
+    "x-guard-meta": {
+      guardType: "tool_poisoning",
+      version: "1.0.0",
+      category: "detection",
+      defaultRunsOn: ["tools_list"],
+      icon: "shield-alert",
+    },
+  },
+
+  rug_pull: {
+    $id: "agentgateway://guards/rug-pull/v1",
+    title: "Rug Pull Detection",
+    description: "Detects tools that change behavior after initial trust",
+    type: "object",
+    properties: {
+      risk_threshold: {
+        type: "number",
+        title: "Risk Threshold",
+        description: "Minimum risk score to trigger alert (0-1)",
+        default: 0.7,
+        minimum: 0,
+        maximum: 1,
+        "x-ui": { component: "slider", order: 1 },
+      },
+    },
+    "x-guard-meta": {
+      guardType: "rug_pull",
+      version: "1.0.0",
+      category: "detection",
+      defaultRunsOn: ["tools_list"],
+      icon: "alert-triangle",
+    },
+  },
+
+  tool_shadowing: {
+    $id: "agentgateway://guards/tool-shadowing/v1",
+    title: "Tool Shadowing Detection",
+    description: "Detects tools that shadow built-in or protected tool names",
+    type: "object",
+    properties: {
+      block_duplicates: {
+        type: "boolean",
+        title: "Block Duplicates",
+        description: "Block tools with duplicate names across servers",
+        default: true,
+        "x-ui": { order: 1 },
+      },
+      protected_names: {
+        type: "array",
+        title: "Protected Names",
+        description: "Tool names that cannot be overridden",
+        items: { type: "string" },
+        default: [],
+        "x-ui": { component: "tags", placeholder: "protected_tool", order: 2 },
+      },
+    },
+    "x-guard-meta": {
+      guardType: "tool_shadowing",
+      version: "1.0.0",
+      category: "detection",
+      defaultRunsOn: ["tools_list"],
+      icon: "copy",
+    },
+  },
+
+  server_whitelist: {
+    $id: "agentgateway://guards/server-whitelist/v1",
+    title: "Server Whitelist",
+    description: "Only allow connections to approved MCP servers",
+    type: "object",
+    properties: {
+      allowed_servers: {
+        type: "array",
+        title: "Allowed Servers",
+        description: "List of allowed server names or patterns",
+        items: { type: "string" },
+        default: [],
+        "x-ui": { component: "tags", placeholder: "server-name", order: 1 },
+      },
+      detect_typosquats: {
+        type: "boolean",
+        title: "Detect Typosquats",
+        description: "Detect server names similar to allowed servers",
+        default: true,
+        "x-ui": { order: 2 },
+      },
+      similarity_threshold: {
+        type: "number",
+        title: "Similarity Threshold",
+        description: "Levenshtein similarity threshold for typosquat detection",
+        default: 0.85,
+        minimum: 0,
+        maximum: 1,
+        "x-ui": { component: "slider", order: 3 },
+      },
+    },
+    "x-guard-meta": {
+      guardType: "server_whitelist",
+      version: "1.0.0",
+      category: "prevention",
+      defaultRunsOn: ["connection"],
+      icon: "list-check",
+    },
+  },
+
+  pii: {
+    $id: "agentgateway://guards/pii/v1",
+    title: "PII Detection",
+    description: "Detects and masks personally identifiable information",
+    type: "object",
+    properties: {
+      detect: {
+        type: "array",
+        title: "PII Types to Detect",
+        description: "Types of PII to detect in responses",
+        items: {
+          type: "string",
+          enum: ["email", "phone_number", "ssn", "credit_card", "ca_sin", "url"],
+        },
+        default: ["email", "phone_number", "ssn", "credit_card"],
+        "x-ui": {
+          component: "multiselect",
+          labels: {
+            email: "Email Address",
+            phone_number: "Phone Number",
+            ssn: "Social Security Number",
+            credit_card: "Credit Card",
+            ca_sin: "Canadian SIN",
+            url: "URL",
+          },
+          order: 1,
+        },
+      },
+      action: {
+        type: "string",
+        title: "Action",
+        description: "What to do when PII is detected",
+        enum: ["mask", "reject"],
+        default: "mask",
+        "x-ui": {
+          component: "select",
+          labels: {
+            mask: "Mask PII",
+            reject: "Reject Request",
+          },
+          order: 2,
+        },
+      },
+      min_score: {
+        type: "number",
+        title: "Minimum Confidence Score",
+        description: "Minimum confidence score to trigger detection (0-1)",
+        default: 0.8,
+        minimum: 0,
+        maximum: 1,
+        "x-ui": { component: "slider", order: 3 },
+      },
+      rejection_message: {
+        type: "string",
+        title: "Rejection Message",
+        description: "Custom message when rejecting requests (optional)",
+        "x-ui": { placeholder: "PII detected in response", order: 4, advanced: true },
+      },
+    },
+    "x-guard-meta": {
+      guardType: "pii",
+      version: "1.0.0",
+      category: "modification",
+      defaultRunsOn: ["response"],
+      icon: "user-x",
+    },
+  },
+};
+
+// =============================================================================
+// Hook Implementation
+// =============================================================================
+
+interface UseGuardSchemasResult {
+  /** Map of guard type to schema */
+  schemas: Record<string, GuardSettingsSchema>;
+
+  /** List of available guard types with metadata */
+  availableGuards: GuardTypeSummary[];
+
+  /** Loading state */
+  loading: boolean;
+
+  /** Error if fetch failed */
+  error: Error | null;
+
+  /** Get schema for a specific guard type */
+  getSchema: (guardType: string) => GuardSettingsSchema | undefined;
+
+  /** Resolve config with defaults from schema */
+  resolveConfig: (
+    guardType: string,
+    config: Record<string, unknown>
+  ) => Record<string, unknown>;
+
+  /** Refresh schemas from API */
+  refresh: () => Promise<void>;
+}
+
+/**
+ * Hook for accessing guard schemas
+ *
+ * @param fetchFromApi - Whether to fetch schemas from API (default: false, uses embedded)
+ */
+export function useGuardSchemas(fetchFromApi = false): UseGuardSchemasResult {
+  const [schemas, setSchemas] = useState<Record<string, GuardSettingsSchema>>(
+    NATIVE_GUARD_SCHEMAS
+  );
+  const [loading, setLoading] = useState(fetchFromApi);
+  const [error, setError] = useState<Error | null>(null);
+
+  const fetchSchemas = useCallback(async () => {
+    if (!fetchFromApi) {
+      // Use embedded schemas
+      setSchemas(NATIVE_GUARD_SCHEMAS);
+      setLoading(false);
+      return;
+    }
+
+    setLoading(true);
+    setError(null);
+
+    try {
+      const response = await fetch(`${API_URL}/api/v1/guards/schemas`);
+      if (!response.ok) {
+        throw new Error(`Failed to fetch guard schemas: ${response.status}`);
+      }
+
+      const data: GuardSchemasResponse = await response.json();
+      // Merge API schemas with native schemas (API takes precedence)
+      setSchemas({ ...NATIVE_GUARD_SCHEMAS, ...data.schemas });
+    } catch (err) {
+      console.warn("Failed to fetch guard schemas from API, using embedded:", err);
+      setError(err instanceof Error ? err : new Error(String(err)));
+      // Fall back to embedded schemas
+      setSchemas(NATIVE_GUARD_SCHEMAS);
+    } finally {
+      setLoading(false);
+    }
+  }, [fetchFromApi]);
+
+  useEffect(() => {
+    fetchSchemas();
+  }, [fetchSchemas]);
+
+  const getSchema = useCallback(
+    (guardType: string): GuardSettingsSchema | undefined => {
+      return schemas[guardType];
+    },
+    [schemas]
+  );
+
+  const resolveConfig = useCallback(
+    (guardType: string, config: Record<string, unknown>): Record<string, unknown> => {
+      const schema = schemas[guardType];
+      if (!schema) {
+        return config;
+      }
+      return resolveWithDefaults(config, schema);
+    },
+    [schemas]
+  );
+
+  const availableGuards: GuardTypeSummary[] = Object.entries(schemas).map(
+    ([type, schema]) => ({
+      type,
+      title: schema.title,
+      description: schema.description,
+      category: schema["x-guard-meta"]?.category || "detection",
+      icon: schema["x-guard-meta"]?.icon,
+      isWasm: !NATIVE_GUARD_SCHEMAS[type],
+    })
+  );
+
+  return {
+    schemas,
+    availableGuards,
+    loading,
+    error,
+    getSchema,
+    resolveConfig,
+    refresh: fetchSchemas,
+  };
+}
+
+/**
+ * Get embedded schema for a guard type without using React hooks
+ */
+export function getEmbeddedSchema(guardType: string): GuardSettingsSchema | undefined {
+  return NATIVE_GUARD_SCHEMAS[guardType];
+}
+
+/**
+ * Get all embedded guard types
+ */
+export function getEmbeddedGuardTypes(): string[] {
+  return Object.keys(NATIVE_GUARD_SCHEMAS);
+}
diff --git a/ui/src/lib/guard-schema-types.ts b/ui/src/lib/guard-schema-types.ts
new file mode 100644
index 000000000..5fdd95494
--- /dev/null
+++ b/ui/src/lib/guard-schema-types.ts
@@ -0,0 +1,421 @@
+/**
+ * TypeScript types for Guard Settings Schema (JSON Schema based)
+ *
+ * These types define the schema structure that guards export to describe
+ * their configurable parameters. The UI uses these schemas to generate
+ * dynamic configuration forms.
+ */
+
+// =============================================================================
+// UI Hints Extension
+// =============================================================================
+
+/**
+ * UI rendering hints for schema properties.
+ * These extend JSON Schema with UI-specific metadata.
+ */
+export interface SchemaUIHints {
+  /** Preferred UI component to render this field */
+  component?:
+    | "input"
+    | "textarea"
+    | "select"
+    | "checkbox"
+    | "slider"
+    | "tags"
+    | "multiselect"
+    | "object-array"
+    | "key-value";
+
+  /** Placeholder text for input fields */
+  placeholder?: string;
+
+  /** Help text shown below the field */
+  helpText?: string;
+
+  /** Show in advanced section (collapsed by default) */
+  advanced?: boolean;
+
+  /** Display order within the group (lower = first) */
+  order?: number;
+
+  /** Group name for organizing related fields */
+  group?: string;
+
+  /** Number of rows for textarea */
+  rows?: number;
+
+  /** Display labels for enum values */
+  labels?: Record<string, string>;
+}
+
+/**
+ * UI group definition for organizing schema properties
+ */
+export interface SchemaUIGroup {
+  title: string;
+  order: number;
+  description?: string;
+  collapsed?: boolean;
+}
+
+// =============================================================================
+// Guard Metadata Extension
+// =============================================================================
+
+/**
+ * Guard metadata embedded in the schema.
+ * Provides information about the guard for UI display and filtering.
+ */
+export interface GuardMeta {
+  /** Guard type identifier (e.g., "server_spoofing", "tool_poisoning") */
+  guardType: string;
+
+  /** Schema version (semver) */
+  version: string;
+
+  /** Guard category for UI grouping */
+  category: "detection" | "prevention" | "modification" | "logging";
+
+  /** Default guard phases to run on */
+  defaultRunsOn: GuardPhase[];
+
+  /** Icon identifier for UI display */
+  icon?: string;
+}
+
+export type GuardPhase =
+  | "connection"
+  | "request"
+  | "response"
+  | "tools_list"
+  | "tool_invoke";
+
+// =============================================================================
+// JSON Schema Types (Draft 2020-12 subset)
+// =============================================================================
+
+/**
+ * Base schema property interface
+ */
+export interface SchemaPropertyBase {
+  /** Property type */
+  type: "string" | "number" | "integer" | "boolean" | "array" | "object";
+
+  /** Human-readable title */
+  title?: string;
+
+  /** Description of the property */
+  description?: string;
+
+  /** Default value */
+  default?: unknown;
+
+  /** UI rendering hints */
+  "x-ui"?: SchemaUIHints;
+}
+
+/**
+ * String property schema
+ */
+export interface StringSchemaProperty extends SchemaPropertyBase {
+  type: "string";
+  default?: string;
+
+  /** Allowed values (renders as select/radio) */
+  enum?: string[];
+
+  /** Minimum length */
+  minLength?: number;
+
+  /** Maximum length */
+  maxLength?: number;
+
+  /** Regex pattern for validation */
+  pattern?: string;
+
+  /** String format hint */
+  format?: "uri" | "email" | "date" | "time" | "date-time" | "regex";
+}
+
+/**
+ * Number/Integer property schema
+ */
+export interface NumberSchemaProperty extends SchemaPropertyBase {
+  type: "number" | "integer";
+  default?: number;
+
+  /** Allowed values */
+  enum?: number[];
+
+  /** Minimum value (inclusive) */
+  minimum?: number;
+
+  /** Maximum value (inclusive) */
+  maximum?: number;
+
+  /** Exclusive minimum */
+  exclusiveMinimum?: number;
+
+  /** Exclusive maximum */
+  exclusiveMaximum?: number;
+
+  /** Value must be multiple of this */
+  multipleOf?: number;
+}
+
+/**
+ * Boolean property schema
+ */
+export interface BooleanSchemaProperty extends SchemaPropertyBase {
+  type: "boolean";
+  default?: boolean;
+}
+
+/**
+ * Array property schema
+ */
+export interface ArraySchemaProperty extends SchemaPropertyBase {
+  type: "array";
+  default?: unknown[];
+
+  /** Schema for array items */
+  items?: SchemaProperty;
+
+  /** Minimum number of items */
+  minItems?: number;
+
+  /** Maximum number of items */
+  maxItems?: number;
+
+  /** Items must be unique */
+  uniqueItems?: boolean;
+}
+
+/**
+ * Object property schema
+ */
+export interface ObjectSchemaProperty extends SchemaPropertyBase {
+  type: "object";
+  default?: Record<string, unknown>;
+
+  /** Nested property definitions */
+  properties?: Record<string, SchemaProperty>;
+
+  /** Required property names */
+  required?: string[];
+
+  /** Schema for additional properties (for key-value maps) */
+  additionalProperties?: SchemaProperty | boolean;
+}
+
+/**
+ * Union type for all schema property types
+ */
+export type SchemaProperty =
+  | StringSchemaProperty
+  | NumberSchemaProperty
+  | BooleanSchemaProperty
+  | ArraySchemaProperty
+  | ObjectSchemaProperty;
+
+// =============================================================================
+// Guard Settings Schema
+// =============================================================================
+
+/**
+ * Complete guard settings schema.
+ *
+ * This is the root schema object that guards export to describe their
+ * configurable parameters. It follows JSON Schema Draft 2020-12 with
+ * custom extensions for UI rendering.
+ */
+export interface GuardSettingsSchema {
+  /** JSON Schema version */
+  $schema?: string;
+
+  /** Schema identifier */
+  $id?: string;
+
+  /** Guard display name */
+  title: string;
+
+  /** Guard description */
+  description?: string;
+
+  /** Root type (always "object" for guard schemas) */
+  type: "object";
+
+  /** Guard-specific property definitions */
+  properties: Record<string, SchemaProperty>;
+
+  /** Required property names */
+  required?: string[];
+
+  /** UI group definitions */
+  "x-ui-groups"?: Record<string, SchemaUIGroup>;
+
+  /** Guard metadata */
+  "x-guard-meta"?: GuardMeta;
+}
+
+// =============================================================================
+// Schema Registry Types
+// =============================================================================
+
+/**
+ * Summary of an available guard type
+ */
+export interface GuardTypeSummary {
+  /** Guard type identifier */
+  type: string;
+
+  /** Display name */
+  title: string;
+
+  /** Description */
+  description?: string;
+
+  /** Category */
+  category: string;
+
+  /** Icon identifier */
+  icon?: string;
+
+  /** Whether this is a WASM guard */
+  isWasm: boolean;
+}
+
+/**
+ * Response from the guard schemas API endpoint
+ */
+export interface GuardSchemasResponse {
+  /** Map of guard type to schema */
+  schemas: Record<string, GuardSettingsSchema>;
+
+  /** List of available guard types */
+  availableGuards: GuardTypeSummary[];
+}
+
+// =============================================================================
+// Utility Types
+// =============================================================================
+
+/**
+ * Resolved guard configuration with defaults applied
+ */
+export type ResolvedGuardConfig<T = Record<string, unknown>> = T;
+
+/**
+ * Validation error for a specific field
+ */
+export interface SchemaValidationError {
+  /** Property path (dot-separated for nested) */
+  path: string;
+
+  /** Error message */
+  message: string;
+
+  /** Error code */
+  code: "required" | "type" | "minimum" | "maximum" | "pattern" | "enum" | "custom";
+}
+
+/**
+ * Result of schema validation
+ */
+export interface SchemaValidationResult {
+  valid: boolean;
+  errors: SchemaValidationError[];
+}
+
+// =============================================================================
+// Helper Functions
+// =============================================================================
+
+/**
+ * Infer the appropriate UI component from a schema property
+ */
+export function inferUIComponent(schema: SchemaProperty): string {
+  const hint = schema["x-ui"]?.component;
+  if (hint) return hint;
+
+  switch (schema.type) {
+    case "boolean":
+      return "checkbox";
+    case "string":
+      if ("enum" in schema && schema.enum) return "select";
+      if ("maxLength" in schema && (schema.maxLength ?? 0) > 200) return "textarea";
+      return "input";
+    case "number":
+    case "integer":
+      if ("enum" in schema && schema.enum) return "select";
+      if ("minimum" in schema && "maximum" in schema) return "slider";
+      return "input";
+    case "array":
+      if ("items" in schema && schema.items) {
+        if (schema.items.type === "string" && "enum" in schema.items) {
+          return "multiselect";
+        }
+        if (schema.items.type === "object") return "object-array";
+      }
+      return "tags";
+    case "object":
+      if ("additionalProperties" in schema && schema.additionalProperties) {
+        return "key-value";
+      }
+      return "object";
+    default:
+      return "input";
+  }
+}
+
+/**
+ * Resolve configuration with defaults from schema
+ */
+export function resolveWithDefaults(
+  config: Record<string, unknown>,
+  schema: GuardSettingsSchema
+): Record<string, unknown> {
+  const result: Record<string, unknown> = { ...config };
+
+  for (const [key, prop] of Object.entries(schema.properties)) {
+    if (!(key in result) && prop.default !== undefined) {
+      result[key] = structuredClone(prop.default);
+    }
+  }
+
+  return result;
+}
+
+/**
+ * Get properties sorted by UI order
+ */
+export function getSortedProperties(
+  schema: GuardSettingsSchema
+): Array<[string, SchemaProperty]> {
+  return Object.entries(schema.properties).sort(([, a], [, b]) => {
+    const orderA = a["x-ui"]?.order ?? 999;
+    const orderB = b["x-ui"]?.order ?? 999;
+    return orderA - orderB;
+  });
+}
+
+/**
+ * Group properties by their x-ui.group value
+ */
+export function getGroupedProperties(
+  schema: GuardSettingsSchema
+): Map<string | undefined, Array<[string, SchemaProperty]>> {
+  const groups = new Map<string | undefined, Array<[string, SchemaProperty]>>();
+  const sorted = getSortedProperties(schema);
+
+  for (const entry of sorted) {
+    const group = entry[1]["x-ui"]?.group;
+    if (!groups.has(group)) {
+      groups.set(group, []);
+    }
+    groups.get(group)!.push(entry);
+  }
+
+  return groups;
+}

From ea6b3831de1c49c7bb2058a20ec2f6d1ebbfedc9 Mon Sep 17 00:00:00 2001
From: Alexey Puzik <alexey.puzik@devpulse.io>
Date: Thu, 5 Feb 2026 20:28:18 +0200
Subject: [PATCH 03/10] Expose wasm guards setting to UI WIP2

---
 crates/agentgateway/src/mcp/handler.rs        |  57 +-
 crates/agentgateway/src/mcp/security/mod.rs   |  54 ++
 .../src/mcp/security/native/mod.rs            |  14 +
 crates/agentgateway/src/mcp/security/wasm.rs  |  93 +++
 .../src/mcp/security/wit/guard.wit            |  19 +-
 crates/agentgateway/src/ui.rs                 | 104 +++
 ui/src/app/playground/page.tsx                |  74 +-
 ui/src/components/backend-config.tsx          |   7 +
 .../components/backend/backend-components.tsx | 653 ++++++++++++++++++
 .../playground/CapabilitiesList.tsx           |  16 +-
 ui/src/components/schema-form/SchemaField.tsx |   5 +-
 ui/src/components/schema-form/SchemaForm.tsx  |  14 +-
 .../schema-form/fields/InputField.tsx         |  17 +-
 .../schema-form/fields/KeyValueField.tsx      |  10 +-
 .../schema-form/fields/MultiselectField.tsx   |  10 +-
 .../schema-form/fields/ObjectArrayField.tsx   |  21 +-
 .../schema-form/fields/SelectField.tsx        |  19 +-
 .../schema-form/fields/SliderField.tsx        |  13 +-
 .../schema-form/fields/TagsField.tsx          |  13 +-
 .../schema-form/fields/TextareaField.tsx      |   4 +-
 ui/src/hooks/useGuardSchemas.ts               |  31 +-
 ui/src/lib/backend-constants.ts               | 229 +++++-
 ui/src/lib/backend-hooks.ts                   |  46 +-
 ui/src/lib/backend-utils.ts                   | 243 +++++--
 ui/src/lib/guard-schema-types.ts              |  11 +-
 ui/src/lib/types.ts                           | 151 ++--
 26 files changed, 1565 insertions(+), 363 deletions(-)

diff --git a/crates/agentgateway/src/mcp/handler.rs b/crates/agentgateway/src/mcp/handler.rs
index f39bd4c29..97f8d67c3 100644
--- a/crates/agentgateway/src/mcp/handler.rs
+++ b/crates/agentgateway/src/mcp/handler.rs
@@ -65,60 +65,9 @@ impl Relay {
 		} else {
 			Some(backend.targets[0].name.to_string())
 		};
-		// Evaluate connection guards BEFORE establishing connections
-		// This allows blocking connections to malicious/unknown servers
-		for target in &backend.targets {
-			// Get server URL from backend (SimpleBackend uses hostport() method)
-			let server_url_string = target.backend.as_ref().map(|b| b.hostport());
-			let server_url = server_url_string.as_deref();
-			let context = crate::mcp::security::GuardContext {
-				server_name: target.name.to_string(),
-				identity: None,
-				metadata: serde_json::Value::Null,
-			};
-
-			match security_guards.evaluate_connection(&target.name, server_url, &context) {
-				Ok(crate::mcp::security::GuardDecision::Allow) => {
-					tracing::debug!(
-						target = %target.name,
-						"Connection guard allowed"
-					);
-				},
-				Ok(crate::mcp::security::GuardDecision::Deny(reason)) => {
-					tracing::warn!(
-						target = %target.name,
-						code = %reason.code,
-						message = %reason.message,
-						"Connection guard denied - blocking connection"
-					);
-					return Err(anyhow::anyhow!(
-						"Connection to {} blocked by security guard: {} - {}",
-						target.name,
-						reason.code,
-						reason.message
-					));
-				},
-				Ok(crate::mcp::security::GuardDecision::Modify(_)) => {
-					// Modify not applicable for connection phase
-					tracing::debug!(
-						target = %target.name,
-						"Connection guard returned Modify (treating as Allow)"
-					);
-				},
-				Err(e) => {
-					tracing::error!(
-						target = %target.name,
-						error = %e,
-						"Connection guard error"
-					);
-					return Err(anyhow::anyhow!(
-						"Connection guard failed for {}: {}",
-						target.name,
-						e
-					));
-				},
-			}
-		}
+		// TODO: Evaluate connection guards BEFORE establishing connections.
+		// This requires wiring GuardExecutorRegistry into Relay::new().
+		// When integrated, guards will inspect each target and block malicious/unknown servers.
 
 		Ok(Self {
 			upstreams: Arc::new(upstream::UpstreamGroup::new(client, backend)?),
diff --git a/crates/agentgateway/src/mcp/security/mod.rs b/crates/agentgateway/src/mcp/security/mod.rs
index 0b367c704..3b2e8ff6f 100644
--- a/crates/agentgateway/src/mcp/security/mod.rs
+++ b/crates/agentgateway/src/mcp/security/mod.rs
@@ -307,6 +307,30 @@ impl GuardExecutorRegistry {
 		let executors = self.executors.read().expect("registry lock poisoned");
 		executors.keys().cloned().collect()
 	}
+
+	/// Collect schemas from all WASM guards across all backends.
+	/// Returns a map of guard_id -> (settings_schema_json, default_config_json).
+	pub fn collect_wasm_schemas(&self) -> HashMap<String, WasmGuardSchema> {
+		let executors = self.executors.read().expect("registry lock poisoned");
+		let mut schemas = HashMap::new();
+
+		for (_backend_name, executor) in executors.iter() {
+			for entry in executor.collect_guard_schemas() {
+				schemas.insert(entry.0, entry.1);
+			}
+		}
+
+		schemas
+	}
+}
+
+/// Schema information returned by a WASM guard
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct WasmGuardSchema {
+	/// JSON Schema describing guard's configurable parameters
+	pub settings_schema: serde_json::Value,
+	/// Default configuration values
+	pub default_config: serde_json::Value,
 }
 
 /// Guard executor that manages and executes security guards in priority order
@@ -637,6 +661,36 @@ impl GuardExecutor {
 		f()
 	}
 
+	/// Collect schemas from guards that support dynamic schema export (WASM guards).
+	/// Returns a list of (guard_id, WasmGuardSchema) pairs.
+	pub fn collect_guard_schemas(&self) -> Vec<(String, WasmGuardSchema)> {
+		let guards = self.guards.read().expect("guards lock poisoned");
+		let mut schemas = Vec::new();
+
+		for guard_entry in guards.iter() {
+			if let Some(schema_json) = guard_entry.guard.get_settings_schema() {
+				let settings_schema: serde_json::Value =
+					serde_json::from_str(&schema_json).unwrap_or(serde_json::Value::Null);
+
+				let default_config: serde_json::Value = guard_entry
+					.guard
+					.get_default_config()
+					.and_then(|s| serde_json::from_str(&s).ok())
+					.unwrap_or(serde_json::Value::Object(serde_json::Map::new()));
+
+				schemas.push((
+					guard_entry.config.id.clone(),
+					WasmGuardSchema {
+						settings_schema,
+						default_config,
+					},
+				));
+			}
+		}
+
+		schemas
+	}
+
 	/// Reset state for a server (called on session re-initialization)
 	/// This clears any per-server state like baselines in guards.
 	pub fn reset_server(&self, server_name: &str) {
diff --git a/crates/agentgateway/src/mcp/security/native/mod.rs b/crates/agentgateway/src/mcp/security/native/mod.rs
index 1cb767594..91f686e6b 100644
--- a/crates/agentgateway/src/mcp/security/native/mod.rs
+++ b/crates/agentgateway/src/mcp/security/native/mod.rs
@@ -94,6 +94,20 @@ pub trait NativeGuard: Send + Sync {
         // Default: no-op (most guards are stateless)
         let _ = server_name;
     }
+
+    /// Get JSON Schema describing this guard's configurable parameters.
+    /// Returns None for native guards (schemas are embedded in the UI).
+    /// WASM guards override this to call the guest module's get-settings-schema.
+    fn get_settings_schema(&self) -> Option<String> {
+        None
+    }
+
+    /// Get default configuration as JSON.
+    /// Returns None for native guards.
+    /// WASM guards override this to call the guest module's get-default-config.
+    fn get_default_config(&self) -> Option<String> {
+        None
+    }
 }
 
 /// Helper: Build regex set from patterns
diff --git a/crates/agentgateway/src/mcp/security/wasm.rs b/crates/agentgateway/src/mcp/security/wasm.rs
index 0647f5f9e..058924395 100644
--- a/crates/agentgateway/src/mcp/security/wasm.rs
+++ b/crates/agentgateway/src/mcp/security/wasm.rs
@@ -400,6 +400,71 @@ impl WasmGuard {
 
         result
     }
+
+    /// Call a no-argument WASM function that returns a string.
+    /// Used for get-settings-schema and get-default-config.
+    fn call_string_func(&self, func_name: &str) -> Result<String, GuardError> {
+        stacker::grow(8 * 1024 * 1024, || {
+            let linker = self.create_linker()?;
+            let state = WasmState::new(self.config.config.clone());
+            let mut store = Store::new(&self.engine, state);
+
+            let instance = linker
+                .instantiate(&mut store, &self.component)
+                .map_err(|e| GuardError::WasmError(format!("Failed to instantiate component: {}", e)))?;
+
+            let guard_export_idx = instance
+                .get_export(&mut store, None, "mcp:security-guard/guard@0.1.0")
+                .ok_or_else(|| {
+                    GuardError::WasmError(
+                        "Guard interface not found in component exports".to_string(),
+                    )
+                })?;
+
+            let func_export_idx = instance
+                .get_export(&mut store, Some(&guard_export_idx), func_name)
+                .ok_or_else(|| {
+                    GuardError::WasmError(format!(
+                        "Function {} not found in guard interface",
+                        func_name
+                    ))
+                })?;
+
+            let func = instance
+                .get_func(&mut store, &func_export_idx)
+                .ok_or_else(|| {
+                    GuardError::WasmError(
+                        "Could not get function from export index".to_string(),
+                    )
+                })?;
+
+            let mut results = vec![Val::Bool(false)]; // Placeholder
+            func.call(&mut store, &[], &mut results)
+                .map_err(|e| GuardError::WasmError(format!("WASM function call failed: {}", e)))?;
+
+            func.post_return(&mut store)
+                .map_err(|e| GuardError::WasmError(format!("WASM post-return failed: {}", e)))?;
+
+            match &results[0] {
+                Val::String(s) => Ok(s.to_string()),
+                other => Err(GuardError::WasmError(format!(
+                    "Expected string from {}, got: {:?}",
+                    func_name, other
+                ))),
+            }
+        })
+    }
+
+    /// Get the JSON Schema describing this guard's configurable parameters.
+    /// Returns JSON-serialized JSON Schema (Draft 2020-12).
+    pub fn get_settings_schema(&self) -> Result<String, GuardError> {
+        self.call_string_func("get-settings-schema")
+    }
+
+    /// Get the default configuration as JSON.
+    pub fn get_default_config(&self) -> Result<String, GuardError> {
+        self.call_string_func("get-default-config")
+    }
 }
 
 #[cfg(feature = "wasm-guards")]
@@ -650,6 +715,34 @@ impl NativeGuard for WasmGuard {
             "WASM guard reset_server called (no-op)"
         );
     }
+
+    fn get_settings_schema(&self) -> Option<String> {
+        match self.call_string_func("get-settings-schema") {
+            Ok(schema) => Some(schema),
+            Err(e) => {
+                tracing::warn!(
+                    guard_id = %self.guard_id,
+                    error = %e,
+                    "Failed to get settings schema from WASM guard"
+                );
+                None
+            }
+        }
+    }
+
+    fn get_default_config(&self) -> Option<String> {
+        match self.call_string_func("get-default-config") {
+            Ok(config) => Some(config),
+            Err(e) => {
+                tracing::warn!(
+                    guard_id = %self.guard_id,
+                    error = %e,
+                    "Failed to get default config from WASM guard"
+                );
+                None
+            }
+        }
+    }
 }
 
 // Non-wasm-guards feature: provide stub implementation
diff --git a/crates/agentgateway/src/mcp/security/wit/guard.wit b/crates/agentgateway/src/mcp/security/wit/guard.wit
index 5b06c5d46..e3d7d1771 100644
--- a/crates/agentgateway/src/mcp/security/wit/guard.wit
+++ b/crates/agentgateway/src/mcp/security/wit/guard.wit
@@ -17,6 +17,7 @@ interface guard {
     /// Context provided by the host
     record guard-context {
         server-name: string,
+        server-url: option<string>,
         identity: option<string>,
         metadata: string,  /// JSON-serialized metadata
     }
@@ -25,7 +26,8 @@ interface guard {
     variant decision {
         allow,
         deny(deny-reason),
-        modify(string),  /// JSON-serialized modification
+        modify(string),  /// JSON-serialized modification (for PII masking, etc.)
+        warn(list<string>),  /// Allow with warnings
     }
 
     /// Reason for denying a request
@@ -35,9 +37,20 @@ interface guard {
         details: option<string>,  /// JSON-serialized details
     }
 
-    /// Main guard evaluation function
-    /// Called by the host for every tools/list response
+    /// Evaluate server connection before establishing
+    evaluate-server-connection: func(context: guard-context) -> result<decision, string>;
+
+    /// Evaluate tools/list response
     evaluate-tools-list: func(tools: list<tool>, context: guard-context) -> result<decision, string>;
+
+    /// Get JSON Schema describing guard's configurable parameters
+    /// Returns JSON-serialized JSON Schema (Draft 2020-12)
+    /// Schema describes guard-specific settings only (not common settings like priority, timeout)
+    get-settings-schema: func() -> string;
+
+    /// Get default configuration as JSON
+    /// Returns JSON-serialized default config values
+    get-default-config: func() -> string;
 }
 
 /// Host interface - functions provided by AgentGateway to the WASM module
diff --git a/crates/agentgateway/src/ui.rs b/crates/agentgateway/src/ui.rs
index 614186350..71b74e053 100644
--- a/crates/agentgateway/src/ui.rs
+++ b/crates/agentgateway/src/ui.rs
@@ -17,7 +17,9 @@ use tower_http::cors::CorsLayer;
 use tower_serve_static::ServeDir;
 
 use crate::management::admin::{AdminFallback, AdminResponse};
+use crate::mcp::security::McpGuardKind;
 use crate::{Config, ConfigSource, client, yamlviajson};
+
 pub struct UiHandler {
 	router: Router,
 }
@@ -49,6 +51,7 @@ impl UiHandler {
 		let router = Router::new()
 			// Redirect to the UI
 			.route("/config", get(get_config).post(write_config))
+			.route("/api/v1/guards/schemas", get(get_guard_schemas))
 			.nest_service("/ui", ui_service)
 			.route("/", get(|| async { Redirect::permanent("/ui") }))
 			.layer(add_cors_layer())
@@ -128,6 +131,107 @@ async fn write_config(
 	))
 }
 
+/// GET /api/v1/guards/schemas
+/// Returns JSON Schemas for all guards (native schemas are embedded in the frontend;
+/// WASM guard schemas are extracted by loading each WASM module and calling get-settings-schema).
+async fn get_guard_schemas(State(app): State<App>) -> Result<Json<Value>, ErrorResponse> {
+	let mut schemas = serde_json::Map::new();
+
+	// Read config to find WASM guards
+	if let Ok(cfg_source) = app.cfg() {
+		if let Ok(yaml_str) = cfg_source.read_to_string().await {
+			if let Ok(config_val) = yamlviajson::from_str::<Value>(&yaml_str) {
+				collect_wasm_schemas_from_config(&config_val, &mut schemas);
+			}
+		}
+	}
+
+	Ok(Json(serde_json::json!({
+		"schemas": schemas,
+	})))
+}
+
+/// Walk the config JSON to find WASM guard entries and extract their schemas.
+/// Returns schemas keyed by x-guard-meta.guardType (or guard id as fallback),
+/// matching the GuardSchemasResponse format expected by the frontend.
+#[allow(unused_variables)]
+fn collect_wasm_schemas_from_config(
+	config: &Value,
+	schemas: &mut serde_json::Map<String, Value>,
+) {
+	// Navigate: backends[] -> mcp -> security_guards[]
+	let Some(backends) = config.get("backends").and_then(|v| v.as_array()) else {
+		return;
+	};
+
+	for backend in backends {
+		let Some(mcp) = backend.get("mcp") else {
+			continue;
+		};
+		let Some(guards) = mcp.get("security_guards").and_then(|v| v.as_array()) else {
+			continue;
+		};
+
+		for guard_val in guards {
+			let Some(guard_type) = guard_val.get("type").and_then(|v| v.as_str()) else {
+				continue;
+			};
+			if guard_type != "wasm" {
+				continue;
+			}
+
+			let Some(guard_id) = guard_val.get("id").and_then(|v| v.as_str()) else {
+				continue;
+			};
+
+			// Try to deserialize as McpGuardKind to get WasmGuardConfig
+			if let Ok(kind) = serde_json::from_value::<McpGuardKind>(guard_val.clone()) {
+				#[cfg(feature = "wasm-guards")]
+				if let McpGuardKind::Wasm(wasm_cfg) = kind {
+					match crate::mcp::security::wasm::WasmGuard::new(
+						guard_id.to_string(),
+						wasm_cfg,
+					) {
+						Ok(wasm_guard) => {
+							if let Ok(schema_str) = wasm_guard.get_settings_schema() {
+								if let Ok(schema_val) =
+									serde_json::from_str::<Value>(&schema_str)
+								{
+									// Use x-guard-meta.guardType as key, fall back to guard id
+									let schema_key = schema_val
+										.get("x-guard-meta")
+										.and_then(|m| m.get("guardType"))
+										.and_then(|v| v.as_str())
+										.unwrap_or(guard_id)
+										.to_string();
+
+									schemas.insert(schema_key, schema_val);
+								}
+							}
+						}
+						Err(e) => {
+							tracing::warn!(
+								guard_id = guard_id,
+								error = %e,
+								"Failed to load WASM guard for schema extraction"
+							);
+						}
+					}
+				}
+
+				#[cfg(not(feature = "wasm-guards"))]
+				{
+					let _ = kind;
+					tracing::debug!(
+						guard_id = guard_id,
+						"WASM guards feature not enabled, skipping schema extraction"
+					);
+				}
+			}
+		}
+	}
+}
+
 pub fn add_cors_layer() -> CorsLayer {
 	CorsLayer::new()
 		.allow_origin(
diff --git a/ui/src/app/playground/page.tsx b/ui/src/app/playground/page.tsx
index c06df7eeb..2707aaa31 100644
--- a/ui/src/app/playground/page.tsx
+++ b/ui/src/app/playground/page.tsx
@@ -2,7 +2,7 @@
 
 import { useState, useEffect, useCallback } from "react";
 import { Client as McpClient } from "@modelcontextprotocol/sdk/client/index.js";
-import { SSEClientTransport as McpSseTransport } from "@modelcontextprotocol/sdk/client/sse.js";
+import { StreamableHTTPClientTransport as McpHttpTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
 import {
   ClientRequest as McpClientRequest,
   Result as McpResult,
@@ -247,9 +247,21 @@ export default function PlaygroundPage() {
         if (listener.routes) {
           listener.routes.forEach((route: Route, routeIndex: number) => {
             const protocol = listener.protocol === ListenerProtocol.HTTPS ? "https" : "http";
-            const hostname = listener.hostname || "localhost";
-            const port = bind.port; // Use the actual port from the bind configuration
-            const baseEndpoint = `${protocol}://${hostname}:${port}`;
+            // Use window.location.hostname when listener hostname is not set
+            // This ensures the UI connects to the correct domain in deployed environments
+            const hostname =
+              listener.hostname ||
+              (typeof window !== "undefined" ? window.location.hostname : "localhost");
+            const configPort = bind.port;
+            // Local dev: browser URL has explicit port (e.g., 127.0.0.1:15000) -> use config port for routes
+            // Deployed (Azure): browser URL has no port (standard 80/443) -> use origin (ingress handles routing)
+            // Drawback: if Azure exposed non-standard port, this would break (uncommon scenario)
+            const hasExplicitPort = typeof window !== "undefined" && window.location.port !== "";
+            const baseEndpoint = hasExplicitPort
+              ? `${protocol}://${hostname}:${configPort}`
+              : typeof window !== "undefined"
+                ? window.location.origin
+                : `${protocol}://${hostname}:${configPort}`;
 
             // Generate route path and description with better pattern recognition
             let routePath = "/";
@@ -464,18 +476,10 @@ export default function PlaygroundPage() {
           headers["Authorization"] = `Bearer ${connectionState.authToken}`;
         }
 
-        const sseUrl = selectedRoute.endpoint.endsWith("/")
-          ? `${selectedRoute.endpoint}sse`
-          : `${selectedRoute.endpoint}/sse`;
-        const transport = new McpSseTransport(new URL(sseUrl), {
-          eventSourceInit: {
-            fetch: (url, init) => {
-              return fetch(url, {
-                ...init,
-                headers: headers as HeadersInit,
-              });
-            },
-          },
+        const mcpUrl = selectedRoute.endpoint.endsWith("/")
+          ? selectedRoute.endpoint.slice(0, -1)
+          : selectedRoute.endpoint;
+        const transport = new McpHttpTransport(new URL(mcpUrl), {
           requestInit: {
             headers: headers as HeadersInit,
             credentials: "omit",
@@ -485,13 +489,15 @@ export default function PlaygroundPage() {
 
         await client.connect(transport);
         setMcpState((prev) => ({ ...prev, client }));
-        setConnectionState((prev) => ({ ...prev, isConnected: true }));
-        toast.success("Connected to MCP endpoint");
 
         setUiState((prev) => ({ ...prev, isLoadingCapabilities: true }));
         const listToolsRequest: McpClientRequest = { method: "tools/list", params: {} };
         const toolsResponse = await client.request(listToolsRequest, McpListToolsResultSchema);
         setMcpState((prev) => ({ ...prev, tools: toolsResponse.tools }));
+
+        // Only mark as connected and show success after tools are loaded successfully
+        setConnectionState((prev) => ({ ...prev, isConnected: true }));
+        toast.success("Connected to MCP endpoint");
       } else if (backendType === "a2a") {
         // Connect to A2A endpoint
         setConnectionState((prev) => ({ ...prev, connectionType: "a2a" }));
@@ -740,11 +746,14 @@ export default function PlaygroundPage() {
           arguments: mcpState.paramValues,
         },
       };
+
       const result = await mcpState.client.request(request, McpToolResponseSchema);
+
       setMcpState((prev) => ({ ...prev, response: result }));
       toast.success(`Tool ${mcpState.selectedTool?.name} executed.`);
     } catch (error: any) {
-      const message = error instanceof McpError ? error.message : "Failed to run tool";
+      const message =
+        error instanceof McpError ? error.message : error?.message || "Failed to run tool";
       setMcpState((prev) => ({ ...prev, response: { error: message, details: error } }));
       toast.error(message);
     } finally {
@@ -752,6 +761,29 @@ export default function PlaygroundPage() {
     }
   };
 
+  const refreshMcpTools = async () => {
+    if (!mcpState.client) return;
+
+    setUiState((prev) => ({ ...prev, isLoadingCapabilities: true }));
+    try {
+      // Call tools/list through the existing gateway connection
+      // The gateway will re-fetch from all configured MCP targets
+      const listToolsRequest: McpClientRequest = { method: "tools/list", params: {} };
+      const toolsResponse = await mcpState.client.request(
+        listToolsRequest,
+        McpListToolsResultSchema
+      );
+      setMcpState((prev) => ({ ...prev, tools: toolsResponse.tools }));
+      toast.success(`Refreshed tools list (${toolsResponse.tools.length} tools)`);
+    } catch (error: any) {
+      const message =
+        error instanceof McpError ? error.message : error?.message || "Failed to refresh tools";
+      toast.error(message);
+    } finally {
+      setUiState((prev) => ({ ...prev, isLoadingCapabilities: false }));
+    }
+  };
+
   const handleA2aSkillSelect = (skill: AgentSkill) => {
     setA2aState((prev) => ({ ...prev, selectedSkill: skill, response: null, message: "" }));
     setMcpState((prev) => ({ ...prev, response: null }));
@@ -1065,8 +1097,7 @@ export default function PlaygroundPage() {
                     <span className="font-medium text-sm">Request URL</span>
                   </div>
                   <div className="font-mono text-sm break-all">
-                    {selectedRoute.protocol}://{selectedRoute.listener.hostname || "localhost"}:
-                    {selectedRoute.bindPort}
+                    {selectedRoute.endpoint}
                     {request.path}
                   </div>
                 </div>
@@ -1436,6 +1467,7 @@ export default function PlaygroundPage() {
             selectedA2aSkillId={a2aState.selectedSkill?.id ?? null}
             onMcpToolSelect={handleMcpToolSelect}
             onA2aSkillSelect={handleA2aSkillSelect}
+            onRefreshMcpTools={refreshMcpTools}
           />
 
           <ActionPanel
diff --git a/ui/src/components/backend-config.tsx b/ui/src/components/backend-config.tsx
index cb79a4d92..68642128e 100644
--- a/ui/src/components/backend-config.tsx
+++ b/ui/src/components/backend-config.tsx
@@ -35,6 +35,10 @@ export function BackendConfig() {
     updateMcpTarget,
     parseAndUpdateUrl,
     updateMcpStateful,
+    // Security guard management
+    addSecurityGuard,
+    removeSecurityGuard,
+    updateSecurityGuardField,
   } = useBackendFormState();
 
   const {
@@ -145,6 +149,9 @@ export function BackendConfig() {
         updateMcpTarget={updateMcpTarget}
         parseAndUpdateUrl={parseAndUpdateUrl}
         updateMcpStateful={updateMcpStateful}
+        addSecurityGuard={addSecurityGuard}
+        removeSecurityGuard={removeSecurityGuard}
+        updateSecurityGuardField={updateSecurityGuardField}
       />
     </div>
   );
diff --git a/ui/src/components/backend/backend-components.tsx b/ui/src/components/backend/backend-components.tsx
index b21d04603..8dce69786 100644
--- a/ui/src/components/backend/backend-components.tsx
+++ b/ui/src/components/backend/backend-components.tsx
@@ -45,6 +45,11 @@ import {
   Loader2,
   Shield,
   AlertTriangle,
+  Eye,
+  Copy,
+  CheckCircle,
+  ShieldAlert,
+  Code,
 } from "lucide-react";
 import { Bind } from "@/lib/types";
 import { BackendWithContext } from "@/lib/backend-hooks";
@@ -55,7 +60,14 @@ import {
   HOST_TYPES,
   AI_MODEL_PLACEHOLDERS,
   AI_REGION_PLACEHOLDERS,
+  SECURITY_GUARD_TYPES,
+  GUARD_PHASES,
+  FAILURE_MODES,
+  PII_TYPES,
+  PII_ACTIONS,
+  SCAN_FIELDS,
 } from "@/lib/backend-constants";
+import type { SecurityGuard, SecurityGuardType } from "@/lib/types";
 import {
   getBackendType,
   getBackendName,
@@ -339,6 +351,10 @@ interface AddBackendDialogProps {
   updateMcpTarget: (index: number, field: string, value: any) => void;
   parseAndUpdateUrl: (index: number, url: string) => void;
   updateMcpStateful: (stateful: boolean) => void;
+  // Security guard management
+  addSecurityGuard: (type: SecurityGuardType) => void;
+  removeSecurityGuard: (index: number) => void;
+  updateSecurityGuardField: (index: number, field: string, value: any) => void;
 }
 
 export const AddBackendDialog: React.FC<AddBackendDialogProps> = ({
@@ -358,6 +374,9 @@ export const AddBackendDialog: React.FC<AddBackendDialogProps> = ({
   updateMcpTarget,
   parseAndUpdateUrl,
   updateMcpStateful,
+  addSecurityGuard,
+  removeSecurityGuard,
+  updateSecurityGuardField,
 }) => {
   return (
     <Dialog open={open} onOpenChange={onOpenChange}>
@@ -511,6 +530,9 @@ export const AddBackendDialog: React.FC<AddBackendDialogProps> = ({
               updateMcpTarget={updateMcpTarget}
               parseAndUpdateUrl={parseAndUpdateUrl}
               updateMcpStateful={updateMcpStateful}
+              addSecurityGuard={addSecurityGuard}
+              removeSecurityGuard={removeSecurityGuard}
+              updateSecurityGuardField={updateSecurityGuardField}
             />
           )}
 
@@ -655,6 +677,623 @@ const HostBackendForm: React.FC<HostBackendFormProps> = ({ backendForm, setBacke
   </div>
 );
 
+// Security Guard icon mapping
+const getSecurityGuardIcon = (type: SecurityGuardType) => {
+  switch (type) {
+    case "pii":
+      return <Eye className="h-4 w-4" />;
+    case "tool_poisoning":
+      return <ShieldAlert className="h-4 w-4" />;
+    case "rug_pull":
+      return <AlertTriangle className="h-4 w-4" />;
+    case "tool_shadowing":
+      return <Copy className="h-4 w-4" />;
+    case "server_whitelist":
+      return <CheckCircle className="h-4 w-4" />;
+    case "wasm":
+      return <Code className="h-4 w-4" />;
+    default:
+      return <Shield className="h-4 w-4" />;
+  }
+};
+
+// Security Guards Section Component
+interface SecurityGuardsSectionProps {
+  guards: SecurityGuard[];
+  addSecurityGuard: (type: SecurityGuardType) => void;
+  removeSecurityGuard: (index: number) => void;
+  updateSecurityGuardField: (index: number, field: string, value: any) => void;
+}
+
+const SecurityGuardsSection: React.FC<SecurityGuardsSectionProps> = ({
+  guards,
+  addSecurityGuard,
+  removeSecurityGuard,
+  updateSecurityGuardField,
+}) => {
+  const [isExpanded, setIsExpanded] = React.useState(guards.length > 0);
+  const [expandedGuards, setExpandedGuards] = React.useState<Set<number>>(new Set());
+
+  const toggleGuardExpanded = (index: number) => {
+    setExpandedGuards((prev) => {
+      const next = new Set(prev);
+      if (next.has(index)) {
+        next.delete(index);
+      } else {
+        next.add(index);
+      }
+      return next;
+    });
+  };
+
+  return (
+    <Collapsible open={isExpanded} onOpenChange={setIsExpanded}>
+      <div className="flex items-center justify-between py-2">
+        <CollapsibleTrigger asChild>
+          <Button variant="ghost" size="sm" className="p-0 hover:bg-transparent">
+            {isExpanded ? (
+              <ChevronDown className="h-4 w-4 mr-2" />
+            ) : (
+              <ChevronRight className="h-4 w-4 mr-2" />
+            )}
+            <Shield className="h-4 w-4 mr-2" />
+            <span className="font-medium">Security Guards</span>
+            {guards.length > 0 && (
+              <Badge variant="secondary" className="ml-2">
+                {guards.length}
+              </Badge>
+            )}
+          </Button>
+        </CollapsibleTrigger>
+        <Select onValueChange={(value) => addSecurityGuard(value as SecurityGuardType)}>
+          <SelectTrigger className="w-[160px]">
+            <Plus className="h-3 w-3 mr-1" />
+            <span>Add Guard</span>
+          </SelectTrigger>
+          <SelectContent>
+            {SECURITY_GUARD_TYPES.map(({ value, label }) => (
+              <SelectItem key={value} value={value}>
+                <div className="flex items-center gap-2">
+                  {getSecurityGuardIcon(value)}
+                  <span>{label}</span>
+                </div>
+              </SelectItem>
+            ))}
+          </SelectContent>
+        </Select>
+      </div>
+
+      <CollapsibleContent className="space-y-3">
+        {guards.length === 0 ? (
+          <div className="text-center py-6 border-2 border-dashed border-muted rounded-md">
+            <Shield className="mx-auto h-8 w-8 text-muted-foreground mb-2" />
+            <p className="text-sm text-muted-foreground">No security guards configured</p>
+            <p className="text-xs text-muted-foreground">
+              Add guards to protect MCP communications
+            </p>
+          </div>
+        ) : (
+          guards.map((guard, index) => (
+            <Card key={index} className="p-3">
+              <div className="space-y-3">
+                {/* Guard Header */}
+                <div className="flex items-center justify-between">
+                  <div className="flex items-center gap-2">
+                    <Button
+                      type="button"
+                      variant="ghost"
+                      size="sm"
+                      className="p-0 h-auto"
+                      onClick={() => toggleGuardExpanded(index)}
+                    >
+                      {expandedGuards.has(index) ? (
+                        <ChevronDown className="h-4 w-4" />
+                      ) : (
+                        <ChevronRight className="h-4 w-4" />
+                      )}
+                    </Button>
+                    <Badge variant="outline" className="flex items-center gap-1">
+                      {getSecurityGuardIcon(guard.type)}
+                      {SECURITY_GUARD_TYPES.find((t) => t.value === guard.type)?.label ||
+                        guard.type}
+                    </Badge>
+                    <span className="text-sm text-muted-foreground">{guard.id}</span>
+                  </div>
+                  <div className="flex items-center gap-2">
+                    <label className="flex items-center gap-1 text-sm cursor-pointer">
+                      <input
+                        type="checkbox"
+                        checked={guard.enabled}
+                        onChange={(e) =>
+                          updateSecurityGuardField(index, "enabled", e.target.checked)
+                        }
+                        className="form-checkbox h-4 w-4"
+                      />
+                      Enabled
+                    </label>
+                    <Button
+                      type="button"
+                      variant="ghost"
+                      size="sm"
+                      onClick={() => removeSecurityGuard(index)}
+                      className="text-destructive hover:text-destructive"
+                    >
+                      <Trash2 className="h-3 w-3" />
+                    </Button>
+                  </div>
+                </div>
+
+                {/* Guard Configuration (expandable) */}
+                {expandedGuards.has(index) && (
+                  <div className="space-y-4 pt-2 border-t">
+                    {/* Common Fields */}
+                    <div className="grid grid-cols-2 gap-3">
+                      <div className="space-y-1">
+                        <Label className="text-xs">Guard ID *</Label>
+                        <Input
+                          value={guard.id}
+                          onChange={(e) => updateSecurityGuardField(index, "id", e.target.value)}
+                          placeholder="my-guard"
+                          className="h-8 text-sm"
+                        />
+                      </div>
+                      <div className="space-y-1">
+                        <Label className="text-xs">Priority (0-100)</Label>
+                        <Input
+                          type="number"
+                          min={0}
+                          max={100}
+                          value={guard.priority}
+                          onChange={(e) =>
+                            updateSecurityGuardField(
+                              index,
+                              "priority",
+                              parseInt(e.target.value) || 0
+                            )
+                          }
+                          className="h-8 text-sm"
+                        />
+                      </div>
+                    </div>
+
+                    <div className="grid grid-cols-2 gap-3">
+                      <div className="space-y-1">
+                        <Label className="text-xs">Timeout (ms)</Label>
+                        <Input
+                          type="number"
+                          min={10}
+                          max={10000}
+                          value={guard.timeout_ms}
+                          onChange={(e) =>
+                            updateSecurityGuardField(
+                              index,
+                              "timeout_ms",
+                              parseInt(e.target.value) || 100
+                            )
+                          }
+                          className="h-8 text-sm"
+                        />
+                      </div>
+                      <div className="space-y-1">
+                        <Label className="text-xs">Failure Mode</Label>
+                        <Select
+                          value={guard.failure_mode}
+                          onValueChange={(value) =>
+                            updateSecurityGuardField(index, "failure_mode", value)
+                          }
+                        >
+                          <SelectTrigger className="h-8 text-sm">
+                            <SelectValue />
+                          </SelectTrigger>
+                          <SelectContent>
+                            {FAILURE_MODES.map(({ value, label }) => (
+                              <SelectItem key={value} value={value}>
+                                {label}
+                              </SelectItem>
+                            ))}
+                          </SelectContent>
+                        </Select>
+                      </div>
+                    </div>
+
+                    {/* Runs On (multi-select as checkboxes) */}
+                    <div className="space-y-1">
+                      <Label className="text-xs">Runs On *</Label>
+                      <div className="flex flex-wrap gap-3">
+                        {GUARD_PHASES.map(({ value, label }) => (
+                          <label
+                            key={value}
+                            className="flex items-center gap-1 text-sm cursor-pointer"
+                          >
+                            <input
+                              type="checkbox"
+                              checked={guard.runs_on.includes(value)}
+                              onChange={(e) => {
+                                const newRunsOn = e.target.checked
+                                  ? [...guard.runs_on, value]
+                                  : guard.runs_on.filter((p) => p !== value);
+                                updateSecurityGuardField(index, "runs_on", newRunsOn);
+                              }}
+                              className="form-checkbox h-4 w-4"
+                            />
+                            {label}
+                          </label>
+                        ))}
+                      </div>
+                    </div>
+
+                    {/* Type-specific configuration */}
+                    {guard.type === "pii" && (
+                      <div className="space-y-3 p-3 bg-muted/50 rounded-md">
+                        <h5 className="text-xs font-medium text-muted-foreground">
+                          PII Detection Settings
+                        </h5>
+                        <div className="space-y-1">
+                          <Label className="text-xs">Detect PII Types *</Label>
+                          <div className="flex flex-wrap gap-2">
+                            {PII_TYPES.map(({ value, label }) => (
+                              <label
+                                key={value}
+                                className="flex items-center gap-1 text-sm cursor-pointer"
+                              >
+                                <input
+                                  type="checkbox"
+                                  checked={guard.detect.includes(value)}
+                                  onChange={(e) => {
+                                    const newDetect = e.target.checked
+                                      ? [...guard.detect, value]
+                                      : guard.detect.filter((t) => t !== value);
+                                    updateSecurityGuardField(index, "detect", newDetect);
+                                  }}
+                                  className="form-checkbox h-4 w-4"
+                                />
+                                {label}
+                              </label>
+                            ))}
+                          </div>
+                        </div>
+                        <div className="grid grid-cols-2 gap-3">
+                          <div className="space-y-1">
+                            <Label className="text-xs">Action</Label>
+                            <Select
+                              value={guard.action}
+                              onValueChange={(value) =>
+                                updateSecurityGuardField(index, "action", value)
+                              }
+                            >
+                              <SelectTrigger className="h-8 text-sm">
+                                <SelectValue />
+                              </SelectTrigger>
+                              <SelectContent>
+                                {PII_ACTIONS.map(({ value, label }) => (
+                                  <SelectItem key={value} value={value}>
+                                    {label}
+                                  </SelectItem>
+                                ))}
+                              </SelectContent>
+                            </Select>
+                          </div>
+                          <div className="space-y-1">
+                            <Label className="text-xs">Min Score (0-1)</Label>
+                            <Input
+                              type="number"
+                              min={0}
+                              max={1}
+                              step={0.1}
+                              value={guard.min_score}
+                              onChange={(e) =>
+                                updateSecurityGuardField(
+                                  index,
+                                  "min_score",
+                                  parseFloat(e.target.value) || 0.3
+                                )
+                              }
+                              className="h-8 text-sm"
+                            />
+                          </div>
+                        </div>
+                        {guard.action === "reject" && (
+                          <div className="space-y-1">
+                            <Label className="text-xs">Rejection Message</Label>
+                            <Input
+                              value={guard.rejection_message || ""}
+                              onChange={(e) =>
+                                updateSecurityGuardField(index, "rejection_message", e.target.value)
+                              }
+                              placeholder="PII detected - request rejected"
+                              className="h-8 text-sm"
+                            />
+                          </div>
+                        )}
+                      </div>
+                    )}
+
+                    {guard.type === "tool_poisoning" && (
+                      <div className="space-y-3 p-3 bg-muted/50 rounded-md">
+                        <h5 className="text-xs font-medium text-muted-foreground">
+                          Tool Poisoning Settings
+                        </h5>
+                        <div className="flex items-center gap-2">
+                          <input
+                            type="checkbox"
+                            checked={guard.strict_mode}
+                            onChange={(e) =>
+                              updateSecurityGuardField(index, "strict_mode", e.target.checked)
+                            }
+                            className="form-checkbox h-4 w-4"
+                          />
+                          <Label className="text-sm cursor-pointer">Strict Mode</Label>
+                        </div>
+                        <div className="space-y-1">
+                          <Label className="text-xs">Scan Fields</Label>
+                          <div className="flex flex-wrap gap-3">
+                            {SCAN_FIELDS.map(({ value, label }) => (
+                              <label
+                                key={value}
+                                className="flex items-center gap-1 text-sm cursor-pointer"
+                              >
+                                <input
+                                  type="checkbox"
+                                  checked={guard.scan_fields.includes(value)}
+                                  onChange={(e) => {
+                                    const newFields = e.target.checked
+                                      ? [...guard.scan_fields, value]
+                                      : guard.scan_fields.filter((f) => f !== value);
+                                    updateSecurityGuardField(index, "scan_fields", newFields);
+                                  }}
+                                  className="form-checkbox h-4 w-4"
+                                />
+                                {label}
+                              </label>
+                            ))}
+                          </div>
+                        </div>
+                        <div className="space-y-1">
+                          <Label className="text-xs">Alert Threshold</Label>
+                          <Input
+                            type="number"
+                            min={1}
+                            value={guard.alert_threshold}
+                            onChange={(e) =>
+                              updateSecurityGuardField(
+                                index,
+                                "alert_threshold",
+                                parseInt(e.target.value) || 1
+                              )
+                            }
+                            className="h-8 text-sm w-24"
+                          />
+                        </div>
+                        <div className="space-y-1">
+                          <Label className="text-xs">Custom Patterns (one per line)</Label>
+                          <textarea
+                            value={guard.custom_patterns.join("\n")}
+                            onChange={(e) =>
+                              updateSecurityGuardField(
+                                index,
+                                "custom_patterns",
+                                e.target.value.split("\n").filter(Boolean)
+                              )
+                            }
+                            placeholder="(?i)SYSTEM:\s*override&#10;(?i)ignore\s+all\s+previous"
+                            className="w-full h-20 px-2 py-1 text-sm border rounded-md"
+                          />
+                        </div>
+                      </div>
+                    )}
+
+                    {guard.type === "rug_pull" && (
+                      <div className="space-y-3 p-3 bg-muted/50 rounded-md">
+                        <h5 className="text-xs font-medium text-muted-foreground">
+                          Rug Pull Settings
+                        </h5>
+                        <div className="space-y-1">
+                          <Label className="text-xs">Risk Threshold</Label>
+                          <Input
+                            type="number"
+                            min={1}
+                            value={guard.risk_threshold}
+                            onChange={(e) =>
+                              updateSecurityGuardField(
+                                index,
+                                "risk_threshold",
+                                parseInt(e.target.value) || 5
+                              )
+                            }
+                            className="h-8 text-sm w-24"
+                          />
+                        </div>
+                      </div>
+                    )}
+
+                    {guard.type === "tool_shadowing" && (
+                      <div className="space-y-3 p-3 bg-muted/50 rounded-md">
+                        <h5 className="text-xs font-medium text-muted-foreground">
+                          Tool Shadowing Settings
+                        </h5>
+                        <div className="flex items-center gap-2">
+                          <input
+                            type="checkbox"
+                            checked={guard.block_duplicates}
+                            onChange={(e) =>
+                              updateSecurityGuardField(index, "block_duplicates", e.target.checked)
+                            }
+                            className="form-checkbox h-4 w-4"
+                          />
+                          <Label className="text-sm cursor-pointer">Block Duplicates</Label>
+                        </div>
+                        <div className="space-y-1">
+                          <Label className="text-xs">Protected Names (one per line)</Label>
+                          <textarea
+                            value={guard.protected_names.join("\n")}
+                            onChange={(e) =>
+                              updateSecurityGuardField(
+                                index,
+                                "protected_names",
+                                e.target.value.split("\n").filter(Boolean)
+                              )
+                            }
+                            placeholder="initialize&#10;tools/list&#10;tools/call"
+                            className="w-full h-20 px-2 py-1 text-sm border rounded-md"
+                          />
+                        </div>
+                      </div>
+                    )}
+
+                    {guard.type === "server_whitelist" && (
+                      <div className="space-y-3 p-3 bg-muted/50 rounded-md">
+                        <h5 className="text-xs font-medium text-muted-foreground">
+                          Server Whitelist Settings
+                        </h5>
+                        <div className="space-y-1">
+                          <Label className="text-xs">Allowed Servers (one per line)</Label>
+                          <textarea
+                            value={guard.allowed_servers.join("\n")}
+                            onChange={(e) =>
+                              updateSecurityGuardField(
+                                index,
+                                "allowed_servers",
+                                e.target.value.split("\n").filter(Boolean)
+                              )
+                            }
+                            placeholder="github-mcp&#10;slack-mcp"
+                            className="w-full h-20 px-2 py-1 text-sm border rounded-md"
+                          />
+                        </div>
+                        <div className="flex items-center gap-2">
+                          <input
+                            type="checkbox"
+                            checked={guard.detect_typosquats}
+                            onChange={(e) =>
+                              updateSecurityGuardField(index, "detect_typosquats", e.target.checked)
+                            }
+                            className="form-checkbox h-4 w-4"
+                          />
+                          <Label className="text-sm cursor-pointer">Detect Typosquats</Label>
+                        </div>
+                        {guard.detect_typosquats && (
+                          <div className="space-y-1">
+                            <Label className="text-xs">Similarity Threshold (0-1)</Label>
+                            <Input
+                              type="number"
+                              min={0}
+                              max={1}
+                              step={0.05}
+                              value={guard.similarity_threshold}
+                              onChange={(e) =>
+                                updateSecurityGuardField(
+                                  index,
+                                  "similarity_threshold",
+                                  parseFloat(e.target.value) || 0.85
+                                )
+                              }
+                              className="h-8 text-sm w-24"
+                            />
+                          </div>
+                        )}
+                      </div>
+                    )}
+
+                    {guard.type === "wasm" && (
+                      <div className="space-y-3 p-3 bg-muted/50 rounded-md">
+                        <h5 className="text-xs font-medium text-muted-foreground">
+                          WASM Guard Settings
+                        </h5>
+                        <div className="space-y-1">
+                          <Label className="text-xs">Module Path *</Label>
+                          <Input
+                            value={guard.module_path}
+                            onChange={(e) =>
+                              updateSecurityGuardField(index, "module_path", e.target.value)
+                            }
+                            placeholder="./path/to/guard.wasm"
+                            className="h-8 text-sm"
+                          />
+                          {guard.module_path && !guard.module_path.endsWith(".wasm") && (
+                            <p className="text-xs text-yellow-600">
+                              Warning: Path should end with .wasm
+                            </p>
+                          )}
+                        </div>
+                        <div className="grid grid-cols-2 gap-3">
+                          <div className="space-y-1">
+                            <Label className="text-xs">Max Memory (MB)</Label>
+                            <Input
+                              type="number"
+                              min={1}
+                              max={1024}
+                              value={Math.round(guard.max_memory_bytes / (1024 * 1024))}
+                              onChange={(e) =>
+                                updateSecurityGuardField(
+                                  index,
+                                  "max_memory_bytes",
+                                  (parseInt(e.target.value) || 10) * 1024 * 1024
+                                )
+                              }
+                              className="h-8 text-sm"
+                            />
+                          </div>
+                          <div className="space-y-1">
+                            <Label className="text-xs">Max Fuel (instructions)</Label>
+                            <Input
+                              type="number"
+                              min={10000}
+                              max={100000000}
+                              step={100000}
+                              value={guard.max_fuel}
+                              onChange={(e) =>
+                                updateSecurityGuardField(
+                                  index,
+                                  "max_fuel",
+                                  parseInt(e.target.value) || 1000000
+                                )
+                              }
+                              className="h-8 text-sm"
+                            />
+                          </div>
+                        </div>
+                        <div className="space-y-1">
+                          <Label className="text-xs">Config (key=value per line)</Label>
+                          <textarea
+                            value={Object.entries(guard.config || {})
+                              .map(([k, v]) => `${k}=${JSON.stringify(v)}`)
+                              .join("\n")}
+                            onChange={(e) => {
+                              const configObj: Record<string, unknown> = {};
+                              e.target.value.split("\n").forEach((line) => {
+                                const eqIdx = line.indexOf("=");
+                                if (eqIdx > 0) {
+                                  const key = line.slice(0, eqIdx).trim();
+                                  const valStr = line.slice(eqIdx + 1).trim();
+                                  try {
+                                    configObj[key] = JSON.parse(valStr);
+                                  } catch {
+                                    configObj[key] = valStr;
+                                  }
+                                }
+                              });
+                              updateSecurityGuardField(index, "config", configObj);
+                            }}
+                            placeholder={'sensitivity="high"\ndeny_threshold=0.5'}
+                            className="w-full h-20 px-2 py-1 text-sm border rounded-md font-mono"
+                          />
+                          <p className="text-xs text-muted-foreground">
+                            Values are JSON-parsed (use quotes for strings)
+                          </p>
+                        </div>
+                      </div>
+                    )}
+                  </div>
+                )}
+              </div>
+            </Card>
+          ))
+        )}
+      </CollapsibleContent>
+    </Collapsible>
+  );
+};
+
 // MCP Backend Form Component
 interface McpBackendFormProps {
   backendForm: typeof DEFAULT_BACKEND_FORM;
@@ -663,6 +1302,9 @@ interface McpBackendFormProps {
   updateMcpTarget: (index: number, field: string, value: any) => void;
   parseAndUpdateUrl: (index: number, url: string) => void;
   updateMcpStateful: (stateful: boolean) => void;
+  addSecurityGuard: (type: SecurityGuardType) => void;
+  removeSecurityGuard: (index: number) => void;
+  updateSecurityGuardField: (index: number, field: string, value: any) => void;
 }
 
 const McpBackendForm: React.FC<McpBackendFormProps> = ({
@@ -672,6 +1314,9 @@ const McpBackendForm: React.FC<McpBackendFormProps> = ({
   updateMcpTarget,
   parseAndUpdateUrl,
   updateMcpStateful,
+  addSecurityGuard,
+  removeSecurityGuard,
+  updateSecurityGuardField,
 }) => (
   <div className="space-y-4">
     <div className="flex items-center justify-between">
@@ -903,6 +1548,14 @@ const McpBackendForm: React.FC<McpBackendFormProps> = ({
         Enable stateful mode
       </Label>
     </div>
+
+    {/* Security Guards */}
+    <SecurityGuardsSection
+      guards={backendForm.securityGuards}
+      addSecurityGuard={addSecurityGuard}
+      removeSecurityGuard={removeSecurityGuard}
+      updateSecurityGuardField={updateSecurityGuardField}
+    />
   </div>
 );
 
diff --git a/ui/src/components/playground/CapabilitiesList.tsx b/ui/src/components/playground/CapabilitiesList.tsx
index e797d7feb..286bca813 100644
--- a/ui/src/components/playground/CapabilitiesList.tsx
+++ b/ui/src/components/playground/CapabilitiesList.tsx
@@ -12,8 +12,9 @@ import {
   TableRow,
 } from "@/components/ui/table";
 import { Badge } from "@/components/ui/badge";
+import { Button } from "@/components/ui/button";
 import { Separator } from "@/components/ui/separator";
-import { Loader2, Bot, Zap, Settings } from "lucide-react";
+import { Loader2, Bot, Zap, Settings, RefreshCw } from "lucide-react";
 
 interface CapabilitiesListProps {
   connectionType: "mcp" | "a2a" | null;
@@ -25,6 +26,7 @@ interface CapabilitiesListProps {
   selectedA2aSkillId: string | null;
   onMcpToolSelect: (tool: McpTool) => void;
   onA2aSkillSelect: (skill: AgentSkill) => void;
+  onRefreshMcpTools?: () => void;
 }
 
 export function CapabilitiesList({
@@ -37,6 +39,7 @@ export function CapabilitiesList({
   selectedA2aSkillId,
   onMcpToolSelect,
   onA2aSkillSelect,
+  onRefreshMcpTools,
 }: CapabilitiesListProps) {
   const title = connectionType === "a2a" ? "Skills" : "Tools";
   const description = `Select a ${title.toLowerCase()} to use`;
@@ -53,6 +56,17 @@ export function CapabilitiesList({
             <Settings className="h-5 w-5" />
           )}
           {connectionType === "a2a" ? a2aAgentCard?.name || "Unknown Agent" : "Available Tools"}
+          {connectionType === "mcp" && onRefreshMcpTools && (
+            <Button
+              variant="ghost"
+              size="icon"
+              className="h-6 w-6 ml-auto"
+              onClick={onRefreshMcpTools}
+              disabled={isLoading}
+            >
+              <RefreshCw className={`h-4 w-4 ${isLoading ? "animate-spin" : ""}`} />
+            </Button>
+          )}
         </CardTitle>
         <CardDescription>
           {connectionType === "a2a" ? a2aAgentCard?.description || "Unknown Agent" : description}
diff --git a/ui/src/components/schema-form/SchemaField.tsx b/ui/src/components/schema-form/SchemaField.tsx
index e40eee1b8..fdf5e35e7 100644
--- a/ui/src/components/schema-form/SchemaField.tsx
+++ b/ui/src/components/schema-form/SchemaField.tsx
@@ -2,10 +2,7 @@
  * SchemaField - Routes schema properties to appropriate field components
  */
 
-import {
-  type SchemaProperty,
-  inferUIComponent,
-} from "@/lib/guard-schema-types";
+import { type SchemaProperty, inferUIComponent } from "@/lib/guard-schema-types";
 import { InputField } from "./fields/InputField";
 import { CheckboxField } from "./fields/CheckboxField";
 import { SelectField } from "./fields/SelectField";
diff --git a/ui/src/components/schema-form/SchemaForm.tsx b/ui/src/components/schema-form/SchemaForm.tsx
index ef972558e..7c77da5a6 100644
--- a/ui/src/components/schema-form/SchemaForm.tsx
+++ b/ui/src/components/schema-form/SchemaForm.tsx
@@ -14,11 +14,7 @@ import {
   getGroupedProperties,
 } from "@/lib/guard-schema-types";
 import { SchemaField } from "./SchemaField";
-import {
-  Collapsible,
-  CollapsibleContent,
-  CollapsibleTrigger,
-} from "@/components/ui/collapsible";
+import { Collapsible, CollapsibleContent, CollapsibleTrigger } from "@/components/ui/collapsible";
 import { Button } from "@/components/ui/button";
 import { ChevronDown, ChevronRight } from "lucide-react";
 
@@ -65,8 +61,8 @@ export function SchemaForm({
   const sortedGroups = useMemo(() => {
     const groups = Array.from(groupedProperties.keys());
     return groups.sort((a, b) => {
-      const orderA = a ? groupDefs[a]?.order ?? 999 : 0;
-      const orderB = b ? groupDefs[b]?.order ?? 999 : 0;
+      const orderA = a ? (groupDefs[a]?.order ?? 999) : 0;
+      const orderB = b ? (groupDefs[b]?.order ?? 999) : 0;
       return orderA - orderB;
     });
   }, [groupedProperties, groupDefs]);
@@ -125,9 +121,7 @@ export function SchemaForm({
                 <div className="border-b pb-2">
                   <h4 className="text-sm font-medium">{groupDef.title}</h4>
                   {groupDef.description && (
-                    <p className="text-xs text-muted-foreground mt-1">
-                      {groupDef.description}
-                    </p>
+                    <p className="text-xs text-muted-foreground mt-1">{groupDef.description}</p>
                   )}
                 </div>
               )}
diff --git a/ui/src/components/schema-form/fields/InputField.tsx b/ui/src/components/schema-form/fields/InputField.tsx
index 1840a56fc..3bee007d6 100644
--- a/ui/src/components/schema-form/fields/InputField.tsx
+++ b/ui/src/components/schema-form/fields/InputField.tsx
@@ -15,14 +15,7 @@ interface InputFieldProps {
   disabled?: boolean;
 }
 
-export function InputField({
-  name,
-  schema,
-  value,
-  onChange,
-  error,
-  disabled,
-}: InputFieldProps) {
+export function InputField({ name, schema, value, onChange, error, disabled }: InputFieldProps) {
   const isNumber = schema.type === "number" || schema.type === "integer";
   const placeholder = schema["x-ui"]?.placeholder;
 
@@ -44,12 +37,8 @@ export function InputField({
 
   return (
     <div className="space-y-2">
-      <Label htmlFor={name}>
-        {schema.title || name}
-      </Label>
-      {schema.description && (
-        <p className="text-xs text-muted-foreground">{schema.description}</p>
-      )}
+      <Label htmlFor={name}>{schema.title || name}</Label>
+      {schema.description && <p className="text-xs text-muted-foreground">{schema.description}</p>}
       <Input
         id={name}
         type={isNumber ? "number" : "text"}
diff --git a/ui/src/components/schema-form/fields/KeyValueField.tsx b/ui/src/components/schema-form/fields/KeyValueField.tsx
index 75a0a0ee2..2d4e59631 100644
--- a/ui/src/components/schema-form/fields/KeyValueField.tsx
+++ b/ui/src/components/schema-form/fields/KeyValueField.tsx
@@ -58,9 +58,7 @@ export function KeyValueField({
   return (
     <div className="space-y-2">
       <Label>{schema.title || name}</Label>
-      {schema.description && (
-        <p className="text-xs text-muted-foreground">{schema.description}</p>
-      )}
+      {schema.description && <p className="text-xs text-muted-foreground">{schema.description}</p>}
       <div className="space-y-2">
         {entries.map(([key, val], index) => (
           <div key={index} className="flex items-center space-x-2">
@@ -79,11 +77,7 @@ export function KeyValueField({
               className="flex-1"
             />
             {!disabled && (
-              <Button
-                variant="ghost"
-                size="sm"
-                onClick={() => removeEntry(key)}
-              >
+              <Button variant="ghost" size="sm" onClick={() => removeEntry(key)}>
                 <Trash2 className="h-4 w-4" />
               </Button>
             )}
diff --git a/ui/src/components/schema-form/fields/MultiselectField.tsx b/ui/src/components/schema-form/fields/MultiselectField.tsx
index 036d4e6d1..c0edc8999 100644
--- a/ui/src/components/schema-form/fields/MultiselectField.tsx
+++ b/ui/src/components/schema-form/fields/MultiselectField.tsx
@@ -4,7 +4,11 @@
 
 import { Checkbox } from "@/components/ui/checkbox";
 import { Label } from "@/components/ui/label";
-import { type SchemaProperty, type ArraySchemaProperty, type StringSchemaProperty } from "@/lib/guard-schema-types";
+import {
+  type SchemaProperty,
+  type ArraySchemaProperty,
+  type StringSchemaProperty,
+} from "@/lib/guard-schema-types";
 
 interface MultiselectFieldProps {
   name: string;
@@ -44,9 +48,7 @@ export function MultiselectField({
   return (
     <div className="space-y-2">
       <Label>{schema.title || name}</Label>
-      {schema.description && (
-        <p className="text-xs text-muted-foreground">{schema.description}</p>
-      )}
+      {schema.description && <p className="text-xs text-muted-foreground">{schema.description}</p>}
       <div className="space-y-2">
         {enumValues.map((enumValue) => (
           <div key={enumValue} className="flex items-center space-x-2">
diff --git a/ui/src/components/schema-form/fields/ObjectArrayField.tsx b/ui/src/components/schema-form/fields/ObjectArrayField.tsx
index dda35a21b..592abe3a9 100644
--- a/ui/src/components/schema-form/fields/ObjectArrayField.tsx
+++ b/ui/src/components/schema-form/fields/ObjectArrayField.tsx
@@ -7,11 +7,7 @@ import { Button } from "@/components/ui/button";
 import { Input } from "@/components/ui/input";
 import { Label } from "@/components/ui/label";
 import { Card, CardContent } from "@/components/ui/card";
-import {
-  Collapsible,
-  CollapsibleContent,
-  CollapsibleTrigger,
-} from "@/components/ui/collapsible";
+import { Collapsible, CollapsibleContent, CollapsibleTrigger } from "@/components/ui/collapsible";
 import { ChevronDown, ChevronRight, Plus, Trash2 } from "lucide-react";
 import {
   type SchemaProperty,
@@ -96,16 +92,11 @@ export function ObjectArrayField({
   return (
     <div className="space-y-2">
       <Label>{schema.title || name}</Label>
-      {schema.description && (
-        <p className="text-xs text-muted-foreground">{schema.description}</p>
-      )}
+      {schema.description && <p className="text-xs text-muted-foreground">{schema.description}</p>}
       <div className="space-y-2">
         {items.map((item, index) => (
           <Card key={index} className="overflow-hidden">
-            <Collapsible
-              open={expandedItems.has(index)}
-              onOpenChange={() => toggleExpanded(index)}
-            >
+            <Collapsible open={expandedItems.has(index)} onOpenChange={() => toggleExpanded(index)}>
               <CollapsibleTrigger asChild>
                 <div className="flex items-center justify-between p-3 cursor-pointer hover:bg-accent/50">
                   <div className="flex items-center gap-2">
@@ -143,7 +134,7 @@ export function ObjectArrayField({
                           <input
                             type="checkbox"
                             id={`${name}-${index}-${key}`}
-                            checked={item[key] as boolean ?? false}
+                            checked={(item[key] as boolean) ?? false}
                             onChange={(e) => updateItem(index, key, e.target.checked)}
                             disabled={disabled}
                             className="h-4 w-4"
@@ -157,7 +148,9 @@ export function ObjectArrayField({
                       ) : (
                         <Input
                           id={`${name}-${index}-${key}`}
-                          type={prop.type === "number" || prop.type === "integer" ? "number" : "text"}
+                          type={
+                            prop.type === "number" || prop.type === "integer" ? "number" : "text"
+                          }
                           value={item[key] !== undefined ? String(item[key]) : ""}
                           onChange={(e) => {
                             const rawValue = e.target.value;
diff --git a/ui/src/components/schema-form/fields/SelectField.tsx b/ui/src/components/schema-form/fields/SelectField.tsx
index 6fd1f93c3..8a90d9580 100644
--- a/ui/src/components/schema-form/fields/SelectField.tsx
+++ b/ui/src/components/schema-form/fields/SelectField.tsx
@@ -10,7 +10,11 @@ import {
   SelectTrigger,
   SelectValue,
 } from "@/components/ui/select";
-import { type SchemaProperty, type StringSchemaProperty, type NumberSchemaProperty } from "@/lib/guard-schema-types";
+import {
+  type SchemaProperty,
+  type StringSchemaProperty,
+  type NumberSchemaProperty,
+} from "@/lib/guard-schema-types";
 
 interface SelectFieldProps {
   name: string;
@@ -21,14 +25,7 @@ interface SelectFieldProps {
   disabled?: boolean;
 }
 
-export function SelectField({
-  name,
-  schema,
-  value,
-  onChange,
-  error,
-  disabled,
-}: SelectFieldProps) {
+export function SelectField({ name, schema, value, onChange, error, disabled }: SelectFieldProps) {
   // Get enum values from schema
   const enumValues: (string | number)[] =
     schema.type === "string"
@@ -49,9 +46,7 @@ export function SelectField({
   return (
     <div className="space-y-2">
       <Label htmlFor={name}>{schema.title || name}</Label>
-      {schema.description && (
-        <p className="text-xs text-muted-foreground">{schema.description}</p>
-      )}
+      {schema.description && <p className="text-xs text-muted-foreground">{schema.description}</p>}
       <Select
         value={value !== undefined ? String(value) : undefined}
         onValueChange={handleChange}
diff --git a/ui/src/components/schema-form/fields/SliderField.tsx b/ui/src/components/schema-form/fields/SliderField.tsx
index 51f5f109b..dc1871ba2 100644
--- a/ui/src/components/schema-form/fields/SliderField.tsx
+++ b/ui/src/components/schema-form/fields/SliderField.tsx
@@ -16,14 +16,7 @@ interface SliderFieldProps {
   disabled?: boolean;
 }
 
-export function SliderField({
-  name,
-  schema,
-  value,
-  onChange,
-  error,
-  disabled,
-}: SliderFieldProps) {
+export function SliderField({ name, schema, value, onChange, error, disabled }: SliderFieldProps) {
   const numSchema = schema as NumberSchemaProperty;
   const min = numSchema.minimum ?? 0;
   const max = numSchema.maximum ?? 100;
@@ -69,9 +62,7 @@ export function SliderField({
           className="w-20 h-7 text-sm text-right"
         />
       </div>
-      {schema.description && (
-        <p className="text-xs text-muted-foreground">{schema.description}</p>
-      )}
+      {schema.description && <p className="text-xs text-muted-foreground">{schema.description}</p>}
       <div className="flex items-center space-x-2">
         <span className="text-xs text-muted-foreground w-8">{min}</span>
         <input
diff --git a/ui/src/components/schema-form/fields/TagsField.tsx b/ui/src/components/schema-form/fields/TagsField.tsx
index e826e82e7..6eef62be3 100644
--- a/ui/src/components/schema-form/fields/TagsField.tsx
+++ b/ui/src/components/schema-form/fields/TagsField.tsx
@@ -18,14 +18,7 @@ interface TagsFieldProps {
   disabled?: boolean;
 }
 
-export function TagsField({
-  name,
-  schema,
-  value,
-  onChange,
-  error,
-  disabled,
-}: TagsFieldProps) {
+export function TagsField({ name, schema, value, onChange, error, disabled }: TagsFieldProps) {
   const [inputValue, setInputValue] = useState("");
   const items = Array.isArray(value) ? value : [];
   const placeholder = schema["x-ui"]?.placeholder || "Type and press Enter";
@@ -61,9 +54,7 @@ export function TagsField({
   return (
     <div className="space-y-2">
       <Label htmlFor={name}>{schema.title || name}</Label>
-      {schema.description && (
-        <p className="text-xs text-muted-foreground">{schema.description}</p>
-      )}
+      {schema.description && <p className="text-xs text-muted-foreground">{schema.description}</p>}
       <div className="space-y-2">
         {items.length > 0 && (
           <div className="flex flex-wrap gap-1">
diff --git a/ui/src/components/schema-form/fields/TextareaField.tsx b/ui/src/components/schema-form/fields/TextareaField.tsx
index 9f21de867..c34a6f568 100644
--- a/ui/src/components/schema-form/fields/TextareaField.tsx
+++ b/ui/src/components/schema-form/fields/TextareaField.tsx
@@ -29,9 +29,7 @@ export function TextareaField({
   return (
     <div className="space-y-2">
       <Label htmlFor={name}>{schema.title || name}</Label>
-      {schema.description && (
-        <p className="text-xs text-muted-foreground">{schema.description}</p>
-      )}
+      {schema.description && <p className="text-xs text-muted-foreground">{schema.description}</p>}
       <Textarea
         id={name}
         value={value ?? ""}
diff --git a/ui/src/hooks/useGuardSchemas.ts b/ui/src/hooks/useGuardSchemas.ts
index 321e80d5f..db5de7b62 100644
--- a/ui/src/hooks/useGuardSchemas.ts
+++ b/ui/src/hooks/useGuardSchemas.ts
@@ -269,10 +269,7 @@ interface UseGuardSchemasResult {
   getSchema: (guardType: string) => GuardSettingsSchema | undefined;
 
   /** Resolve config with defaults from schema */
-  resolveConfig: (
-    guardType: string,
-    config: Record<string, unknown>
-  ) => Record<string, unknown>;
+  resolveConfig: (guardType: string, config: Record<string, unknown>) => Record<string, unknown>;
 
   /** Refresh schemas from API */
   refresh: () => Promise<void>;
@@ -281,12 +278,10 @@ interface UseGuardSchemasResult {
 /**
  * Hook for accessing guard schemas
  *
- * @param fetchFromApi - Whether to fetch schemas from API (default: false, uses embedded)
+ * @param fetchFromApi - Whether to fetch schemas from API (default: true, fetches WASM guard schemas from backend)
  */
-export function useGuardSchemas(fetchFromApi = false): UseGuardSchemasResult {
-  const [schemas, setSchemas] = useState<Record<string, GuardSettingsSchema>>(
-    NATIVE_GUARD_SCHEMAS
-  );
+export function useGuardSchemas(fetchFromApi = true): UseGuardSchemasResult {
+  const [schemas, setSchemas] = useState<Record<string, GuardSettingsSchema>>(NATIVE_GUARD_SCHEMAS);
   const [loading, setLoading] = useState(fetchFromApi);
   const [error, setError] = useState<Error | null>(null);
 
@@ -342,16 +337,14 @@ export function useGuardSchemas(fetchFromApi = false): UseGuardSchemasResult {
     [schemas]
   );
 
-  const availableGuards: GuardTypeSummary[] = Object.entries(schemas).map(
-    ([type, schema]) => ({
-      type,
-      title: schema.title,
-      description: schema.description,
-      category: schema["x-guard-meta"]?.category || "detection",
-      icon: schema["x-guard-meta"]?.icon,
-      isWasm: !NATIVE_GUARD_SCHEMAS[type],
-    })
-  );
+  const availableGuards: GuardTypeSummary[] = Object.entries(schemas).map(([type, schema]) => ({
+    type,
+    title: schema.title,
+    description: schema.description,
+    category: schema["x-guard-meta"]?.category || "detection",
+    icon: schema["x-guard-meta"]?.icon,
+    isWasm: !NATIVE_GUARD_SCHEMAS[type],
+  }));
 
   return {
     schemas,
diff --git a/ui/src/lib/backend-constants.ts b/ui/src/lib/backend-constants.ts
index 614452cd0..9d213c323 100644
--- a/ui/src/lib/backend-constants.ts
+++ b/ui/src/lib/backend-constants.ts
@@ -1,3 +1,19 @@
+import type {
+  SecurityGuardType,
+  FailureMode,
+  GuardPhase,
+  PiiType,
+  PiiAction,
+  ScanField,
+  ToolPoisoningGuard,
+  RugPullGuard,
+  ToolShadowingGuard,
+  ServerWhitelistGuard,
+  PiiGuard,
+  WasmGuard,
+  SecurityGuard,
+} from "./types";
+
 export const DEFAULT_BACKEND_FORM = {
   name: "",
   weight: "1",
@@ -32,34 +48,8 @@ export const DEFAULT_BACKEND_FORM = {
     schema: boolean;
   }>,
   mcpStateful: true,
-  // Security guards for MCP backend (UnitOne Extension)
-  securityGuards: [] as Array<{
-    id: string;
-    description?: string;
-    priority?: number;
-    failureMode?: "fail_closed" | "fail_open";
-    timeoutMs?: number;
-    runsOn?: Array<"request" | "response" | "tools_list" | "tool_invoke">;
-    enabled?: boolean;
-    type: "tool_poisoning" | "rug_pull" | "tool_shadowing" | "server_whitelist" | "pii" | "wasm";
-    // Type-specific config
-    strictMode?: boolean;
-    customPatterns?: string[];
-    alertThreshold?: number;
-    scanFields?: string[];
-    changeThreshold?: number;
-    monitoredChangeTypes?: string[];
-    updateBaseline?: boolean;
-    shadowingPatterns?: string[];
-    allowedServers?: string[];
-    detect?: Array<"email" | "phone_number" | "ssn" | "credit_card" | "ca_sin" | "url">;
-    action?: "mask" | "reject";
-    minScore?: number;
-    rejectionMessage?: string;
-    modulePath?: string;
-    maxMemory?: number;
-    config?: Record<string, unknown>;
-  }>,
+  // Security guards for MCP backend
+  securityGuards: [] as SecurityGuard[],
   // AI backend fields
   aiProvider: "openAI" as "openAI" | "gemini" | "vertex" | "anthropic" | "bedrock" | "azureOpenAI",
   aiModel: "",
@@ -74,7 +64,7 @@ export const DEFAULT_BACKEND_FORM = {
 
 export const DEFAULT_MCP_TARGET = {
   name: "",
-  type: "sse" as const,
+  type: "mcp" as const,
   host: "",
   port: "",
   path: "",
@@ -130,3 +120,184 @@ export const AI_REGION_PLACEHOLDERS = {
   vertex: "us-central1",
   bedrock: "us-east-1",
 } as const;
+
+// =============================================================================
+// Security Guards Constants
+// =============================================================================
+
+// Base security guard defaults (common fields)
+export const DEFAULT_SECURITY_GUARD_BASE = {
+  id: "",
+  description: "",
+  enabled: true,
+  priority: 100,
+  timeout_ms: 100,
+  failure_mode: "fail_closed" as FailureMode,
+  runs_on: ["response"] as GuardPhase[],
+};
+
+// Default Tool Poisoning guard
+export const DEFAULT_TOOL_POISONING_GUARD: ToolPoisoningGuard = {
+  ...DEFAULT_SECURITY_GUARD_BASE,
+  type: "tool_poisoning",
+  strict_mode: true,
+  custom_patterns: [],
+  scan_fields: ["name", "description", "input_schema"],
+  alert_threshold: 1,
+};
+
+// Default Rug Pull guard
+export const DEFAULT_RUG_PULL_GUARD: RugPullGuard = {
+  ...DEFAULT_SECURITY_GUARD_BASE,
+  type: "rug_pull",
+  risk_threshold: 5,
+};
+
+// Default Tool Shadowing guard
+export const DEFAULT_TOOL_SHADOWING_GUARD: ToolShadowingGuard = {
+  ...DEFAULT_SECURITY_GUARD_BASE,
+  type: "tool_shadowing",
+  block_duplicates: true,
+  protected_names: [],
+};
+
+// Default Server Whitelist guard
+export const DEFAULT_SERVER_WHITELIST_GUARD: ServerWhitelistGuard = {
+  ...DEFAULT_SECURITY_GUARD_BASE,
+  type: "server_whitelist",
+  allowed_servers: [],
+  detect_typosquats: true,
+  similarity_threshold: 0.85,
+};
+
+// Default PII guard
+export const DEFAULT_PII_GUARD: PiiGuard = {
+  ...DEFAULT_SECURITY_GUARD_BASE,
+  type: "pii",
+  runs_on: ["request", "response", "tool_invoke"],
+  detect: ["email", "credit_card"],
+  action: "mask",
+  min_score: 0.3,
+  rejection_message: "",
+};
+
+// Default WASM guard
+export const DEFAULT_WASM_GUARD: WasmGuard = {
+  ...DEFAULT_SECURITY_GUARD_BASE,
+  type: "wasm",
+  runs_on: ["response", "tools_list"],
+  module_path: "",
+  max_memory_bytes: 10 * 1024 * 1024, // 10 MB
+  max_fuel: 1_000_000, // 1 million instructions
+  config: {},
+};
+
+// Security guard type metadata for UI
+export const SECURITY_GUARD_TYPES: Array<{
+  value: SecurityGuardType;
+  label: string;
+  description: string;
+}> = [
+  {
+    value: "pii",
+    label: "PII Detection",
+    description: "Detect and mask personally identifiable information",
+  },
+  {
+    value: "tool_poisoning",
+    label: "Tool Poisoning",
+    description: "Detect malicious patterns in tool descriptions",
+  },
+  {
+    value: "rug_pull",
+    label: "Rug Pull",
+    description: "Monitor tool changes over time",
+  },
+  {
+    value: "tool_shadowing",
+    label: "Tool Shadowing",
+    description: "Prevent duplicate or conflicting tools",
+  },
+  {
+    value: "server_whitelist",
+    label: "Server Whitelist",
+    description: "Only allow trusted MCP servers",
+  },
+  {
+    value: "wasm",
+    label: "WASM Guard",
+    description: "Custom WebAssembly security guard module",
+  },
+];
+
+// Guard phases for UI selection
+export const GUARD_PHASES: Array<{ value: GuardPhase; label: string }> = [
+  { value: "request", label: "Request" },
+  { value: "response", label: "Response" },
+  { value: "tools_list", label: "Tools List" },
+  { value: "tool_invoke", label: "Tool Invoke" },
+];
+
+// Failure modes for UI selection
+export const FAILURE_MODES: Array<{ value: FailureMode; label: string; description: string }> = [
+  { value: "fail_closed", label: "Fail Closed", description: "Block on failure (secure)" },
+  { value: "fail_open", label: "Fail Open", description: "Allow on failure (available)" },
+];
+
+// PII types for UI selection
+export const PII_TYPES: Array<{ value: PiiType; label: string }> = [
+  { value: "email", label: "Email Address" },
+  { value: "phone_number", label: "Phone Number" },
+  { value: "ssn", label: "SSN (US)" },
+  { value: "credit_card", label: "Credit Card" },
+  { value: "ca_sin", label: "SIN (Canada)" },
+  { value: "url", label: "URL" },
+];
+
+// PII actions for UI selection
+export const PII_ACTIONS: Array<{ value: PiiAction; label: string; description: string }> = [
+  { value: "mask", label: "Mask", description: "Replace PII with placeholders" },
+  { value: "reject", label: "Reject", description: "Block requests containing PII" },
+];
+
+// Scan fields for tool poisoning
+export const SCAN_FIELDS: Array<{ value: ScanField; label: string }> = [
+  { value: "name", label: "Tool Name" },
+  { value: "description", label: "Description" },
+  { value: "input_schema", label: "Input Schema" },
+];
+
+// Helper to get default guard by type
+export function getDefaultGuard(type: SecurityGuardType): SecurityGuard {
+  const baseId = `${type}-${Date.now()}`;
+  switch (type) {
+    case "tool_poisoning":
+      return { ...DEFAULT_TOOL_POISONING_GUARD, id: baseId };
+    case "rug_pull":
+      return { ...DEFAULT_RUG_PULL_GUARD, id: baseId };
+    case "tool_shadowing":
+      return { ...DEFAULT_TOOL_SHADOWING_GUARD, id: baseId };
+    case "server_whitelist":
+      return { ...DEFAULT_SERVER_WHITELIST_GUARD, id: baseId };
+    case "pii":
+      return { ...DEFAULT_PII_GUARD, id: baseId };
+    case "wasm":
+      return { ...DEFAULT_WASM_GUARD, id: baseId };
+  }
+}
+
+export const MCP_TARGET_TYPES = [
+  { value: "mcp", label: "MCP (Streamable HTTP)" },
+  { value: "sse", label: "SSE" },
+  { value: "stdio", label: "Stdio" },
+  { value: "openapi", label: "OpenAPI" },
+] as const;
+
+export const AI_PROVIDERS = [
+  { value: "openAI", label: "OpenAI" },
+  { value: "gemini", label: "Gemini" },
+  { value: "vertex", label: "Vertex AI" },
+  { value: "anthropic", label: "Anthropic" },
+  { value: "bedrock", label: "Bedrock" },
+  { value: "azureOpenAI", label: "Azure OpenAI" },
+] as const;
diff --git a/ui/src/lib/backend-hooks.ts b/ui/src/lib/backend-hooks.ts
index 63f49efea..5a4706f0b 100644
--- a/ui/src/lib/backend-hooks.ts
+++ b/ui/src/lib/backend-hooks.ts
@@ -3,7 +3,8 @@ import { Backend, Route, Listener, Bind } from "@/lib/types";
 import { fetchConfig, updateConfig } from "@/lib/api";
 import { useServer } from "@/lib/server-context";
 import { toast } from "sonner";
-import { DEFAULT_BACKEND_FORM, DEFAULT_MCP_TARGET } from "./backend-constants";
+import { DEFAULT_BACKEND_FORM, DEFAULT_MCP_TARGET, getDefaultGuard } from "./backend-constants";
+import type { SecurityGuardType, SecurityGuard } from "./types";
 import {
   getBackendType,
   populateFormFromBackend,
@@ -173,6 +174,44 @@ export const useBackendFormState = () => {
     }));
   };
 
+  // Security guard management
+  const addSecurityGuard = (type: SecurityGuardType) => {
+    const newGuard = getDefaultGuard(type);
+    setBackendForm((prev) => ({
+      ...prev,
+      securityGuards: [...prev.securityGuards, newGuard],
+    }));
+  };
+
+  const removeSecurityGuard = (index: number) => {
+    setBackendForm((prev) => ({
+      ...prev,
+      securityGuards: prev.securityGuards.filter((_, i) => i !== index),
+    }));
+  };
+
+  const updateSecurityGuard = <K extends keyof SecurityGuard>(
+    index: number,
+    field: K,
+    value: SecurityGuard[K]
+  ) => {
+    setBackendForm((prev) => ({
+      ...prev,
+      securityGuards: prev.securityGuards.map((guard, i) =>
+        i === index ? { ...guard, [field]: value } : guard
+      ),
+    }));
+  };
+
+  const updateSecurityGuardField = (index: number, field: string, value: any) => {
+    setBackendForm((prev) => ({
+      ...prev,
+      securityGuards: prev.securityGuards.map((guard, i) =>
+        i === index ? { ...guard, [field]: value } : guard
+      ),
+    }));
+  };
+
   return {
     backendForm,
     setBackendForm,
@@ -185,6 +224,11 @@ export const useBackendFormState = () => {
     updateMcpTarget,
     parseAndUpdateUrl,
     updateMcpStateful,
+    // Security guard management
+    addSecurityGuard,
+    removeSecurityGuard,
+    updateSecurityGuard,
+    updateSecurityGuardField,
   };
 };
 
diff --git a/ui/src/lib/backend-utils.ts b/ui/src/lib/backend-utils.ts
index eb7aaf720..b906b904c 100644
--- a/ui/src/lib/backend-utils.ts
+++ b/ui/src/lib/backend-utils.ts
@@ -6,6 +6,13 @@ import {
   StreamHttpTarget,
   McpTarget,
   McpStatefulMode,
+  SecurityGuard,
+  SecurityGuardType,
+  FailureMode,
+  GuardPhase,
+  PiiType,
+  PiiAction,
+  ScanField,
 } from "@/lib/types";
 import { DEFAULT_BACKEND_FORM, BACKEND_TYPE_COLORS } from "./backend-constants";
 import { POLICY_TYPES, BACKEND_POLICY_KEYS } from "./policy-constants";
@@ -483,54 +490,92 @@ export const createMcpTarget = (target: any) => {
   }
 };
 
+/**
+ * Convert security guards from form state to config format
+ */
+export const convertSecurityGuardsToConfig = (guards: SecurityGuard[]): any[] => {
+  return guards.map((guard) => {
+    // Build base config
+    const config: any = {
+      id: guard.id,
+      type: guard.type,
+      enabled: guard.enabled,
+      priority: guard.priority,
+      timeout_ms: guard.timeout_ms,
+      failure_mode: guard.failure_mode,
+      runs_on: guard.runs_on,
+    };
+
+    if (guard.description) {
+      config.description = guard.description;
+    }
+
+    // Add type-specific fields
+    switch (guard.type) {
+      case "tool_poisoning":
+        config.strict_mode = guard.strict_mode;
+        if (guard.custom_patterns.length > 0) {
+          config.custom_patterns = guard.custom_patterns;
+        }
+        config.scan_fields = guard.scan_fields;
+        config.alert_threshold = guard.alert_threshold;
+        break;
+
+      case "rug_pull":
+        config.risk_threshold = guard.risk_threshold;
+        break;
+
+      case "tool_shadowing":
+        config.block_duplicates = guard.block_duplicates;
+        if (guard.protected_names.length > 0) {
+          config.protected_names = guard.protected_names;
+        }
+        break;
+
+      case "server_whitelist":
+        if (guard.allowed_servers.length > 0) {
+          config.allowed_servers = guard.allowed_servers;
+        }
+        config.detect_typosquats = guard.detect_typosquats;
+        config.similarity_threshold = guard.similarity_threshold;
+        break;
+
+      case "pii":
+        config.detect = guard.detect;
+        config.action = guard.action;
+        config.min_score = guard.min_score;
+        if (guard.rejection_message) {
+          config.rejection_message = guard.rejection_message;
+        }
+        break;
+
+      case "wasm":
+        config.module_path = guard.module_path;
+        config.max_memory_bytes = guard.max_memory_bytes;
+        config.max_fuel = guard.max_fuel;
+        if (guard.config && Object.keys(guard.config).length > 0) {
+          config.config = guard.config;
+        }
+        break;
+    }
+
+    return config;
+  });
+};
+
 export const createMcpBackend = (form: typeof DEFAULT_BACKEND_FORM, weight: number): Backend => {
   const targets = form.mcpTargets.map(createMcpTarget);
-  const mcpConfig: any = {
+  const mcp: any = {
     targets, // Flat structure for local config format
     statefulMode: form.mcpStateful ? McpStatefulMode.STATEFUL : McpStatefulMode.STATELESS,
   };
 
-  // Add security guards if configured (UnitOne Extension)
+  // Add security guards if configured
   if (form.securityGuards && form.securityGuards.length > 0) {
-    mcpConfig.securityGuards = form.securityGuards.map((guard) => {
-      // Convert camelCase form fields to snake_case for YAML config
-      const guardConfig: any = {
-        id: guard.id,
-        type: guard.type,
-      };
-
-      // Add optional common fields if present
-      if (guard.description) guardConfig.description = guard.description;
-      if (guard.priority !== undefined) guardConfig.priority = guard.priority;
-      if (guard.failureMode) guardConfig.failure_mode = guard.failureMode;
-      if (guard.timeoutMs !== undefined) guardConfig.timeout_ms = guard.timeoutMs;
-      if (guard.runsOn && guard.runsOn.length > 0) guardConfig.runs_on = guard.runsOn;
-      if (guard.enabled !== undefined) guardConfig.enabled = guard.enabled;
-
-      // Add type-specific config fields
-      if (guard.strictMode !== undefined) guardConfig.strict_mode = guard.strictMode;
-      if (guard.customPatterns) guardConfig.custom_patterns = guard.customPatterns;
-      if (guard.alertThreshold !== undefined) guardConfig.alert_threshold = guard.alertThreshold;
-      if (guard.scanFields) guardConfig.scan_fields = guard.scanFields;
-      if (guard.changeThreshold !== undefined) guardConfig.change_threshold = guard.changeThreshold;
-      if (guard.monitoredChangeTypes)
-        guardConfig.monitored_change_types = guard.monitoredChangeTypes;
-      if (guard.updateBaseline !== undefined) guardConfig.update_baseline = guard.updateBaseline;
-      if (guard.shadowingPatterns) guardConfig.shadowing_patterns = guard.shadowingPatterns;
-      if (guard.allowedServers) guardConfig.allowed_servers = guard.allowedServers;
-      if (guard.detect) guardConfig.detect = guard.detect;
-      if (guard.action) guardConfig.action = guard.action;
-      if (guard.minScore !== undefined) guardConfig.min_score = guard.minScore;
-      if (guard.rejectionMessage) guardConfig.rejection_message = guard.rejectionMessage;
-      if (guard.modulePath) guardConfig.module_path = guard.modulePath;
-      if (guard.maxMemory !== undefined) guardConfig.max_memory = guard.maxMemory;
-      if (guard.config) guardConfig.config = guard.config;
-
-      return guardConfig;
-    });
+    mcp.securityGuards = convertSecurityGuardsToConfig(form.securityGuards);
   }
 
-  return addWeightIfNeeded({ mcp: mcpConfig }, weight);
+  return addWeightIfNeeded({ mcp }, weight);
 };
 
 export const createAiProviderConfig = (form: typeof DEFAULT_BACKEND_FORM) => {
@@ -664,6 +709,96 @@ export const parseUrl = (url: string): { host: string; port: string; path: strin
   }
 };
 
+/**
+ * Parse security guards from config format to form state
+ */
+export const parseSecurityGuardsFromConfig = (configGuards: any[]): SecurityGuard[] => {
+  if (!configGuards || !Array.isArray(configGuards)) return [];
+
+  return configGuards.map((config) => {
+    const baseGuard = {
+      id: config.id || "",
+      description: config.description || "",
+      enabled: config.enabled !== false,
+      priority: config.priority ?? 100,
+      timeout_ms: config.timeout_ms ?? 100,
+      failure_mode: (config.failure_mode || "fail_closed") as FailureMode,
+      runs_on: (config.runs_on || ["response"]) as GuardPhase[],
+    };
+
+    switch (config.type as SecurityGuardType) {
+      case "tool_poisoning":
+        return {
+          ...baseGuard,
+          type: "tool_poisoning" as const,
+          strict_mode: config.strict_mode !== false,
+          custom_patterns: config.custom_patterns || [],
+          scan_fields: (config.scan_fields || [
+            "name",
+            "description",
+            "input_schema",
+          ]) as ScanField[],
+          alert_threshold: config.alert_threshold ?? 1,
+        };
+
+      case "rug_pull":
+        return {
+          ...baseGuard,
+          type: "rug_pull" as const,
+          risk_threshold: config.risk_threshold ?? 5,
+        };
+
+      case "tool_shadowing":
+        return {
+          ...baseGuard,
+          type: "tool_shadowing" as const,
+          block_duplicates: config.block_duplicates !== false,
+          protected_names: config.protected_names || [],
+        };
+
+      case "server_whitelist":
+        return {
+          ...baseGuard,
+          type: "server_whitelist" as const,
+          allowed_servers: config.allowed_servers || [],
+          detect_typosquats: config.detect_typosquats !== false,
+          similarity_threshold: config.similarity_threshold ?? 0.85,
+        };
+
+      case "pii":
+        return {
+          ...baseGuard,
+          type: "pii" as const,
+          detect: (config.detect || ["email", "credit_card"]) as PiiType[],
+          action: (config.action || "mask") as PiiAction,
+          min_score: config.min_score ?? 0.3,
+          rejection_message: config.rejection_message || "",
+        };
+
+      case "wasm":
+        return {
+          ...baseGuard,
+          type: "wasm" as const,
+          module_path: config.module_path || "",
+          max_memory_bytes: config.max_memory_bytes ?? 10 * 1024 * 1024,
+          max_fuel: config.max_fuel ?? 1_000_000,
+          config: config.config || {},
+        };
+
+      default:
+        // Return as PII guard by default if type is unknown
+        return {
+          ...baseGuard,
+          type: "pii" as const,
+          detect: ["email"] as PiiType[],
+          action: "mask" as PiiAction,
+          min_score: 0.3,
+          rejection_message: "",
+        };
+    }
+  });
+};
+
 // Populate form from backend for editing
 export const populateFormFromBackend = (
   backend: Backend,
@@ -763,34 +898,8 @@ export const populateFormFromBackend = (
       return baseTarget;
     }),
     mcpStateful: backend.mcp?.statefulMode !== McpStatefulMode.STATELESS, // Default to stateful if not specified
-    // Security guards (UnitOne Extension)
-    securityGuards: (backend.mcp?.securityGuards || []).map((guard: any) => ({
-      id: guard.id || "",
-      description: guard.description,
-      priority: guard.priority,
-      failureMode: guard.failure_mode || guard.failureMode,
-      timeoutMs: guard.timeout_ms || guard.timeoutMs,
-      runsOn: guard.runs_on || guard.runsOn || [],
-      enabled: guard.enabled,
-      type: guard.type || "tool_poisoning",
-      // Type-specific config
-      strictMode: guard.strict_mode || guard.strictMode,
-      customPatterns: guard.custom_patterns || guard.customPatterns,
-      alertThreshold: guard.alert_threshold || guard.alertThreshold,
-      scanFields: guard.scan_fields || guard.scanFields,
-      changeThreshold: guard.change_threshold || guard.changeThreshold,
-      monitoredChangeTypes: guard.monitored_change_types || guard.monitoredChangeTypes,
-      updateBaseline: guard.update_baseline || guard.updateBaseline,
-      shadowingPatterns: guard.shadowing_patterns || guard.shadowingPatterns,
-      allowedServers: guard.allowed_servers || guard.allowedServers,
-      detect: guard.detect,
-      action: guard.action,
-      minScore: guard.min_score || guard.minScore,
-      rejectionMessage: guard.rejection_message || guard.rejectionMessage,
-      modulePath: guard.module_path || guard.modulePath,
-      maxMemory: guard.max_memory || guard.maxMemory,
-      config: guard.config,
-    })),
+    // Security guards
+    securityGuards: parseSecurityGuardsFromConfig((backend.mcp as any)?.securityGuards),
     // AI backend
     aiProvider:
       (getAiProviderType(backend) as
diff --git a/ui/src/lib/guard-schema-types.ts b/ui/src/lib/guard-schema-types.ts
index 5fdd95494..8e3f67228 100644
--- a/ui/src/lib/guard-schema-types.ts
+++ b/ui/src/lib/guard-schema-types.ts
@@ -84,12 +84,7 @@ export interface GuardMeta {
   icon?: string;
 }
 
-export type GuardPhase =
-  | "connection"
-  | "request"
-  | "response"
-  | "tools_list"
-  | "tool_invoke";
+export type GuardPhase = "connection" | "request" | "response" | "tools_list" | "tool_invoke";
 
 // =============================================================================
 // JSON Schema Types (Draft 2020-12 subset)
@@ -390,9 +385,7 @@ export function resolveWithDefaults(
 /**
  * Get properties sorted by UI order
  */
-export function getSortedProperties(
-  schema: GuardSettingsSchema
-): Array<[string, SchemaProperty]> {
+export function getSortedProperties(schema: GuardSettingsSchema): Array<[string, SchemaProperty]> {
   return Object.entries(schema.properties).sort(([, a], [, b]) => {
     const orderA = a["x-ui"]?.order ?? 999;
     const orderB = b["x-ui"]?.order ?? 999;
diff --git a/ui/src/lib/types.ts b/ui/src/lib/types.ts
index 9e6b863e1..371549917 100644
--- a/ui/src/lib/types.ts
+++ b/ui/src/lib/types.ts
@@ -301,71 +301,21 @@ export interface McpBackend {
   targets: McpTarget[];
   statefulMode?: McpStatefulMode;
   // Security guards to apply to this MCP backend
-  securityGuards?: McpSecurityGuard[];
+  securityGuards?: SecurityGuard[];
 }
 
-// ===========================================
-// Security Guards Types (UnitOne Extension)
-// ===========================================
+// =============================================================================
+// Security Guards Types
+// =============================================================================
 
-/// Security guard that can be applied to MCP protocol operations
-export interface McpSecurityGuard {
-  /// Unique identifier for this guard
-  id: string;
-
-  /// Human-readable description
-  description?: string;
-
-  /// Execution priority (lower = runs first)
-  priority?: number;
-
-  /// Behavior when guard fails to execute
-  failureMode?: FailureMode;
-
-  /// Maximum time allowed for guard execution (ms)
-  timeoutMs?: number;
-
-  /// Which phases this guard runs on
-  runsOn?: GuardPhase[];
-
-  /// Whether guard is enabled
-  enabled?: boolean;
-
-  /// The specific guard implementation type and config
-  type: GuardType;
-
-  // Type-specific config (flattened)
-  // Tool Poisoning config
-  strictMode?: boolean;
-  customPatterns?: string[];
-  alertThreshold?: number;
-  scanFields?: string[];
-
-  // Rug Pull config
-  changeThreshold?: number;
-  monitoredChangeTypes?: string[];
-  updateBaseline?: boolean;
-
-  // Tool Shadowing config
-  shadowingPatterns?: string[];
-
-  // Server Whitelist config
-  allowedServers?: string[];
-
-  // PII config
-  detect?: PiiType[];
-  action?: PiiAction;
-  minScore?: number;
-  rejectionMessage?: string;
+// Guard phase types (matches Rust GuardPhase enum)
+export type GuardPhase = "request" | "response" | "tools_list" | "tool_invoke";
 
-  // WASM config
-  modulePath?: string;
-  maxMemory?: number;
-  config?: Record<string, unknown>;
-}
+// Failure mode (matches Rust FailureMode enum)
+export type FailureMode = "fail_closed" | "fail_open";
 
-/// Guard implementation types
-export type GuardType =
+// Guard types (matches Rust McpGuardKind enum)
+export type SecurityGuardType =
   | "tool_poisoning"
   | "rug_pull"
   | "tool_shadowing"
@@ -373,18 +323,83 @@ export type GuardType =
   | "pii"
   | "wasm";
 
-/// Execution phase for guards
-export type GuardPhase = "request" | "response" | "tools_list" | "tool_invoke";
-
-/// How to behave when guard execution fails
-export type FailureMode = "fail_closed" | "fail_open";
-
-/// PII types that can be detected
+// PII types (matches Rust PiiType enum)
 export type PiiType = "email" | "phone_number" | "ssn" | "credit_card" | "ca_sin" | "url";
 
-/// Action to take when PII is detected
+// PII action (matches Rust PiiAction enum)
 export type PiiAction = "mask" | "reject";
 
+// Scan fields for tool poisoning
+export type ScanField = "name" | "description" | "input_schema";
+
+// Base security guard interface (common fields)
+export interface SecurityGuardBase {
+  id: string;
+  description?: string;
+  enabled: boolean;
+  priority: number;
+  timeout_ms: number;
+  failure_mode: FailureMode;
+  runs_on: GuardPhase[];
+}
+
+// Tool Poisoning config
+export interface ToolPoisoningGuard extends SecurityGuardBase {
+  type: "tool_poisoning";
+  strict_mode: boolean;
+  custom_patterns: string[];
+  scan_fields: ScanField[];
+  alert_threshold: number;
+}
+
+// Rug Pull config
+export interface RugPullGuard extends SecurityGuardBase {
+  type: "rug_pull";
+  risk_threshold: number;
+}
+
+// Tool Shadowing config
+export interface ToolShadowingGuard extends SecurityGuardBase {
+  type: "tool_shadowing";
+  block_duplicates: boolean;
+  protected_names: string[];
+}
+
+// Server Whitelist config
+export interface ServerWhitelistGuard extends SecurityGuardBase {
+  type: "server_whitelist";
+  allowed_servers: string[];
+  detect_typosquats: boolean;
+  similarity_threshold: number;
+}
+
+// PII Guard config
+export interface PiiGuard extends SecurityGuardBase {
+  type: "pii";
+  detect: PiiType[];
+  action: PiiAction;
+  min_score: number;
+  rejection_message?: string;
+}
+
+// WASM Guard config (for custom WebAssembly guards)
+export interface WasmGuard extends SecurityGuardBase {
+  type: "wasm";
+  module_path: string;
+  max_memory_bytes: number;
+  max_fuel: number;
+  config: Record<string, unknown>;
+}
+
+// Union type for all security guards
+export type SecurityGuard =
+  | ToolPoisoningGuard
+  | RugPullGuard
+  | ToolShadowingGuard
+  | ServerWhitelistGuard
+  | PiiGuard
+  | WasmGuard;
+
 // UI-friendly flat structure (matches local config format for write path)
 export interface AiBackend {
   name: string;

From c160c47f357d5a92db0451d75a7c101d885968af Mon Sep 17 00:00:00 2001
From: Alexey Puzik <alexey.puzik@devpulse.io>
Date: Thu, 12 Feb 2026 19:49:57 +0200
Subject: [PATCH 04/10] Rollback accidentally added change

---
 ui/src/app/playground/page.tsx | 74 ++++++++++------------------------
 1 file changed, 21 insertions(+), 53 deletions(-)

diff --git a/ui/src/app/playground/page.tsx b/ui/src/app/playground/page.tsx
index 2707aaa31..c06df7eeb 100644
--- a/ui/src/app/playground/page.tsx
+++ b/ui/src/app/playground/page.tsx
@@ -2,7 +2,7 @@
 
 import { useState, useEffect, useCallback } from "react";
 import { Client as McpClient } from "@modelcontextprotocol/sdk/client/index.js";
-import { StreamableHTTPClientTransport as McpHttpTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+import { SSEClientTransport as McpSseTransport } from "@modelcontextprotocol/sdk/client/sse.js";
 import {
   ClientRequest as McpClientRequest,
   Result as McpResult,
@@ -247,21 +247,9 @@ export default function PlaygroundPage() {
         if (listener.routes) {
           listener.routes.forEach((route: Route, routeIndex: number) => {
             const protocol = listener.protocol === ListenerProtocol.HTTPS ? "https" : "http";
-            // Use window.location.hostname when listener hostname is not set
-            // This ensures the UI connects to the correct domain in deployed environments
-            const hostname =
-              listener.hostname ||
-              (typeof window !== "undefined" ? window.location.hostname : "localhost");
-            const configPort = bind.port;
-            // Local dev: browser URL has explicit port (e.g., 127.0.0.1:15000) -> use config port for routes
-            // Deployed (Azure): browser URL has no port (standard 80/443) -> use origin (ingress handles routing)
-            // Drawback: if Azure exposed non-standard port, this would break (uncommon scenario)
-            const hasExplicitPort = typeof window !== "undefined" && window.location.port !== "";
-            const baseEndpoint = hasExplicitPort
-              ? `${protocol}://${hostname}:${configPort}`
-              : typeof window !== "undefined"
-                ? window.location.origin
-                : `${protocol}://${hostname}:${configPort}`;
+            const hostname = listener.hostname || "localhost";
+            const port = bind.port; // Use the actual port from the bind configuration
+            const baseEndpoint = `${protocol}://${hostname}:${port}`;
 
             // Generate route path and description with better pattern recognition
             let routePath = "/";
@@ -476,10 +464,18 @@ export default function PlaygroundPage() {
           headers["Authorization"] = `Bearer ${connectionState.authToken}`;
         }
 
-        const mcpUrl = selectedRoute.endpoint.endsWith("/")
-          ? selectedRoute.endpoint.slice(0, -1)
-          : selectedRoute.endpoint;
-        const transport = new McpHttpTransport(new URL(mcpUrl), {
+        const sseUrl = selectedRoute.endpoint.endsWith("/")
+          ? `${selectedRoute.endpoint}sse`
+          : `${selectedRoute.endpoint}/sse`;
+        const transport = new McpSseTransport(new URL(sseUrl), {
+          eventSourceInit: {
+            fetch: (url, init) => {
+              return fetch(url, {
+                ...init,
+                headers: headers as HeadersInit,
+              });
+            },
+          },
           requestInit: {
             headers: headers as HeadersInit,
             credentials: "omit",
@@ -489,15 +485,13 @@ export default function PlaygroundPage() {
 
         await client.connect(transport);
         setMcpState((prev) => ({ ...prev, client }));
+        setConnectionState((prev) => ({ ...prev, isConnected: true }));
+        toast.success("Connected to MCP endpoint");
 
         setUiState((prev) => ({ ...prev, isLoadingCapabilities: true }));
         const listToolsRequest: McpClientRequest = { method: "tools/list", params: {} };
         const toolsResponse = await client.request(listToolsRequest, McpListToolsResultSchema);
         setMcpState((prev) => ({ ...prev, tools: toolsResponse.tools }));
-
-        // Only mark as connected and show success after tools are loaded successfully
-        setConnectionState((prev) => ({ ...prev, isConnected: true }));
-        toast.success("Connected to MCP endpoint");
       } else if (backendType === "a2a") {
         // Connect to A2A endpoint
         setConnectionState((prev) => ({ ...prev, connectionType: "a2a" }));
@@ -746,14 +740,11 @@ export default function PlaygroundPage() {
           arguments: mcpState.paramValues,
         },
       };
-
       const result = await mcpState.client.request(request, McpToolResponseSchema);
-
       setMcpState((prev) => ({ ...prev, response: result }));
       toast.success(`Tool ${mcpState.selectedTool?.name} executed.`);
     } catch (error: any) {
-      const message =
-        error instanceof McpError ? error.message : error?.message || "Failed to run tool";
+      const message = error instanceof McpError ? error.message : "Failed to run tool";
       setMcpState((prev) => ({ ...prev, response: { error: message, details: error } }));
       toast.error(message);
     } finally {
@@ -761,29 +752,6 @@ export default function PlaygroundPage() {
     }
   };
 
-  const refreshMcpTools = async () => {
-    if (!mcpState.client) return;
-
-    setUiState((prev) => ({ ...prev, isLoadingCapabilities: true }));
-    try {
-      // Call tools/list through the existing gateway connection
-      // The gateway will re-fetch from all configured MCP targets
-      const listToolsRequest: McpClientRequest = { method: "tools/list", params: {} };
-      const toolsResponse = await mcpState.client.request(
-        listToolsRequest,
-        McpListToolsResultSchema
-      );
-      setMcpState((prev) => ({ ...prev, tools: toolsResponse.tools }));
-      toast.success(`Refreshed tools list (${toolsResponse.tools.length} tools)`);
-    } catch (error: any) {
-      const message =
-        error instanceof McpError ? error.message : error?.message || "Failed to refresh tools";
-      toast.error(message);
-    } finally {
-      setUiState((prev) => ({ ...prev, isLoadingCapabilities: false }));
-    }
-  };
-
   const handleA2aSkillSelect = (skill: AgentSkill) => {
     setA2aState((prev) => ({ ...prev, selectedSkill: skill, response: null, message: "" }));
     setMcpState((prev) => ({ ...prev, response: null }));
@@ -1097,7 +1065,8 @@ export default function PlaygroundPage() {
                     <span className="font-medium text-sm">Request URL</span>
                   </div>
                   <div className="font-mono text-sm break-all">
-                    {selectedRoute.endpoint}
+                    {selectedRoute.protocol}://{selectedRoute.listener.hostname || "localhost"}:
+                    {selectedRoute.bindPort}
                     {request.path}
                   </div>
                 </div>
@@ -1467,7 +1436,6 @@ export default function PlaygroundPage() {
             selectedA2aSkillId={a2aState.selectedSkill?.id ?? null}
             onMcpToolSelect={handleMcpToolSelect}
             onA2aSkillSelect={handleA2aSkillSelect}
-            onRefreshMcpTools={refreshMcpTools}
           />
 
           <ActionPanel

From bc868f77244b65205400e183520983f0ec1c9eaa Mon Sep 17 00:00:00 2001
From: Alexey Puzik <alexey.puzik@devpulse.io>
Date: Fri, 13 Feb 2026 01:05:29 +0200
Subject: [PATCH 05/10] Fix merge issues

---
 .../playground/CapabilitiesList.tsx           | 23 +++---
 ui/src/components/schema-form/SchemaForm.tsx  |  2 +-
 ui/src/lib/backend-constants.ts               | 32 --------
 ui/src/lib/types.ts                           | 80 -------------------
 4 files changed, 12 insertions(+), 125 deletions(-)

diff --git a/ui/src/components/playground/CapabilitiesList.tsx b/ui/src/components/playground/CapabilitiesList.tsx
index 5e50eb517..3a1c61dbb 100644
--- a/ui/src/components/playground/CapabilitiesList.tsx
+++ b/ui/src/components/playground/CapabilitiesList.tsx
@@ -14,7 +14,6 @@ import {
 import { Badge } from "@/components/ui/badge";
 import { Button } from "@/components/ui/button";
 import { Separator } from "@/components/ui/separator";
-import { Button } from "@/components/ui/button";
 import { Loader2, Bot, Zap, Settings, RefreshCw } from "lucide-react";
 
 interface CapabilitiesListProps {
@@ -58,17 +57,17 @@ export function CapabilitiesList({
               <Settings className="h-5 w-5" />
             )}
             {connectionType === "a2a" ? a2aAgentCard?.name || "Unknown Agent" : "Available Tools"}
-          {connectionType === "mcp" && onRefreshMcpTools && (
-            <Button
-              variant="ghost"
-              size="icon"
-              className="h-6 w-6 ml-auto"
-              onClick={onRefreshMcpTools}
-              disabled={isLoading}
-            >
-              <RefreshCw className={`h-4 w-4 ${isLoading ? "animate-spin" : ""}`} />
-            </Button>
-          )}
+            {connectionType === "mcp" && onRefreshMcpTools && (
+              <Button
+                variant="ghost"
+                size="icon"
+                className="h-6 w-6 ml-auto"
+                onClick={onRefreshMcpTools}
+                disabled={isLoading}
+              >
+                <RefreshCw className={`h-4 w-4 ${isLoading ? "animate-spin" : ""}`} />
+              </Button>
+            )}
           </CardTitle>
           {connectionType === "mcp" && onRefreshMcpTools && (
             <Button variant="outline" size="sm" onClick={onRefreshMcpTools} disabled={isLoading}>
diff --git a/ui/src/components/schema-form/SchemaForm.tsx b/ui/src/components/schema-form/SchemaForm.tsx
index 7c77da5a6..b725e0782 100644
--- a/ui/src/components/schema-form/SchemaForm.tsx
+++ b/ui/src/components/schema-form/SchemaForm.tsx
@@ -55,7 +55,7 @@ export function SchemaForm({
   const groupedProperties = useMemo(() => getGroupedProperties(schema), [schema]);
 
   // Get group definitions from schema
-  const groupDefs = schema["x-ui-groups"] || {};
+  const groupDefs = useMemo(() => schema["x-ui-groups"] || {}, [schema]);
 
   // Sort groups by their order
   const sortedGroups = useMemo(() => {
diff --git a/ui/src/lib/backend-constants.ts b/ui/src/lib/backend-constants.ts
index 4566f0cb7..8ac5082a3 100644
--- a/ui/src/lib/backend-constants.ts
+++ b/ui/src/lib/backend-constants.ts
@@ -1,19 +1,3 @@
-import type {
-  SecurityGuardType,
-  FailureMode,
-  GuardPhase,
-  PiiType,
-  PiiAction,
-  ScanField,
-  ToolPoisoningGuard,
-  RugPullGuard,
-  ToolShadowingGuard,
-  ServerWhitelistGuard,
-  PiiGuard,
-  WasmGuard,
-  SecurityGuard,
-} from "./types";
-
 export const DEFAULT_BACKEND_FORM = {
   name: "",
   weight: "1",
@@ -301,19 +285,3 @@ export function getDefaultGuard(type: SecurityGuardType): SecurityGuard {
       return { ...DEFAULT_WASM_GUARD, id: baseId };
   }
 }
-
-export const MCP_TARGET_TYPES = [
-  { value: "mcp", label: "MCP (Streamable HTTP)" },
-  { value: "sse", label: "SSE" },
-  { value: "stdio", label: "Stdio" },
-  { value: "openapi", label: "OpenAPI" },
-] as const;
-
-export const AI_PROVIDERS = [
-  { value: "openAI", label: "OpenAI" },
-  { value: "gemini", label: "Gemini" },
-  { value: "vertex", label: "Vertex AI" },
-  { value: "anthropic", label: "Anthropic" },
-  { value: "bedrock", label: "Bedrock" },
-  { value: "azureOpenAI", label: "Azure OpenAI" },
-] as const;
diff --git a/ui/src/lib/types.ts b/ui/src/lib/types.ts
index 00243d8a1..29efa44fc 100644
--- a/ui/src/lib/types.ts
+++ b/ui/src/lib/types.ts
@@ -301,88 +301,8 @@ export interface McpBackend {
   targets: McpTarget[];
   statefulMode?: McpStatefulMode;
   securityGuards?: SecurityGuard[];
-// =============================================================================
-// Security Guards Types
-// =============================================================================
-// Guard phase types (matches Rust GuardPhase enum)
-export type GuardPhase = "request" | "response" | "tools_list" | "tool_invoke";
-// Failure mode (matches Rust FailureMode enum)
-export type FailureMode = "fail_closed" | "fail_open";
-// Guard types (matches Rust McpGuardKind enum)
-export type SecurityGuardType =
-  | "tool_poisoning"
-  | "rug_pull"
-  | "tool_shadowing"
-  | "server_whitelist"
-  | "pii"
-  | "wasm";
-// PII types (matches Rust PiiType enum)
-export type PiiType = "email" | "phone_number" | "ssn" | "credit_card" | "ca_sin" | "url";
-// PII action (matches Rust PiiAction enum)
-export type PiiAction = "mask" | "reject";
-// Scan fields for tool poisoning
-export type ScanField = "name" | "description" | "input_schema";
-// Base security guard interface (common fields)
-export interface SecurityGuardBase {
-  id: string;
-  description?: string;
-  enabled: boolean;
-  priority: number;
-  timeout_ms: number;
-  failure_mode: FailureMode;
-  runs_on: GuardPhase[];
-}
-// Tool Poisoning config
-export interface ToolPoisoningGuard extends SecurityGuardBase {
-  type: "tool_poisoning";
-  strict_mode: boolean;
-  custom_patterns: string[];
-  scan_fields: ScanField[];
-  alert_threshold: number;
-}
-// Rug Pull config
-export interface RugPullGuard extends SecurityGuardBase {
-  type: "rug_pull";
-  risk_threshold: number;
-}
-// Tool Shadowing config
-export interface ToolShadowingGuard extends SecurityGuardBase {
-  type: "tool_shadowing";
-  block_duplicates: boolean;
-  protected_names: string[];
-}
-// Server Whitelist config
-export interface ServerWhitelistGuard extends SecurityGuardBase {
-  type: "server_whitelist";
-  allowed_servers: string[];
-  detect_typosquats: boolean;
-  similarity_threshold: number;
 }
 
-// PII Guard config
-export interface PiiGuard extends SecurityGuardBase {
-  type: "pii";
-  detect: PiiType[];
-  action: PiiAction;
-  min_score: number;
-  rejection_message?: string;
-}
-// WASM Guard config (for custom WebAssembly guards)
-export interface WasmGuard extends SecurityGuardBase {
-  type: "wasm";
-  module_path: string;
-  max_memory_bytes: number;
-  max_fuel: number;
-  config: Record<string, unknown>;
-}
-// Union type for all security guards
-export type SecurityGuard =
-  | ToolPoisoningGuard
-  | RugPullGuard
-  | ToolShadowingGuard
-  | ServerWhitelistGuard
-  | PiiGuard
-  | WasmGuard;
 // UI-friendly flat structure (matches local config format for write path)
 export interface AiBackend {
   name: string;

From 471a2a6cf3490c27a19bd0456a08085bce1e7ccb Mon Sep 17 00:00:00 2001
From: Alexey Puzik <alexey.puzik@devpulse.io>
Date: Fri, 13 Feb 2026 09:29:10 +0200
Subject: [PATCH 06/10] Fix merge issue

---
 .../components/backend/backend-components.tsx | 26 +++++++------------
 ui/src/lib/backend-constants.ts               |  4 +--
 ui/src/lib/backend-utils.ts                   |  8 +++---
 ui/src/lib/types.ts                           |  4 +--
 4 files changed, 17 insertions(+), 25 deletions(-)

diff --git a/ui/src/components/backend/backend-components.tsx b/ui/src/components/backend/backend-components.tsx
index 74254b3e0..a14a960b1 100644
--- a/ui/src/components/backend/backend-components.tsx
+++ b/ui/src/components/backend/backend-components.tsx
@@ -1227,11 +1227,11 @@ const SecurityGuardsSection: React.FC<SecurityGuardsSectionProps> = ({
                               type="number"
                               min={1}
                               max={1024}
-                              value={Math.round(guard.max_memory_bytes / (1024 * 1024))}
+                              value={Math.round(guard.max_memory / (1024 * 1024))}
                               onChange={(e) =>
                                 updateSecurityGuardField(
                                   index,
-                                  "max_memory_bytes",
+                                  "max_memory",
                                   (parseInt(e.target.value) || 10) * 1024 * 1024
                                 )
                               }
@@ -1239,18 +1239,18 @@ const SecurityGuardsSection: React.FC<SecurityGuardsSectionProps> = ({
                             />
                           </div>
                           <div className="space-y-1">
-                            <Label className="text-xs">Max Fuel (instructions)</Label>
+                            <Label className="text-xs">Max WASM Stack (MB)</Label>
                             <Input
                               type="number"
-                              min={10000}
-                              max={100000000}
-                              step={100000}
-                              value={guard.max_fuel}
+                              min={1}
+                              max={64}
+                              step={1}
+                              value={Math.round(guard.max_wasm_stack / (1024 * 1024))}
                               onChange={(e) =>
                                 updateSecurityGuardField(
                                   index,
-                                  "max_fuel",
-                                  parseInt(e.target.value) || 1000000
+                                  "max_wasm_stack",
+                                  (parseInt(e.target.value) || 2) * 1024 * 1024
                                 )
                               }
                               className="h-8 text-sm"
@@ -1561,14 +1561,6 @@ const McpBackendForm: React.FC<McpBackendFormProps> = ({
         Enable stateful mode
       </Label>
     </div>
-
-    {/* Security Guards */}
-    <SecurityGuardsSection
-      guards={backendForm.securityGuards}
-      addSecurityGuard={addSecurityGuard}
-      removeSecurityGuard={removeSecurityGuard}
-      updateSecurityGuardField={updateSecurityGuardField}
-    />
   </div>
 );
 
diff --git a/ui/src/lib/backend-constants.ts b/ui/src/lib/backend-constants.ts
index 8ac5082a3..3311f2323 100644
--- a/ui/src/lib/backend-constants.ts
+++ b/ui/src/lib/backend-constants.ts
@@ -187,8 +187,8 @@ export const DEFAULT_WASM_GUARD: WasmGuard = {
   type: "wasm",
   runs_on: ["response", "tools_list"],
   module_path: "",
-  max_memory_bytes: 10 * 1024 * 1024, // 10 MB
-  max_fuel: 1_000_000, // 1 million instructions
+  max_memory: 10 * 1024 * 1024, // 10 MB
+  max_wasm_stack: 2 * 1024 * 1024, // 2 MB
   config: {},
 };
 
diff --git a/ui/src/lib/backend-utils.ts b/ui/src/lib/backend-utils.ts
index c0c53741a..632598d10 100644
--- a/ui/src/lib/backend-utils.ts
+++ b/ui/src/lib/backend-utils.ts
@@ -551,8 +551,8 @@ export const convertSecurityGuardsToConfig = (guards: SecurityGuard[]): any[] =>
 
       case "wasm":
         config.module_path = guard.module_path;
-        config.max_memory_bytes = guard.max_memory_bytes;
-        config.max_fuel = guard.max_fuel;
+        config.max_memory = guard.max_memory;
+        config.max_wasm_stack = guard.max_wasm_stack;
         if (guard.config && Object.keys(guard.config).length > 0) {
           config.config = guard.config;
         }
@@ -780,8 +780,8 @@ export const parseSecurityGuardsFromConfig = (configGuards: any[]): SecurityGuar
           ...baseGuard,
           type: "wasm" as const,
           module_path: config.module_path || "",
-          max_memory_bytes: config.max_memory_bytes ?? 10 * 1024 * 1024,
-          max_fuel: config.max_fuel ?? 1_000_000,
+          max_memory: config.max_memory ?? 10 * 1024 * 1024,
+          max_wasm_stack: config.max_wasm_stack ?? 2 * 1024 * 1024,
           config: config.config || {},
         };
 
diff --git a/ui/src/lib/types.ts b/ui/src/lib/types.ts
index 29efa44fc..743365c96 100644
--- a/ui/src/lib/types.ts
+++ b/ui/src/lib/types.ts
@@ -575,8 +575,8 @@ export interface PiiGuard extends SecurityGuardBase {
 export interface WasmGuard extends SecurityGuardBase {
   type: "wasm";
   module_path: string;
-  max_memory_bytes: number;
-  max_fuel: number;
+  max_memory: number;
+  max_wasm_stack: number;
   config: Record<string, unknown>;
 }
 

From 7f176a69487f87133eb4a861fc65e4515e1829e4 Mon Sep 17 00:00:00 2001
From: Alexey Puzik <alexey.puzik@devpulse.io>
Date: Fri, 13 Feb 2026 18:27:10 +0200
Subject: [PATCH 07/10] Fix wasm guards issues

---
 crates/agentgateway/src/mcp/handler.rs        |  41 +++-
 crates/agentgateway/src/mcp/security/wasm.rs  | 188 ++++++++++++++++--
 .../src/mcp/security/wit/guard.wit            |   9 +
 crates/agentgateway/src/state_manager.rs      |  30 +++
 crates/agentgateway/src/ui.rs                 | 122 +++++++-----
 .../simple-pattern-guard/src/lib.rs           |  15 ++
 .../simple-pattern-guard/wit/guard.wit        |   6 +
 .../components/backend/backend-components.tsx |  90 ++++++---
 ui/src/lib/backend-constants.ts               |   1 +
 ui/src/lib/types.ts                           |   2 +-
 10 files changed, 404 insertions(+), 100 deletions(-)

diff --git a/crates/agentgateway/src/mcp/handler.rs b/crates/agentgateway/src/mcp/handler.rs
index af5c89630..405d76be1 100644
--- a/crates/agentgateway/src/mcp/handler.rs
+++ b/crates/agentgateway/src/mcp/handler.rs
@@ -171,6 +171,36 @@ impl Relay {
 		tracing::info!("Establishing security guard baselines for all upstreams");
 
 		for (server_name, upstream) in self.upstreams.iter_named() {
+			// Evaluate connection phase guards (whitelist, typosquat detection)
+			let context = crate::mcp::security::GuardContext {
+				server_name: server_name.to_string(),
+				identity: None,
+				metadata: serde_json::Value::Null,
+			};
+			match self.security_guards.evaluate_connection(&server_name, None, &context) {
+				Ok(crate::mcp::security::GuardDecision::Allow) => {
+					tracing::info!(server = %server_name, "Connection guard: allowed");
+				},
+				Ok(crate::mcp::security::GuardDecision::Deny(reason)) => {
+					tracing::warn!(
+						server = %server_name,
+						code = %reason.code,
+						message = %reason.message,
+						"Connection guard: BLOCKED server"
+					);
+					continue; // Skip this upstream entirely
+				},
+				Ok(_) => {},
+				Err(e) => {
+					tracing::error!(
+						server = %server_name,
+						error = %e,
+						"Connection guard: error"
+					);
+					continue; // Skip on error (fail closed)
+				},
+			}
+
 			// Create a tools/list request
 			let request = JsonRpcRequest {
 				jsonrpc: Default::default(),
@@ -263,6 +293,12 @@ impl Relay {
 
 			// Process each server's tools individually for security guard evaluation
 			for (server_name, s) in streams.into_iter() {
+				let context = crate::mcp::security::GuardContext {
+					server_name: server_name.to_string(),
+					identity: None,
+					metadata: serde_json::Value::Null,
+				};
+
 				let tools = match s {
 					ServerResult::ListToolsResult(ltr) => ltr.tools,
 					_ => vec![],
@@ -270,11 +306,6 @@ impl Relay {
 
 				// Execute security guards on this server's tools list BEFORE merging
 				// This ensures baselines are stored per-server, not under "merged"
-				let context = crate::mcp::security::GuardContext {
-					server_name: server_name.to_string(),
-					identity: None,
-					metadata: serde_json::Value::Null,
-				};
 
 				match security_guards.evaluate_tools_list(&tools, &context) {
 					Ok(crate::mcp::security::GuardDecision::Allow) => {
diff --git a/crates/agentgateway/src/mcp/security/wasm.rs b/crates/agentgateway/src/mcp/security/wasm.rs
index d8b367413..e368368bc 100644
--- a/crates/agentgateway/src/mcp/security/wasm.rs
+++ b/crates/agentgateway/src/mcp/security/wasm.rs
@@ -602,27 +602,179 @@ impl NativeGuard for WasmGuard {
 		arguments: &serde_json::Value,
 		context: &GuardContext,
 	) -> GuardResult {
-		// Default implementation - WASM guards primarily target tools_list evaluation
-		// This can be extended if the WIT interface is updated to support tool invocation
-		tracing::debug!(
-				guard_id = %self.guard_id,
-				tool_name = %tool_name,
-				server = %context.server_name,
-				"WASM guard evaluate_tool_invoke called (default allow)"
-		);
-		let _ = (tool_name, arguments, context);
-		Ok(GuardDecision::Allow)
+		self.execute_with_timeout(|| {
+			tracing::debug!(
+					guard_id = %self.guard_id,
+					tool_name = %tool_name,
+					server = %context.server_name,
+					"Evaluating tool invocation with WASM guard"
+			);
+
+			let linker = self.create_linker()?;
+			let state = WasmState::new(self.config.config.clone());
+			let mut store = Store::new(&self.engine, state);
+
+			let instance = linker
+				.instantiate(&mut store, &self.component)
+				.map_err(|e| GuardError::WasmError(format!("Failed to instantiate component: {}", e)))?;
+
+			let guard_export_idx = instance
+				.get_export(&mut store, None, "mcp:security-guard/guard@0.1.0")
+				.ok_or_else(|| {
+					GuardError::WasmError("Guard interface not found in component exports".to_string())
+				})?;
+
+			// Try to get evaluate-tool-invoke — if not exported, allow (backward compat)
+			let func_export_idx = match instance.get_export(
+				&mut store,
+				Some(&guard_export_idx),
+				"evaluate-tool-invoke",
+			) {
+				Some(idx) => idx,
+				None => {
+					tracing::debug!(
+						guard_id = %self.guard_id,
+						"WASM guard does not export evaluate-tool-invoke, allowing"
+					);
+					return Ok(GuardDecision::Allow);
+				},
+			};
+
+			let func = instance
+				.get_func(&mut store, &func_export_idx)
+				.ok_or_else(|| {
+					GuardError::WasmError("Could not get function from export index".to_string())
+				})?;
+
+			let tool_name_val = Val::String(tool_name.to_string().into());
+			let arguments_val = Val::String(
+				serde_json::to_string(arguments)
+					.unwrap_or_else(|_| "{}".to_string())
+					.into(),
+			);
+			let context_record = Val::Record(vec![
+				(
+					"server-name".into(),
+					Val::String(context.server_name.clone().into()),
+				),
+				("server-url".into(), Val::Option(None)),
+				(
+					"identity".into(),
+					match &context.identity {
+						Some(id) => Val::Option(Some(Box::new(Val::String(id.clone().into())))),
+						None => Val::Option(None),
+					},
+				),
+				(
+					"metadata".into(),
+					Val::String(
+						serde_json::to_string(&context.metadata)
+							.unwrap_or_else(|_| "{}".to_string())
+							.into(),
+					),
+				),
+			]);
+
+			let mut results = vec![Val::Bool(false)];
+			func
+				.call(
+					&mut store,
+					&[tool_name_val, arguments_val, context_record],
+					&mut results,
+				)
+				.map_err(|e| GuardError::WasmError(format!("WASM function call failed: {}", e)))?;
+
+			func
+				.post_return(&mut store)
+				.map_err(|e| GuardError::WasmError(format!("WASM post-return failed: {}", e)))?;
+
+			Self::parse_decision(&results)
+		})
 	}
 
 	fn evaluate_response(&self, response: &serde_json::Value, context: &GuardContext) -> GuardResult {
-		// Default implementation - can be extended if WIT interface supports response evaluation
-		tracing::debug!(
-				guard_id = %self.guard_id,
-				server = %context.server_name,
-				"WASM guard evaluate_response called (default allow)"
-		);
-		let _ = (response, context);
-		Ok(GuardDecision::Allow)
+		self.execute_with_timeout(|| {
+			tracing::debug!(
+					guard_id = %self.guard_id,
+					server = %context.server_name,
+					"Evaluating response with WASM guard"
+			);
+
+			let linker = self.create_linker()?;
+			let state = WasmState::new(self.config.config.clone());
+			let mut store = Store::new(&self.engine, state);
+
+			let instance = linker
+				.instantiate(&mut store, &self.component)
+				.map_err(|e| GuardError::WasmError(format!("Failed to instantiate component: {}", e)))?;
+
+			let guard_export_idx = instance
+				.get_export(&mut store, None, "mcp:security-guard/guard@0.1.0")
+				.ok_or_else(|| {
+					GuardError::WasmError("Guard interface not found in component exports".to_string())
+				})?;
+
+			// Try to get evaluate-response — if not exported, allow (backward compat)
+			let func_export_idx = match instance.get_export(
+				&mut store,
+				Some(&guard_export_idx),
+				"evaluate-response",
+			) {
+				Some(idx) => idx,
+				None => {
+					tracing::debug!(
+						guard_id = %self.guard_id,
+						"WASM guard does not export evaluate-response, allowing"
+					);
+					return Ok(GuardDecision::Allow);
+				},
+			};
+
+			let func = instance
+				.get_func(&mut store, &func_export_idx)
+				.ok_or_else(|| {
+					GuardError::WasmError("Could not get function from export index".to_string())
+				})?;
+
+			let response_val = Val::String(
+				serde_json::to_string(response)
+					.unwrap_or_else(|_| "{}".to_string())
+					.into(),
+			);
+			let context_record = Val::Record(vec![
+				(
+					"server-name".into(),
+					Val::String(context.server_name.clone().into()),
+				),
+				("server-url".into(), Val::Option(None)),
+				(
+					"identity".into(),
+					match &context.identity {
+						Some(id) => Val::Option(Some(Box::new(Val::String(id.clone().into())))),
+						None => Val::Option(None),
+					},
+				),
+				(
+					"metadata".into(),
+					Val::String(
+						serde_json::to_string(&context.metadata)
+							.unwrap_or_else(|_| "{}".to_string())
+							.into(),
+					),
+				),
+			]);
+
+			let mut results = vec![Val::Bool(false)];
+			func
+				.call(&mut store, &[response_val, context_record], &mut results)
+				.map_err(|e| GuardError::WasmError(format!("WASM function call failed: {}", e)))?;
+
+			func
+				.post_return(&mut store)
+				.map_err(|e| GuardError::WasmError(format!("WASM post-return failed: {}", e)))?;
+
+			Self::parse_decision(&results)
+		})
 	}
 
 	fn evaluate_connection(
diff --git a/crates/agentgateway/src/mcp/security/wit/guard.wit b/crates/agentgateway/src/mcp/security/wit/guard.wit
index e3d7d1771..24504ec3e 100644
--- a/crates/agentgateway/src/mcp/security/wit/guard.wit
+++ b/crates/agentgateway/src/mcp/security/wit/guard.wit
@@ -43,6 +43,15 @@ interface guard {
     /// Evaluate tools/list response
     evaluate-tools-list: func(tools: list<tool>, context: guard-context) -> result<decision, string>;
 
+    /// Evaluate a tool invocation (tools/call) before execution
+    /// tool-name: name of the tool being invoked
+    /// arguments: JSON-serialized tool arguments
+    evaluate-tool-invoke: func(tool-name: string, arguments: string, context: guard-context) -> result<decision, string>;
+
+    /// Evaluate a response from the MCP server
+    /// response: JSON-serialized response content
+    evaluate-response: func(response: string, context: guard-context) -> result<decision, string>;
+
     /// Get JSON Schema describing guard's configurable parameters
     /// Returns JSON-serialized JSON Schema (Draft 2020-12)
     /// Schema describes guard-specific settings only (not common settings like priority, timeout)
diff --git a/crates/agentgateway/src/state_manager.rs b/crates/agentgateway/src/state_manager.rs
index 8f186c5d5..92eb77d0b 100644
--- a/crates/agentgateway/src/state_manager.rs
+++ b/crates/agentgateway/src/state_manager.rs
@@ -195,12 +195,42 @@ impl LocalClient {
 		.await?;
 		info!("loaded config from {:?}", self.cfg);
 
+		// Extract MCP backend guard configs before sync_local consumes backends
+		let mcp_guard_configs: Vec<_> = config
+			.backends
+			.iter()
+			.filter_map(|bwp| {
+				if let crate::types::agent::Backend::MCP(_, mcp) = &bwp.backend {
+					let backend_name = bwp.backend.name().to_string();
+					Some((backend_name, mcp.security_guards.clone()))
+				} else {
+					None
+				}
+			})
+			.collect();
+
 		// Sync the state
 		let next_binds =
 			self
 				.stores
 				.binds
 				.sync_local(config.binds, config.policies, config.backends, prev.binds);
+
+		// Hot-reload security guards for MCP backends
+		for (backend_name, guards) in mcp_guard_configs {
+			if let Err(e) = self
+				.stores
+				.guard_registry
+				.update_backend(&backend_name, guards)
+			{
+				warn!(
+					backend = %backend_name,
+					error = %e,
+					"Failed to hot-reload security guards"
+				);
+			}
+		}
+
 		let next_discovery =
 			self
 				.stores
diff --git a/crates/agentgateway/src/ui.rs b/crates/agentgateway/src/ui.rs
index c1d984aaa..2034c8138 100644
--- a/crates/agentgateway/src/ui.rs
+++ b/crates/agentgateway/src/ui.rs
@@ -17,7 +17,7 @@ use tower_http::cors::CorsLayer;
 use tower_serve_static::ServeDir;
 
 use crate::management::admin::{AdminFallback, AdminResponse};
-use crate::mcp::security::McpGuardKind;
+use crate::mcp::security::{McpGuardKind, McpSecurityGuard};
 use crate::{Config, ConfigSource, client, yamlviajson};
 
 pub struct UiHandler {
@@ -156,69 +156,91 @@ async fn get_guard_schemas(State(app): State<App>) -> Result<Json<Value>, ErrorR
 /// matching the GuardSchemasResponse format expected by the frontend.
 #[allow(unused_variables)]
 fn collect_wasm_schemas_from_config(config: &Value, schemas: &mut serde_json::Map<String, Value>) {
-	// Navigate: backends[] -> mcp -> security_guards[]
-	let Some(backends) = config.get("backends").and_then(|v| v.as_array()) else {
+	// Navigate: binds[] -> listeners[] -> routes[] -> backends[] -> mcp -> securityGuards[]
+	let Some(binds) = config.get("binds").and_then(|v| v.as_array()) else {
 		return;
 	};
 
-	for backend in backends {
-		let Some(mcp) = backend.get("mcp") else {
+	for bind in binds {
+		let Some(listeners) = bind.get("listeners").and_then(|v| v.as_array()) else {
 			continue;
 		};
-		let Some(guards) = mcp.get("security_guards").and_then(|v| v.as_array()) else {
-			continue;
-		};
-
-		for guard_val in guards {
-			let Some(guard_type) = guard_val.get("type").and_then(|v| v.as_str()) else {
+		for listener in listeners {
+			let Some(routes) = listener.get("routes").and_then(|v| v.as_array()) else {
 				continue;
 			};
-			if guard_type != "wasm" {
-				continue;
+			for route in routes {
+				let Some(backends) = route.get("backends").and_then(|v| v.as_array()) else {
+					continue;
+				};
+				for backend in backends {
+					let Some(mcp) = backend.get("mcp") else {
+						continue;
+					};
+					let Some(guards) = mcp.get("securityGuards").and_then(|v| v.as_array()) else {
+						continue;
+					};
+					collect_wasm_schemas_from_guards(guards, schemas);
+				}
 			}
+		}
+	}
+}
 
-			let Some(guard_id) = guard_val.get("id").and_then(|v| v.as_str()) else {
-				continue;
-			};
+/// Extract schemas from a list of guard config values.
+#[allow(unused_variables)]
+fn collect_wasm_schemas_from_guards(guards: &[Value], schemas: &mut serde_json::Map<String, Value>) {
+	for guard_val in guards {
+		let Some(guard_type) = guard_val.get("type").and_then(|v| v.as_str()) else {
+			continue;
+		};
+		if guard_type != "wasm" {
+			continue;
+		}
 
-			// Try to deserialize as McpGuardKind to get WasmGuardConfig
-			if let Ok(kind) = serde_json::from_value::<McpGuardKind>(guard_val.clone()) {
-				#[cfg(feature = "wasm-guards")]
-				if let McpGuardKind::Wasm(wasm_cfg) = kind {
-					match crate::mcp::security::wasm::WasmGuard::new(guard_id.to_string(), wasm_cfg) {
-						Ok(wasm_guard) => {
-							if let Ok(schema_str) = wasm_guard.get_settings_schema() {
-								if let Ok(schema_val) = serde_json::from_str::<Value>(&schema_str) {
-									// Use x-guard-meta.guardType as key, fall back to guard id
-									let schema_key = schema_val
-										.get("x-guard-meta")
-										.and_then(|m| m.get("guardType"))
-										.and_then(|v| v.as_str())
-										.unwrap_or(guard_id)
-										.to_string();
+		let Some(guard_id) = guard_val.get("id").and_then(|v| v.as_str()) else {
+			continue;
+		};
+
+		// Deserialize as full McpSecurityGuard (which flattens McpGuardKind),
+		// then extract .kind to get WasmGuardConfig
+		if let Ok(guard) = serde_json::from_value::<McpSecurityGuard>(guard_val.clone()) {
+			let kind = guard.kind;
+			#[cfg(feature = "wasm-guards")]
+			if let McpGuardKind::Wasm(wasm_cfg) = kind {
+				match crate::mcp::security::wasm::WasmGuard::new(guard_id.to_string(), wasm_cfg) {
+					Ok(wasm_guard) => {
+						if let Ok(schema_str) = wasm_guard.get_settings_schema() {
+							if let Ok(schema_val) = serde_json::from_str::<Value>(&schema_str) {
+								// Use x-guard-meta.guardType as key, fall back to guard id
+								let schema_key = schema_val
+									.get("x-guard-meta")
+									.and_then(|m| m.get("guardType"))
+									.and_then(|v| v.as_str())
+									.unwrap_or(guard_id)
+									.to_string();
 
-									schemas.insert(schema_key, schema_val);
-								}
+								schemas.insert(schema_key, schema_val);
 							}
-						},
-						Err(e) => {
-							tracing::warn!(
-								guard_id = guard_id,
-								error = %e,
-								"Failed to load WASM guard for schema extraction"
-							);
-						},
-					}
+						}
+					},
+					Err(e) => {
+						tracing::warn!(
+							guard_id = guard_id,
+							error = %e,
+							"Failed to load WASM guard for schema extraction"
+						);
+					},
 				}
+			}
 
-				#[cfg(not(feature = "wasm-guards"))]
-				{
-					let _ = kind;
-					tracing::debug!(
-						guard_id = guard_id,
-						"WASM guards feature not enabled, skipping schema extraction"
-					);
-				}
+			#[cfg(not(feature = "wasm-guards"))]
+			{
+				let _ = kind;
+				tracing::debug!(
+					guard_id = guard_id,
+					"WASM guards feature not enabled, skipping schema extraction"
+				);
 			}
 		}
 	}
diff --git a/examples/wasm-guards/simple-pattern-guard/src/lib.rs b/examples/wasm-guards/simple-pattern-guard/src/lib.rs
index aa875726a..7b3d56190 100644
--- a/examples/wasm-guards/simple-pattern-guard/src/lib.rs
+++ b/examples/wasm-guards/simple-pattern-guard/src/lib.rs
@@ -98,6 +98,21 @@ impl Guest for SimplePatternGuard {
         Ok(Decision::Allow)
     }
 
+    fn evaluate_tool_invoke(
+        _tool_name: String,
+        _arguments: String,
+        _context: GuardContext,
+    ) -> Result<Decision, String> {
+        Ok(Decision::Allow)
+    }
+
+    fn evaluate_response(
+        _response: String,
+        _context: GuardContext,
+    ) -> Result<Decision, String> {
+        Ok(Decision::Allow)
+    }
+
     fn get_settings_schema() -> String {
         serde_json::json!({
             "$schema": "https://json-schema.org/draft/2020-12/schema",
diff --git a/examples/wasm-guards/simple-pattern-guard/wit/guard.wit b/examples/wasm-guards/simple-pattern-guard/wit/guard.wit
index 0df40fe37..cd879fd3e 100644
--- a/examples/wasm-guards/simple-pattern-guard/wit/guard.wit
+++ b/examples/wasm-guards/simple-pattern-guard/wit/guard.wit
@@ -48,6 +48,12 @@ interface guard {
     /// Called by the host before connecting to an MCP server
     evaluate-server-connection: func(context: guard-context) -> result<decision, string>;
 
+    /// Evaluate a tool invocation (tools/call) before execution
+    evaluate-tool-invoke: func(tool-name: string, arguments: string, context: guard-context) -> result<decision, string>;
+
+    /// Evaluate a response from the MCP server
+    evaluate-response: func(response: string, context: guard-context) -> result<decision, string>;
+
     /// Get JSON Schema describing guard's configurable parameters
     /// Returns JSON-serialized JSON Schema (Draft 2020-12)
     /// Schema describes guard-specific settings only (not common settings like priority, timeout)
diff --git a/ui/src/components/backend/backend-components.tsx b/ui/src/components/backend/backend-components.tsx
index a14a960b1..c690326ca 100644
--- a/ui/src/components/backend/backend-components.tsx
+++ b/ui/src/components/backend/backend-components.tsx
@@ -67,6 +67,8 @@ import {
   PII_ACTIONS,
   SCAN_FIELDS,
 } from "@/lib/backend-constants";
+import { SchemaForm } from "@/components/schema-form";
+import { useGuardSchemas } from "@/hooks/useGuardSchemas";
 import type { SecurityGuard, SecurityGuardType } from "@/lib/types";
 import {
   getBackendType,
@@ -718,6 +720,7 @@ const SecurityGuardsSection: React.FC<SecurityGuardsSectionProps> = ({
 }) => {
   const [isExpanded, setIsExpanded] = React.useState(guards.length > 0);
   const [expandedGuards, setExpandedGuards] = React.useState<Set<number>>(new Set());
+  const { schemas } = useGuardSchemas();
 
   const toggleGuardExpanded = (index: number) => {
     setExpandedGuards((prev) => {
@@ -1257,35 +1260,70 @@ const SecurityGuardsSection: React.FC<SecurityGuardsSectionProps> = ({
                             />
                           </div>
                         </div>
-                        <div className="space-y-1">
-                          <Label className="text-xs">Config (key=value per line)</Label>
-                          <textarea
-                            value={Object.entries(guard.config || {})
-                              .map(([k, v]) => `${k}=${JSON.stringify(v)}`)
-                              .join("\n")}
-                            onChange={(e) => {
-                              const configObj: Record<string, unknown> = {};
-                              e.target.value.split("\n").forEach((line) => {
-                                const eqIdx = line.indexOf("=");
-                                if (eqIdx > 0) {
-                                  const key = line.slice(0, eqIdx).trim();
-                                  const valStr = line.slice(eqIdx + 1).trim();
+                        {/* Schema-driven config form or JSON fallback */}
+                        {(() => {
+                          // For WASM guards, match schema by module_path filename or guardType
+                          const guardSchema = (() => {
+                            // Direct match by guard id
+                            if (schemas[guard.id]) return schemas[guard.id];
+
+                            if (guard.type === "wasm" && guard.module_path) {
+                              // Extract base name: "server_spoofing_guard.wasm" -> "server_spoofing"
+                              const filename =
+                                guard.module_path
+                                  .split("/")
+                                  .pop()
+                                  ?.replace(/_guard\.wasm$/, "")
+                                  .replace(/\.wasm$/, "") || "";
+
+                              // Match against x-guard-meta.guardType
+                              const byGuardType = Object.entries(schemas).find(([key, s]) => {
+                                const gt = s["x-guard-meta"]?.guardType;
+                                return gt === filename || key === filename;
+                              });
+                              if (byGuardType) return byGuardType[1];
+                            }
+
+                            // Fallback: match by guardType === guard.id
+                            return Object.values(schemas).find(
+                              (s) => s["x-guard-meta"]?.guardType === guard.id
+                            );
+                          })();
+
+                          if (guardSchema) {
+                            return (
+                              <SchemaForm
+                                schema={guardSchema}
+                                value={guard.config || {}}
+                                onChange={(newConfig) =>
+                                  updateSecurityGuardField(index, "config", newConfig)
+                                }
+                              />
+                            );
+                          }
+
+                          return (
+                            <div className="space-y-1">
+                              <Label className="text-xs">Config (JSON)</Label>
+                              <textarea
+                                value={JSON.stringify(guard.config || {}, null, 2)}
+                                onChange={(e) => {
                                   try {
-                                    configObj[key] = JSON.parse(valStr);
+                                    updateSecurityGuardField(
+                                      index,
+                                      "config",
+                                      JSON.parse(e.target.value)
+                                    );
                                   } catch {
-                                    configObj[key] = valStr;
+                                    /* ignore parse errors while typing */
                                   }
-                                }
-                              });
-                              updateSecurityGuardField(index, "config", configObj);
-                            }}
-                            placeholder={'sensitivity="high"\ndeny_threshold=0.5'}
-                            className="w-full h-20 px-2 py-1 text-sm border rounded-md font-mono"
-                          />
-                          <p className="text-xs text-muted-foreground">
-                            Values are JSON-parsed (use quotes for strings)
-                          </p>
-                        </div>
+                                }}
+                                placeholder="{}"
+                                className="w-full h-32 px-2 py-1 text-sm border rounded-md font-mono"
+                              />
+                            </div>
+                          );
+                        })()}
                       </div>
                     )}
                   </div>
diff --git a/ui/src/lib/backend-constants.ts b/ui/src/lib/backend-constants.ts
index 3311f2323..996bc1b59 100644
--- a/ui/src/lib/backend-constants.ts
+++ b/ui/src/lib/backend-constants.ts
@@ -232,6 +232,7 @@ export const SECURITY_GUARD_TYPES: Array<{
 
 // Guard phases for UI selection
 export const GUARD_PHASES: Array<{ value: GuardPhase; label: string }> = [
+  { value: "connection", label: "Connection" },
   { value: "request", label: "Request" },
   { value: "response", label: "Response" },
   { value: "tools_list", label: "Tools List" },
diff --git a/ui/src/lib/types.ts b/ui/src/lib/types.ts
index 743365c96..cce2f95a5 100644
--- a/ui/src/lib/types.ts
+++ b/ui/src/lib/types.ts
@@ -498,7 +498,7 @@ export interface ListenerInfo extends Listener {
 // =============================================================================
 
 // Guard phase types (matches Rust GuardPhase enum)
-export type GuardPhase = "request" | "response" | "tools_list" | "tool_invoke";
+export type GuardPhase = "connection" | "request" | "response" | "tools_list" | "tool_invoke";
 
 // Failure mode (matches Rust FailureMode enum)
 export type FailureMode = "fail_closed" | "fail_open";

From 2ea00973b84fb1de1d35b371f9eb76b0ee3f9e4b Mon Sep 17 00:00:00 2001
From: Alexey Puzik <alexey.puzik@devpulse.io>
Date: Mon, 16 Feb 2026 14:55:51 +0200
Subject: [PATCH 08/10] Load UI for config for recently added guards

---
 crates/agentgateway/src/app.rs |  2 +-
 crates/agentgateway/src/ui.rs  | 38 ++++++++++++++++++++++++++--------
 2 files changed, 30 insertions(+), 10 deletions(-)

diff --git a/crates/agentgateway/src/app.rs b/crates/agentgateway/src/app.rs
index 655d33fd3..eaa1be065 100644
--- a/crates/agentgateway/src/app.rs
+++ b/crates/agentgateway/src/app.rs
@@ -109,7 +109,7 @@ pub async fn run(config: Arc<Config>) -> anyhow::Result<Bound> {
 	.await
 	.context("admin server starts")?;
 	#[cfg(feature = "ui")]
-	admin_server.set_admin_handler(Arc::new(crate::ui::UiHandler::new(config.clone())));
+	admin_server.set_admin_handler(Arc::new(crate::ui::UiHandler::new(config.clone(), stores.guard_registry.clone())));
 	#[cfg(feature = "ui")]
 	info!("serving UI at http://{}/ui", config.admin_addr);
 
diff --git a/crates/agentgateway/src/ui.rs b/crates/agentgateway/src/ui.rs
index 2034c8138..76ec06368 100644
--- a/crates/agentgateway/src/ui.rs
+++ b/crates/agentgateway/src/ui.rs
@@ -17,7 +17,7 @@ use tower_http::cors::CorsLayer;
 use tower_serve_static::ServeDir;
 
 use crate::management::admin::{AdminFallback, AdminResponse};
-use crate::mcp::security::{McpGuardKind, McpSecurityGuard};
+use crate::mcp::security::{GuardExecutorRegistry, McpGuardKind, McpSecurityGuard};
 use crate::{Config, ConfigSource, client, yamlviajson};
 
 pub struct UiHandler {
@@ -28,6 +28,7 @@ pub struct UiHandler {
 struct App {
 	state: Arc<Config>,
 	client: client::Client,
+	guard_registry: GuardExecutorRegistry,
 }
 
 impl App {
@@ -46,7 +47,7 @@ lazy_static::lazy_static! {
 }
 
 impl UiHandler {
-	pub fn new(cfg: Arc<Config>) -> Self {
+	pub fn new(cfg: Arc<Config>, guard_registry: GuardExecutorRegistry) -> Self {
 		let ui_service = ServeDir::new(&ASSETS_DIR);
 		let router = Router::new()
 			// Redirect to the UI
@@ -58,6 +59,7 @@ impl UiHandler {
 			.with_state(App {
 				state: cfg.clone(),
 				client: client::Client::new(&cfg.dns, None, Default::default(), None),
+				guard_registry,
 			});
 		Self { router }
 	}
@@ -132,16 +134,34 @@ async fn write_config(
 }
 
 /// GET /api/v1/guards/schemas
-/// Returns JSON Schemas for all guards (native schemas are embedded in the frontend;
-/// WASM guard schemas are extracted by loading each WASM module and calling get-settings-schema).
+/// Returns JSON Schemas for all guards.
+/// Primary source: already-loaded guards from the registry (works regardless of file paths).
+/// Fallback: re-instantiate WASM modules from config (for when guards haven't connected yet).
 async fn get_guard_schemas(State(app): State<App>) -> Result<Json<Value>, ErrorResponse> {
 	let mut schemas = serde_json::Map::new();
 
-	// Read config to find WASM guards
-	if let Ok(cfg_source) = app.cfg() {
-		if let Ok(yaml_str) = cfg_source.read_to_string().await {
-			if let Ok(config_val) = yamlviajson::from_str::<Value>(&yaml_str) {
-				collect_wasm_schemas_from_config(&config_val, &mut schemas);
+	// Primary: query already-loaded guards from the registry
+	let registry_schemas = app.guard_registry.collect_wasm_schemas();
+	for (guard_id, wasm_schema) in &registry_schemas {
+		// Use x-guard-meta.guardType as key, fall back to guard id
+		let schema_key = wasm_schema
+			.settings_schema
+			.get("x-guard-meta")
+			.and_then(|m| m.get("guardType"))
+			.and_then(|v| v.as_str())
+			.unwrap_or(guard_id)
+			.to_string();
+		schemas.insert(schema_key, wasm_schema.settings_schema.clone());
+	}
+
+	// Fallback: if registry had no schemas, try loading from config
+	// (handles case where no MCP clients have connected yet)
+	if schemas.is_empty() {
+		if let Ok(cfg_source) = app.cfg() {
+			if let Ok(yaml_str) = cfg_source.read_to_string().await {
+				if let Ok(config_val) = yamlviajson::from_str::<Value>(&yaml_str) {
+					collect_wasm_schemas_from_config(&config_val, &mut schemas);
+				}
 			}
 		}
 	}

From 7df9a21c4fa060f2edf26ff367b480f78363fe64 Mon Sep 17 00:00:00 2001
From: Alexey Puzik <alexey.puzik@devpulse.io>
Date: Mon, 16 Feb 2026 15:57:01 +0200
Subject: [PATCH 09/10] Fix formatting

---
 crates/agentgateway/src/app.rs               |  5 +-
 crates/agentgateway/src/mcp/handler.rs       |  5 +-
 crates/agentgateway/src/mcp/security/wasm.rs | 50 +++++++++-----------
 crates/agentgateway/src/ui.rs                |  5 +-
 4 files changed, 34 insertions(+), 31 deletions(-)

diff --git a/crates/agentgateway/src/app.rs b/crates/agentgateway/src/app.rs
index eaa1be065..876fd3947 100644
--- a/crates/agentgateway/src/app.rs
+++ b/crates/agentgateway/src/app.rs
@@ -109,7 +109,10 @@ pub async fn run(config: Arc<Config>) -> anyhow::Result<Bound> {
 	.await
 	.context("admin server starts")?;
 	#[cfg(feature = "ui")]
-	admin_server.set_admin_handler(Arc::new(crate::ui::UiHandler::new(config.clone(), stores.guard_registry.clone())));
+	admin_server.set_admin_handler(Arc::new(crate::ui::UiHandler::new(
+		config.clone(),
+		stores.guard_registry.clone(),
+	)));
 	#[cfg(feature = "ui")]
 	info!("serving UI at http://{}/ui", config.admin_addr);
 
diff --git a/crates/agentgateway/src/mcp/handler.rs b/crates/agentgateway/src/mcp/handler.rs
index 405d76be1..c5088568e 100644
--- a/crates/agentgateway/src/mcp/handler.rs
+++ b/crates/agentgateway/src/mcp/handler.rs
@@ -177,7 +177,10 @@ impl Relay {
 				identity: None,
 				metadata: serde_json::Value::Null,
 			};
-			match self.security_guards.evaluate_connection(&server_name, None, &context) {
+			match self
+				.security_guards
+				.evaluate_connection(&server_name, None, &context)
+			{
 				Ok(crate::mcp::security::GuardDecision::Allow) => {
 					tracing::info!(server = %server_name, "Connection guard: allowed");
 				},
diff --git a/crates/agentgateway/src/mcp/security/wasm.rs b/crates/agentgateway/src/mcp/security/wasm.rs
index e368368bc..8e5717767 100644
--- a/crates/agentgateway/src/mcp/security/wasm.rs
+++ b/crates/agentgateway/src/mcp/security/wasm.rs
@@ -625,20 +625,17 @@ impl NativeGuard for WasmGuard {
 				})?;
 
 			// Try to get evaluate-tool-invoke — if not exported, allow (backward compat)
-			let func_export_idx = match instance.get_export(
-				&mut store,
-				Some(&guard_export_idx),
-				"evaluate-tool-invoke",
-			) {
-				Some(idx) => idx,
-				None => {
-					tracing::debug!(
-						guard_id = %self.guard_id,
-						"WASM guard does not export evaluate-tool-invoke, allowing"
-					);
-					return Ok(GuardDecision::Allow);
-				},
-			};
+			let func_export_idx =
+				match instance.get_export(&mut store, Some(&guard_export_idx), "evaluate-tool-invoke") {
+					Some(idx) => idx,
+					None => {
+						tracing::debug!(
+							guard_id = %self.guard_id,
+							"WASM guard does not export evaluate-tool-invoke, allowing"
+						);
+						return Ok(GuardDecision::Allow);
+					},
+				};
 
 			let func = instance
 				.get_func(&mut store, &func_export_idx)
@@ -715,20 +712,17 @@ impl NativeGuard for WasmGuard {
 				})?;
 
 			// Try to get evaluate-response — if not exported, allow (backward compat)
-			let func_export_idx = match instance.get_export(
-				&mut store,
-				Some(&guard_export_idx),
-				"evaluate-response",
-			) {
-				Some(idx) => idx,
-				None => {
-					tracing::debug!(
-						guard_id = %self.guard_id,
-						"WASM guard does not export evaluate-response, allowing"
-					);
-					return Ok(GuardDecision::Allow);
-				},
-			};
+			let func_export_idx =
+				match instance.get_export(&mut store, Some(&guard_export_idx), "evaluate-response") {
+					Some(idx) => idx,
+					None => {
+						tracing::debug!(
+							guard_id = %self.guard_id,
+							"WASM guard does not export evaluate-response, allowing"
+						);
+						return Ok(GuardDecision::Allow);
+					},
+				};
 
 			let func = instance
 				.get_func(&mut store, &func_export_idx)
diff --git a/crates/agentgateway/src/ui.rs b/crates/agentgateway/src/ui.rs
index 76ec06368..a5e3f2e22 100644
--- a/crates/agentgateway/src/ui.rs
+++ b/crates/agentgateway/src/ui.rs
@@ -209,7 +209,10 @@ fn collect_wasm_schemas_from_config(config: &Value, schemas: &mut serde_json::Ma
 
 /// Extract schemas from a list of guard config values.
 #[allow(unused_variables)]
-fn collect_wasm_schemas_from_guards(guards: &[Value], schemas: &mut serde_json::Map<String, Value>) {
+fn collect_wasm_schemas_from_guards(
+	guards: &[Value],
+	schemas: &mut serde_json::Map<String, Value>,
+) {
 	for guard_val in guards {
 		let Some(guard_type) = guard_val.get("type").and_then(|v| v.as_str()) else {
 			continue;

From 58f100f0a9e19aaf3fd649b97c850cebcd26e8b3 Mon Sep 17 00:00:00 2001
From: Alexey Puzik <alexey.puzik@devpulse.io>
Date: Mon, 16 Feb 2026 16:51:35 +0200
Subject: [PATCH 10/10] Fix formatting in schema

---
 schema/config.json | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/schema/config.json b/schema/config.json
index 04b60d010..bd6932cf2 100644
--- a/schema/config.json
+++ b/schema/config.json
@@ -7219,6 +7219,11 @@
                                             "items": {
                                               "description": "Execution phase for guards",
                                               "oneOf": [
+                                                {
+                                                  "description": "Before establishing connection to MCP server\nUsed for server whitelisting, typosquat detection, TLS validation",
+                                                  "type": "string",
+                                                  "const": "connection"
+                                                },
                                                 {
                                                   "description": "Before forwarding client request to MCP server",
                                                   "type": "string",