Add enum value support to input fields and improve error handling

Author: subpop

src/tui/app.rs

@@ -120,6 +120,8 @@ pub struct InputField {
     pub field_type: String,
     pub required: bool,
     pub description: Option<String>,
+    /// Allowed values when the schema specifies "enum" (e.g. elicitation requestedSchema).
+    pub enum_values: Option<Vec<String>>,
 }
 
 impl App {
@@ -486,6 +488,7 @@ impl App {
                 .entry(field_name.clone())
                 .or_default()
                 .push(c);
+            self.error_message = None;
         } else if self.tool_call_input_mode {
             self.tool_call_inputs
                 .entry(field_name.clone())
@@ -509,6 +512,7 @@ impl App {
             if let Some(value) = self.elicitation_inputs.get_mut(field_name) {
                 value.pop();
             }
+            self.error_message = None;
         } else if self.tool_call_input_mode {
             if let Some(value) = self.tool_call_inputs.get_mut(field_name) {
                 value.pop();
@@ -668,6 +672,7 @@ impl App {
                     field_type: "string".to_string(),
                     required: arg.required.unwrap_or(false),
                     description: arg.description.clone(),
+                    enum_values: None,
                 })
                 .collect()
         } else {
@@ -830,6 +835,17 @@ impl App {
             if let Some(value_str) = self.elicitation_inputs.get(&field.name) {
                 let value_str = value_str.trim();
                 if !value_str.is_empty() {
+                    if let Some(allowed) = &field.enum_values {
+                        if !allowed.iter().any(|v| v == value_str) {
+                            self.error_message = Some(format!(
+                                "Invalid value for '{}': \"{}\" is not allowed. Choose one of: {}.",
+                                field.name,
+                                value_str,
+                                allowed.join(", ")
+                            ));
+                            return;
+                        }
+                    }
                     let json_value = match field.field_type.as_str() {
                         "number" | "integer" => {
                             if let Ok(num) = value_str.parse::<i64>() {
@@ -1014,11 +1030,23 @@ fn parse_input_schema(schema: &Value) -> Vec<InputField> {
 
             let required = required_fields.contains(name);
 
+            let enum_values = prop.get("enum").and_then(|e| e.as_array()).map(|arr| {
+                arr.iter()
+                    .filter_map(|v| {
+                        v.as_str()
+                            .map(String::from)
+                            .or_else(|| v.as_i64().map(|n| n.to_string()))
+                            .or_else(|| v.as_f64().map(|n| n.to_string()))
+                    })
+                    .collect::<Vec<String>>()
+            });
+
             fields.push(InputField {
                 name: name.clone(),
                 field_type,
                 required,
                 description,
+                enum_values,
             });
         }
     }

src/tui/ui.rs

@@ -96,13 +96,16 @@ fn render_content(f: &mut Frame, app: &App, area: Rect) {
         return;
     }
 
+    // When in elicitation form, show errors inside the form overlay instead of replacing content
     if let Some(error) = &app.error_message {
-        let error_widget = Paragraph::new(error.as_str())
-            .block(Block::default().borders(Borders::ALL).title("Error"))
-            .style(Style::default().fg(Color::Red))
-            .wrap(Wrap { trim: true });
-        f.render_widget(error_widget, area);
-        return;
+        if !app.elicitation_input_mode {
+            let error_widget = Paragraph::new(error.as_str())
+                .block(Block::default().borders(Borders::ALL).title("Error"))
+                .style(Style::default().fg(Color::Red))
+                .wrap(Wrap { trim: true });
+            f.render_widget(error_widget, area);
+            return;
+        }
     }
 
     match app.current_tab {
@@ -627,6 +630,16 @@ fn render_tool_input_form(f: &mut Frame, app: &App) {
                 )));
             }
 
+            if let Some(opts) = &field.enum_values {
+                if !opts.is_empty() {
+                    let hint = format!("  Allowed: {}", opts.join(", "));
+                    lines.push(Line::from(Span::styled(
+                        hint,
+                        Style::default().fg(Color::DarkGray),
+                    )));
+                }
+            }
+
             let value_style = if is_current {
                 Style::default()
                     .fg(Color::Green)
@@ -798,9 +811,17 @@ fn render_elicitation_form(f: &mut Frame, app: &App) {
         .map(|p| p.message.lines().count())
         .unwrap_or(0)
         .max(1);
+    let error_lines = app
+        .error_message
+        .as_ref()
+        .map(|e| e.lines().count())
+        .unwrap_or(0);
     let popup_width = area.width.saturating_sub(10).min(80);
-    let popup_height = (message_lines as u16 + (app.input_fields.len() as u16 * 3) + 8)
-        .min(area.height.saturating_sub(4));
+    let popup_height = (message_lines as u16
+        + (error_lines as u16).saturating_add(2)
+        + (app.input_fields.len() as u16 * 3)
+        + 8)
+    .min(area.height.saturating_sub(4));
 
     let popup_area = Rect {
         x: (area.width.saturating_sub(popup_width)) / 2,
@@ -827,6 +848,20 @@ fn render_elicitation_form(f: &mut Frame, app: &App) {
 
     let mut lines = Vec::new();
 
+    if let Some(error) = &app.error_message {
+        lines.push(Line::from(Span::styled(
+            "Error:",
+            Style::default().fg(Color::Red).add_modifier(Modifier::BOLD),
+        )));
+        for line in error.lines() {
+            lines.push(Line::from(Span::styled(
+                line,
+                Style::default().fg(Color::Red),
+            )));
+        }
+        lines.push(Line::from(""));
+    }
+
     if let Some(pending) = &app.pending_elicitation {
         lines.push(Line::from(Span::styled(
             &pending.message,
@@ -878,6 +913,16 @@ fn render_elicitation_form(f: &mut Frame, app: &App) {
                 )));
             }
 
+            if let Some(opts) = &field.enum_values {
+                if !opts.is_empty() {
+                    let hint = format!("  Allowed: {}", opts.join(", "));
+                    lines.push(Line::from(Span::styled(
+                        hint,
+                        Style::default().fg(Color::DarkGray),
+                    )));
+                }
+            }
+
             let value_style = if is_current {
                 Style::default()
                     .fg(Color::Green)