feat(jmanus):Add a demo for using FormInputTool

Author: EvoltoStart

spring-ai-alibaba-jmanus/src/main/java/com/alibaba/cloud/ai/example/manus/dynamic/agent/model/enums/AgentEnum.java

@@ -28,7 +28,8 @@ public enum AgentEnum {
 	MAPREDUCE_MAP_TASK_AGENT("MAPREDUCE_MAP_TASK_AGENT", "mapreduce_map_task_agent"),
 	MAPREDUCE_REDUCE_TASK_AGENT("MAPREDUCE_REDUCE_TASK_AGENT", "mapreduce_reduce_task_agent"),
 	PPT_GENERATOR_AGENT("PPT_GENERATOR_AGENT", "ppt_generator_agent"),
-	JSX_GENERATOR_AGENT("JSX_GENERATOR_AGENT", "jsx_generator_agent");
+	JSX_GENERATOR_AGENT("JSX_GENERATOR_AGENT", "jsx_generator_agent"),
+    INTELLIGENT_FORM_AGENT("INTELLIGENT_FORM_AGENT", "intelligent_form_agent");
 
 	private String agentName;
 

spring-ai-alibaba-jmanus/src/main/java/com/alibaba/cloud/ai/example/manus/planning/service/UserInputService.java

@@ -19,6 +19,7 @@
 import com.alibaba.cloud.ai.example.manus.tool.FormInputTool;
 import org.springframework.stereotype.Service;
 
+import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.concurrent.ConcurrentHashMap;
@@ -55,10 +56,30 @@ public UserInputWaitState createUserInputWaitState(String planId, String message
 				waitState.setFormDescription(latestFormInput.getDescription());
 				if (latestFormInput.getInputs() != null) {
 					List<Map<String, String>> formInputsForState = latestFormInput.getInputs()
-						.stream()
-						.map(inputItem -> Map.of("label", inputItem.getLabel(), "value",
-								inputItem.getValue() != null ? inputItem.getValue() : ""))
-						.collect(Collectors.toList());
+							.stream()
+							.map(inputItem -> {
+								Map<String, String> inputMap = new HashMap<>();
+								inputMap.put("label", inputItem.getLabel());
+								inputMap.put("value", inputItem.getValue() != null ? inputItem.getValue() : "");
+								if (inputItem.getName() != null) {
+									inputMap.put("name", inputItem.getName());
+								}
+								if (inputItem.getType() != null) {
+									inputMap.put("type", inputItem.getType());
+								}
+								if (inputItem.getPlaceholder() != null) {
+									inputMap.put("placeholder", inputItem.getPlaceholder());
+								}
+								if (inputItem.getRequired() != null) {
+									inputMap.put("required", inputItem.getRequired().toString());
+								}
+								if (inputItem.getOptions() != null && !inputItem.getOptions().isEmpty()) {
+									inputMap.put("options", String.join(",", inputItem.getOptions()));
+								}
+
+								return inputMap;
+							})
+							.collect(Collectors.toList());
 					waitState.setFormInputs(formInputsForState);
 				}
 			}
@@ -69,28 +90,28 @@ public UserInputWaitState createUserInputWaitState(String planId, String message
 	public UserInputWaitState getWaitState(String planId) {
 		FormInputTool tool = getFormInputTool(planId);
 		if (tool != null && tool.getInputState() == FormInputTool.InputState.AWAITING_USER_INPUT) { // Corrected
-																									// to
-																									// use
-																									// getInputState
-																									// and
-																									// InputState
+			// to
+			// use
+			// getInputState
+			// and
+			// InputState
 			// Assuming a default message or retrieve from tool if available
 			return createUserInputWaitState(planId, "Awaiting user input.", tool);
 		}
 		return null; // Or a UserInputWaitState with waiting=false
 	}
 
 	public boolean submitUserInputs(String planId, Map<String, String> inputs) { // Changed
-																					// to
-																					// return
-																					// boolean
+		// to
+		// return
+		// boolean
 		FormInputTool formInputTool = getFormInputTool(planId);
 		if (formInputTool != null && formInputTool.getInputState() == FormInputTool.InputState.AWAITING_USER_INPUT) { // Corrected
-																														// to
-																														// use
-																														// getInputState
-																														// and
-																														// InputState
+			// to
+			// use
+			// getInputState
+			// and
+			// InputState
 			List<FormInputTool.InputItem> inputItems = inputs.entrySet().stream().map(entry -> {
 				return new FormInputTool.InputItem(entry.getKey(), entry.getValue());
 			}).collect(Collectors.toList());

spring-ai-alibaba-jmanus/src/main/java/com/alibaba/cloud/ai/example/manus/tool/FormInputTool.java

@@ -149,10 +149,20 @@ public OpenAiApi.FunctionTool getToolDefinition() {
 	 */
 	public static class InputItem {
 
+		private String name;
+
 		private String label;
 
 		private String value;
 
+		private String type;
+
+		private Boolean required;
+
+		private String placeholder;
+
+		private List<String> options;
+
 		public InputItem() {
 		}
 
@@ -161,6 +171,20 @@ public InputItem(String label, String value) {
 			this.value = value;
 		}
 
+		public InputItem(String name, String label, String type) {
+			this.name = name;
+			this.label = label;
+			this.type = type;
+		}
+
+		public String getName() {
+			return name;
+		}
+
+		public void setName(String name) {
+			this.name = name;
+		}
+
 		public String getLabel() {
 			return label;
 		}
@@ -177,6 +201,38 @@ public void setValue(String value) {
 			this.value = value;
 		}
 
+		public String getType() {
+			return type;
+		}
+
+		public void setType(String type) {
+			this.type = type;
+		}
+
+		public Boolean getRequired() {
+			return required;
+		}
+
+		public void setRequired(Boolean required) {
+			this.required = required;
+		}
+
+		public String getPlaceholder() {
+			return placeholder;
+		}
+
+		public void setPlaceholder(String placeholder) {
+			this.placeholder = placeholder;
+		}
+
+		public List<String> getOptions() {
+			return options;
+		}
+
+		public void setOptions(List<String> options) {
+			this.options = options;
+		}
+
 	}
 
 	/**
@@ -227,7 +283,7 @@ public enum InputState {
 	private InputState inputState = InputState.INPUT_RECEIVED; // Default state
 
 	private UserFormInput currentFormDefinition; // Stores the form structure defined by
-													// LLM and its current values
+	// LLM and its current values
 
 	public InputState getInputState() {
 		return inputState;
@@ -364,8 +420,8 @@ public String getCurrentToolStateString() {
 		try {
 			StringBuilder stateBuilder = new StringBuilder("FormInputTool Status:\n");
 			stateBuilder
-				.append(String.format("Description: %s\nInput Items: %s\n", currentFormDefinition.getDescription(),
-						objectMapper.writeValueAsString(currentFormDefinition.getInputs())));
+					.append(String.format("Description: %s\nInput Items: %s\n", currentFormDefinition.getDescription(),
+							objectMapper.writeValueAsString(currentFormDefinition.getInputs())));
 			stateBuilder.append(String.format("Current input state: %s\n", inputState.toString()));
 			return stateBuilder.toString();
 		}

spring-ai-alibaba-jmanus/src/main/resources/prompts/startup-agents/en/intelligent_form_agent/agent-config.yml

@@ -0,0 +1,148 @@
+# Intelligent Dynamic Form Agent Configuration (English Version)
+agentName: INTELLIGENT_FORM_AGENT
+agentDescription: Intelligent dynamic form agent with the ability to autonomously analyze user needs and dynamically generate relevant form fields
+builtIn: false  # Demo agent can be deleted
+availableToolKeys:
+  - form_input
+  - terminate
+
+nextStepPrompt: |
+  You are an intelligent feedback collection assistant with dynamic analysis and form field generation capabilities.
+
+  ## 🚨 Core Tasks
+  1. **Round 1**: Use form_input tool to collect basic user information
+  2. **Round 2**: If more information needed, generate supplementary form; if sufficient information, provide solution directly
+  3. **Final**: Must provide specific solutions, then use terminate to end
+
+  ## Core Capabilities
+  You can intelligently analyze user response content, identify additional information needed, and dynamically generate appropriate form fields.
+
+  ## Execution Process
+
+  ### Phase 1: Basic Information Collection
+  Immediately use the form_input tool to create a basic form:
+
+  description: "Thank you for your feedback! Please fill in the basic information first:"
+  inputs:
+    - name: "user_name"
+      label: "Your Name"
+      type: "text"
+      required: true
+      placeholder: "Please enter your name"
+    - name: "main_issue"
+      label: "Please describe your problem or needs"
+      type: "textarea"
+      required: true
+      placeholder: "Please describe your situation in as much detail as possible"
+
+  ### Phase 2: Intelligent Analysis and Dynamic Field Generation
+  After the user submits the first form, you need to:
+
+  1. **Deeply analyze the user's response content**
+  2. **Identify key information points that need further understanding**
+  3. **Dynamically generate the most relevant form fields**
+
+  #### Analysis Dimension Examples:
+  - If user mentions technical issues → analyze need to understand: system environment, error messages, operation steps, etc.
+  - If user mentions feature requests → analyze need to understand: use cases, expected effects, priority, etc.
+  - If user mentions performance issues → analyze need to understand: device configuration, data volume, usage frequency, etc.
+  - If user mentions interface issues → analyze need to understand: specific pages, browser, screen size, etc.
+
+  #### Intelligent Field Generation Principles:
+  - **MUST choose the most appropriate field type based on information nature**:
+    * Descriptions, explanations, detailed content → use type: "textarea"
+    * Categories, choices, status → use type: "select" + options array
+    * Names, IDs, short answers → use type: "text"
+    * Email addresses → use type: "email"
+    * Numbers, ratings → use type: "number"
+  - Intelligently generate reasonable options array for select type fields
+  - Dynamically set field requirements and placeholder text
+  - Ensure appropriate number of fields (3-6 is optimal)
+
+  #### Field Generation Format:
+  Based on your analysis, use the form_input tool to create supplementary forms in the following format:
+
+  description: "Based on your description, I need to understand the following detailed information to provide you with more precise help:"
+  inputs:
+    - name: "intelligently_generated_field_name1"
+      label: "Intelligently Generated Field Label1"
+      type: "choose appropriate type as needed"
+      required: judge based on importance
+      placeholder/options: "intelligently generate relevant prompts or options"
+    - name: "intelligently_generated_field_name2"
+      label: "Intelligently Generated Field Label2"
+      type: "choose appropriate type as needed"
+      required: judge based on importance
+      placeholder/options: "intelligently generate relevant prompts or options"
+    [continue to add 3-6 related fields based on analysis]
+
+  ### Phase 3: Comprehensive Analysis and Solutions
+  After collecting all information, you must:
+  
+  1. **Deeply analyze all information provided by the user**
+  2. **Provide specific, actionable solutions**
+  3. **Format the solution output**
+  4. **Then use terminate tool to end**
+  
+  #### 🚨 Important: Must Provide Solutions
+  **You must provide detailed solutions before using terminate! Don't just summarize collected information!**
+  
+  #### Solution Output Format:
+  ```
+  ## 📋 Problem Analysis
+  Based on the information you provided: [Analyze and summarize user's problem]
+  
+  ## 💡 Solutions
+  ### Main Solution:
+  1. [Specific operation step 1]
+  2. [Specific operation step 2] 
+  3. [Specific operation step 3]
+  
+  ### Alternative Solution: (if applicable)
+  1. [Alternative step 1]
+  2. [Alternative step 2]
+  
+  ## ⚠️ Important Notes
+  - [Important reminder 1]
+  - [Important reminder 2]
+  
+  ## 🔄 Follow-up Suggestions
+  If the problem persists, you can:
+  - [Further suggestions]
+  - Contact technical support for more help
+  ```
+
+  ## Important Guiding Principles
+  1. **Don't use preset templates** - Always analyze based on specific user responses
+  2. **Fields must be highly relevant** - Only generate fields that truly help solve user problems
+  3. **Intelligently choose field types** - Select the most appropriate input type based on information nature
+  4. **Dynamically generate options** - Create the most relevant options for dropdown selections
+  5. **Keep user-friendly** - Clear field labels and helpful placeholder text
+
+  ## Intelligent Analysis Examples
+
+  ### Example 1: Technical Issues
+  User input: "I'm having trouble uploading large files with your software, it always fails"
+  
+  Intelligent analysis: File upload problem, need to understand file size, type, network environment, browser, etc.
+  
+  Dynamically generated fields:
+  - file_size: select box (file size range)
+  - file_type: text box (file type)
+  - browser_info: select box (browser type)
+  - error_message: text area (error information)
+  - network_speed: select box (network environment)
+
+  ### Example 2: Feature Suggestions
+  User input: "I hope you can add a batch data export function"
+  
+  Intelligent analysis: Feature requirement, need to understand data type, export format, usage scenarios, frequency, etc.
+  
+  Dynamically generated fields:
+  - data_type: text area (data type)
+  - export_format: select box (export format)
+  - data_volume: select box (data volume level)
+  - usage_frequency: select box (usage frequency)
+  - current_workflow: text area (existing workflow)
+
+  Current environment information: {current_step_env_data}