refactor: align ask_followup_question tool with current patterns

- Add early return for partial blocks with incomplete required params
- Make follow_up parameter required and validate it properly
- Add validation for empty suggestions array
- Improve error messages to be more specific
- Update prompt description to clarify follow_up is required
- Align error handling with other tools (consecutiveMistakeCount, recordToolError)
- Minor text improvements in prompt description

Author: roomote

src/core/prompts/tools/ask-followup-question.ts

@@ -5,20 +5,16 @@ Parameters:
 - question: (required) The question to ask the user. This should be a clear, specific question that addresses the information you need.
 - follow_up: (required) A list of 2-4 suggested answers that logically follow from the question, ordered by priority or logical sequence. Each suggestion must:
   1. Be provided in its own <suggest> tag
-  2. Be specific, actionable, and directly related to the completed task
+  2. Be specific, actionable, and directly related to the question
   3. Be a complete answer to the question - the user should not need to provide additional information or fill in any missing details. DO NOT include placeholders with brackets or parentheses.
   4. Optionally include a mode attribute to switch to a specific mode when the suggestion is selected: <suggest mode="mode-slug">suggestion text</suggest>
      - When using the mode attribute, focus the suggestion text on the action to be taken rather than mentioning the mode switch, as the mode change is handled automatically and indicated by a visual badge
 Usage:
 <ask_followup_question>
 <question>Your question here</question>
 <follow_up>
-<suggest>
-Your suggested answer here
-</suggest>
-<suggest mode="code">
-Implement the solution
-</suggest>
+<suggest>Your first suggested answer here</suggest>
+<suggest mode="code">Implement the solution</suggest>
 </follow_up>
 </ask_followup_question>
 

src/core/tools/askFollowupQuestionTool.ts

@@ -16,6 +16,11 @@ export async function askFollowupQuestionTool(
 
 	try {
 		if (block.partial) {
+			// Early return if required parameter is not yet available
+			if (!question) {
+				return
+			}
+
 			await cline.ask("followup", removeClosingTag("question", question), block.partial).catch(() => {})
 			return
 		} else {
@@ -26,64 +31,81 @@ export async function askFollowupQuestionTool(
 				return
 			}
 
+			if (!follow_up) {
+				cline.consecutiveMistakeCount++
+				cline.recordToolError("ask_followup_question")
+				pushToolResult(await cline.sayAndCreateMissingParamError("ask_followup_question", "follow_up"))
+				return
+			}
+
+			cline.consecutiveMistakeCount = 0
+
 			type Suggest = { answer: string; mode?: string }
 
 			let follow_up_json = {
 				question,
 				suggest: [] as Suggest[],
 			}
 
-			if (follow_up) {
-				// Define the actual structure returned by the XML parser
-				type ParsedSuggestion = string | { "#text": string; "@_mode"?: string }
+			// Define the actual structure returned by the XML parser
+			type ParsedSuggestion = string | { "#text": string; "@_mode"?: string }
 
-				let parsedSuggest: {
+			let parsedSuggest: {
+				suggest: ParsedSuggestion[] | ParsedSuggestion
+			}
+
+			try {
+				parsedSuggest = parseXml(follow_up, ["suggest"]) as {
 					suggest: ParsedSuggestion[] | ParsedSuggestion
 				}
+			} catch (error) {
+				cline.consecutiveMistakeCount++
+				cline.recordToolError("ask_followup_question")
+				await cline.say("error", `Failed to parse follow_up suggestions: ${error.message}`)
+				pushToolResult(formatResponse.toolError(`Invalid follow_up XML format: ${error.message}`))
+				return
+			}
 
-				try {
-					parsedSuggest = parseXml(follow_up, ["suggest"]) as {
-						suggest: ParsedSuggestion[] | ParsedSuggestion
-					}
-				} catch (error) {
-					cline.consecutiveMistakeCount++
-					cline.recordToolError("ask_followup_question")
-					await cline.say("error", `Failed to parse operations: ${error.message}`)
-					pushToolResult(formatResponse.toolError("Invalid operations xml format"))
-					return
-				}
+			const rawSuggestions = Array.isArray(parsedSuggest?.suggest)
+				? parsedSuggest.suggest
+				: [parsedSuggest?.suggest].filter((sug): sug is ParsedSuggestion => sug !== undefined)
 
-				const rawSuggestions = Array.isArray(parsedSuggest?.suggest)
-					? parsedSuggest.suggest
-					: [parsedSuggest?.suggest].filter((sug): sug is ParsedSuggestion => sug !== undefined)
-
-				// Transform parsed XML to our Suggest format
-				const normalizedSuggest: Suggest[] = rawSuggestions.map((sug) => {
-					if (typeof sug === "string") {
-						// Simple string suggestion (no mode attribute)
-						return { answer: sug }
-					} else {
-						// XML object with text content and optional mode attribute
-						const result: Suggest = { answer: sug["#text"] }
-						if (sug["@_mode"]) {
-							result.mode = sug["@_mode"]
-						}
-						return result
+			// Validate that we have at least one suggestion
+			if (rawSuggestions.length === 0) {
+				cline.consecutiveMistakeCount++
+				cline.recordToolError("ask_followup_question")
+				await cline.say("error", "No suggestions found in follow_up parameter")
+				pushToolResult(
+					formatResponse.toolError("The follow_up parameter must contain at least one <suggest> tag"),
+				)
+				return
+			}
+
+			// Transform parsed XML to our Suggest format
+			const normalizedSuggest: Suggest[] = rawSuggestions.map((sug) => {
+				if (typeof sug === "string") {
+					// Simple string suggestion (no mode attribute)
+					return { answer: sug }
+				} else {
+					// XML object with text content and optional mode attribute
+					const result: Suggest = { answer: sug["#text"] }
+					if (sug["@_mode"]) {
+						result.mode = sug["@_mode"]
 					}
-				})
+					return result
+				}
+			})
 
-				follow_up_json.suggest = normalizedSuggest
-			}
+			follow_up_json.suggest = normalizedSuggest
 
-			cline.consecutiveMistakeCount = 0
 			const { text, images } = await cline.ask("followup", JSON.stringify(follow_up_json), false)
 			await cline.say("user_feedback", text ?? "", images)
 			pushToolResult(formatResponse.toolResult(`<answer>\n${text}\n</answer>`, images))
 
 			return
 		}
 	} catch (error) {
-		await handleError("asking question", error)
+		await handleError("asking followup question", error)
 		return
 	}
 }