Skip to content

AutoGPT is the vision of accessible AI for everyone, to use and to build on. Our mission is to provide the tools, so that you can focus on what matters.

refactor(backend/copilot): simplify ask_question to questions-only API

Zamil Majdy505af7e67395
diff --git a/autogpt_platform/backend/backend/copilot/tools/ask_question.py b/autogpt_platform/backend/backend/copilot/tools/ask_question.py
index 25aa164896..d64df08e76 100644
--- a/autogpt_platform/backend/backend/copilot/tools/ask_question.py
+++ b/autogpt_platform/backend/backend/copilot/tools/ask_question.py
@@ -15,16 +15,9 @@ class AskQuestionTool(BaseTool):
"""Ask the user one or more clarifying questions and wait for answers.
Use this tool when the user's request is ambiguous and you need more
- information before proceeding. Call find_block or other discovery tools
+ information before proceeding. Call find_block or other discovery tools
first to ground your questions in real platform options, then call this
tool with concrete questions listing those options.
-
- Supports two calling conventions (backward-compatible):
- 1. Single question: ``question="Which channel?"``
- 2. Multiple questions: ``questions=[{...}, {...}]``
-
- When *questions* (plural) is provided, the *question*, *options*, and
- *keyword* top-level parameters are ignored.
"""
@property
@@ -36,8 +29,7 @@ class AskQuestionTool(BaseTool):
return (
"Ask the user one or more clarifying questions. Use when the "
"request is ambiguous and you need to confirm intent, choose "
- "between options, or gather missing details before proceeding. "
- "Pass a single question via 'question' or multiple via 'questions'."
+ "between options, or gather missing details before proceeding."
)
@property
@@ -45,29 +37,6 @@ class AskQuestionTool(BaseTool):
return {
"type": "object",
"properties": {
- "question": {
- "type": "string",
- "description": (
- "A single concrete question to ask the user. "
- "Ignored when 'questions' is provided."
- ),
- },
- "options": {
- "type": "array",
- "items": {"type": "string"},
- "description": (
- "Options for the single question "
- "(e.g. ['Email', 'Slack', 'Google Docs']). "
- "Ignored when 'questions' is provided."
- ),
- },
- "keyword": {
- "type": "string",
- "description": (
- "Short label for the single question. "
- "Ignored when 'questions' is provided."
- ),
- },
"questions": {
"type": "array",
"items": {
@@ -90,125 +59,81 @@ class AskQuestionTool(BaseTool):
"required": ["question"],
},
"description": (
- "Ask multiple questions at once. Each item has "
- "'question' (required), 'options', and 'keyword'. "
- "Takes precedence over the single 'question' param."
+ "One or more clarifying questions. Each item has "
+ "'question' (required), 'options', and 'keyword'."
),
},
},
- "required": ["question"],
+ "required": ["questions"],
}
@property
def requires_auth(self) -> bool:
return False
- # ------------------------------------------------------------------
- # Helpers
- # ------------------------------------------------------------------
-
- @staticmethod
- def _build_question(
- question: str,
- options: list[str] | None = None,
- keyword: str = "",
- ) -> ClarifyingQuestion:
- """Build a single ``ClarifyingQuestion`` from raw inputs."""
- safe_options = (
- [str(o) for o in options if o is not None and str(o).strip()]
- if isinstance(options, list)
- else []
- )
- return ClarifyingQuestion(
- question=question,
- keyword=keyword,
- example=", ".join(safe_options) if safe_options else None,
- )
-
- # ------------------------------------------------------------------
- # Execute
- # ------------------------------------------------------------------
-
async def _execute(
self,
user_id: str | None,
session: ChatSession,
**kwargs: Any,
) -> ToolResponseBase:
- del user_id # unused; required by BaseTool contract
- session_id = session.session_id if session else None
-
- raw_questions = kwargs.get("questions")
- if isinstance(raw_questions, list) and raw_questions:
- return self._execute_multi(raw_questions, session_id)
+ del user_id
+ raw_questions = kwargs.get("questions", [])
+ if not isinstance(raw_questions, list) or not raw_questions:
+ raise ValueError("ask_question requires a non-empty 'questions' array")
- return self._execute_single(kwargs, session_id)
+ questions = _parse_questions(raw_questions)
+ if not questions:
+ raise ValueError(
+ "ask_question requires at least one valid question in 'questions'"
+ )
- def _execute_single(
- self,
- kwargs: dict[str, Any],
- session_id: str | None,
- ) -> ClarificationNeededResponse:
- """Original single-question path (backward-compatible)."""
- question_raw = kwargs.get("question")
- if not isinstance(question_raw, str) or not question_raw.strip():
- raise ValueError("ask_question requires a non-empty 'question' string")
- question = question_raw.strip()
-
- raw_options = kwargs.get("options", [])
- if not isinstance(raw_options, list):
- raw_options = []
-
- raw_keyword = kwargs.get("keyword") or ""
- keyword: str = str(raw_keyword).strip()
-
- clarifying_question = self._build_question(question, raw_options, keyword)
return ClarificationNeededResponse(
- message=question,
- session_id=session_id,
- questions=[clarifying_question],
+ message="; ".join(q.question for q in questions),
+ session_id=session.session_id if session else None,
+ questions=questions,
)
- def _execute_multi(
- self,
- raw_questions: list[Any],
- session_id: str | None,
- ) -> ClarificationNeededResponse:
- """New multi-question path."""
- clarifying_questions: list[ClarifyingQuestion] = []
- for idx, item in enumerate(raw_questions):
- if not isinstance(item, dict):
- logger.warning("ask_question: skipping non-dict item at index %d", idx)
- continue
- q_text = item.get("question")
- if not isinstance(q_text, str) or not q_text.strip():
- logger.warning(
- "ask_question: skipping item at index %d with missing/empty question",
- idx,
- )
- continue
- raw_keyword = item.get("keyword")
- keyword = (
- str(raw_keyword).strip()
- if raw_keyword is not None and str(raw_keyword).strip()
- else f"question-{idx}"
- )
- clarifying_questions.append(
- self._build_question(
- question=q_text.strip(),
- options=item.get("options"),
- keyword=keyword,
- )
- )
- if not clarifying_questions:
- raise ValueError(
- "ask_question requires at least one valid question in 'questions'"
- )
+def _parse_questions(raw: list[Any]) -> list[ClarifyingQuestion]:
+ """Parse and validate raw question dicts into ClarifyingQuestion objects."""
+ return [
+ q
+ for idx, item in enumerate(raw)
+ if (q := _parse_one(item, idx)) is not None
+ ]
- message = "; ".join(q.question for q in clarifying_questions)
- return ClarificationNeededResponse(
- message=message,
- session_id=session_id,
- questions=clarifying_questions,
+
+def _parse_one(item: Any, idx: int) -> ClarifyingQuestion | None:
+ """Parse a single question item, returning None for invalid entries."""
+ if not isinstance(item, dict):
+ logger.warning("ask_question: skipping non-dict item at index %d", idx)
+ return None
+
+ text = item.get("question")
+ if not isinstance(text, str) or not text.strip():
+ logger.warning(
+ "ask_question: skipping item at index %d with missing/empty question",
+ idx,
)
+ return None
+
+ raw_keyword = item.get("keyword")
+ keyword = (
+ str(raw_keyword).strip()
+ if raw_keyword is not None and str(raw_keyword).strip()
+ else f"question-{idx}"
+ )
+
+ raw_options = item.get("options")
+ options = (
+ [str(o) for o in raw_options if o is not None and str(o).strip()]
+ if isinstance(raw_options, list)
+ else []
+ )
+
+ return ClarifyingQuestion(
+ question=text.strip(),
+ keyword=keyword,
+ example=", ".join(options) if options else None,
+ )
diff --git a/autogpt_platform/backend/backend/copilot/tools/ask_question_test.py b/autogpt_platform/backend/backend/copilot/tools/ask_question_test.py
index 0470540e28..3e70abf990 100644
--- a/autogpt_platform/backend/backend/copilot/tools/ask_question_test.py
+++ b/autogpt_platform/backend/backend/copilot/tools/ask_question_test.py
@@ -17,335 +17,235 @@ def session() -> ChatSession:
return ChatSession.new(user_id="test-user", dry_run=False)
-# ── Single-question (backward-compatible) ────────────────────────────
+# ── Happy paths ──────────────────────────────────────────────────────
@pytest.mark.asyncio
-async def test_execute_with_options(tool: AskQuestionTool, session: ChatSession):
+async def test_single_question(tool: AskQuestionTool, session: ChatSession):
result = await tool._execute(
user_id=None,
session=session,
- question="Which channel?",
- options=["Email", "Slack", "Google Docs"],
- keyword="channel",
+ questions=[{"question": "Which channel?", "keyword": "channel"}],
)
assert isinstance(result, ClarificationNeededResponse)
assert result.message == "Which channel?"
assert result.session_id == session.session_id
assert len(result.questions) == 1
-
- q = result.questions[0]
- assert q.question == "Which channel?"
- assert q.keyword == "channel"
- assert q.example == "Email, Slack, Google Docs"
+ assert result.questions[0].question == "Which channel?"
+ assert result.questions[0].keyword == "channel"
@pytest.mark.asyncio
-async def test_execute_without_options(tool: AskQuestionTool, session: ChatSession):
+async def test_single_question_with_options(
+ tool: AskQuestionTool, session: ChatSession
+):
result = await tool._execute(
user_id=None,
session=session,
- question="What format do you want?",
+ questions=[
+ {
+ "question": "Which channel?",
+ "options": ["Email", "Slack", "Google Docs"],
+ "keyword": "channel",
+ }
+ ],
)
assert isinstance(result, ClarificationNeededResponse)
- assert result.message == "What format do you want?"
- assert len(result.questions) == 1
-
q = result.questions[0]
- assert q.question == "What format do you want?"
- assert q.keyword == ""
- assert q.example is None
+ assert q.example == "Email, Slack, Google Docs"
@pytest.mark.asyncio
-async def test_execute_with_keyword_only(tool: AskQuestionTool, session: ChatSession):
+async def test_multiple_questions(tool: AskQuestionTool, session: ChatSession):
result = await tool._execute(
user_id=None,
session=session,
- question="How often should it run?",
- keyword="trigger",
+ questions=[
+ {"question": "Which channel?", "options": ["Email", "Slack"], "keyword": "channel"},
+ {"question": "How often?", "options": ["Daily", "Weekly"], "keyword": "frequency"},
+ {"question": "Any extra notes?"},
+ ],
)
assert isinstance(result, ClarificationNeededResponse)
- q = result.questions[0]
- assert q.keyword == "trigger"
- assert q.example is None
+ assert len(result.questions) == 3
+ assert result.message == "Which channel?; How often?; Any extra notes?"
+ assert result.questions[0].keyword == "channel"
+ assert result.questions[0].example == "Email, Slack"
+ assert result.questions[1].keyword == "frequency"
+ assert result.questions[2].keyword == "question-2"
+ assert result.questions[2].example is None
-async def test_execute_rejects_empty_question(
- tool: AskQuestionTool, session: ChatSession
-):
- with pytest.raises(ValueError, match="non-empty"):
- await tool._execute(user_id=None, session=session, question="")
- with pytest.raises(ValueError, match="non-empty"):
- await tool._execute(user_id=None, session=session, question=" ")
+# ── Keyword handling ─────────────────────────────────────────────────
@pytest.mark.asyncio
-async def test_execute_coerces_invalid_options(
+async def test_missing_keyword_gets_index_fallback(
tool: AskQuestionTool, session: ChatSession
):
- """LLM may send options as a string instead of a list; should not crash."""
result = await tool._execute(
user_id=None,
session=session,
- question="Pick one",
- options="not-a-list", # type: ignore[arg-type]
+ questions=[{"question": "First?"}, {"question": "Second?"}],
)
assert isinstance(result, ClarificationNeededResponse)
- q = result.questions[0]
- assert q.example is None
-
-
-# ── Multi-question ───────────────────────────────────────────────────
+ assert result.questions[0].keyword == "question-0"
+ assert result.questions[1].keyword == "question-1"
@pytest.mark.asyncio
-async def test_execute_multiple_questions(tool: AskQuestionTool, session: ChatSession):
+async def test_null_keyword_gets_index_fallback(
+ tool: AskQuestionTool, session: ChatSession
+):
result = await tool._execute(
user_id=None,
session=session,
- questions=[
- {
- "question": "Which channel?",
- "options": ["Email", "Slack"],
- "keyword": "channel",
- },
- {
- "question": "How often?",
- "options": ["Daily", "Weekly"],
- "keyword": "frequency",
- },
- {
- "question": "Any extra notes?",
- },
- ],
+ questions=[{"question": "First?", "keyword": None}],
)
assert isinstance(result, ClarificationNeededResponse)
- assert len(result.questions) == 3
- assert result.message == "Which channel?; How often?; Any extra notes?"
-
- q0 = result.questions[0]
- assert q0.question == "Which channel?"
- assert q0.keyword == "channel"
- assert q0.example == "Email, Slack"
-
- q1 = result.questions[1]
- assert q1.question == "How often?"
- assert q1.keyword == "frequency"
- assert q1.example == "Daily, Weekly"
-
- q2 = result.questions[2]
- assert q2.question == "Any extra notes?"
- assert q2.keyword == "question-2"
- assert q2.example is None
+ assert result.questions[0].keyword == "question-0"
@pytest.mark.asyncio
-async def test_execute_multiple_questions_skips_invalid_items(
+async def test_duplicate_keywords_preserved(
tool: AskQuestionTool, session: ChatSession
):
- """Non-dict items and items without a question are skipped with a warning."""
+ """Frontend normalizeClarifyingQuestions() handles dedup."""
result = await tool._execute(
user_id=None,
session=session,
questions=[
- "not-a-dict",
- {"keyword": "missing-question"},
- {"question": ""},
- {"question": " Valid question ", "keyword": "valid"},
+ {"question": "First?", "keyword": "same"},
+ {"question": "Second?", "keyword": "same"},
],
)
assert isinstance(result, ClarificationNeededResponse)
- assert len(result.questions) == 1
- assert result.questions[0].question == "Valid question"
- assert result.questions[0].keyword == "valid"
+ assert result.questions[0].keyword == "same"
+ assert result.questions[1].keyword == "same"
-async def test_execute_multiple_questions_rejects_all_invalid(
- tool: AskQuestionTool, session: ChatSession
-):
- """If every item in questions is invalid, raise ValueError."""
- with pytest.raises(ValueError, match="at least one valid question"):
- await tool._execute(
- user_id=None,
- session=session,
- questions=[{"keyword": "no-question"}, "bad"],
- )
+# ── Options filtering ────────────────────────────────────────────────
@pytest.mark.asyncio
-async def test_execute_multiple_questions_ignores_single_params(
+async def test_options_preserves_falsy_strings(
tool: AskQuestionTool, session: ChatSession
):
- """When 'questions' is provided, 'question'/'options'/'keyword' are ignored."""
result = await tool._execute(
user_id=None,
session=session,
- question="Should be ignored",
- options=["A", "B"],
- keyword="ignored",
- questions=[
- {"question": "Real question?", "keyword": "real"},
- ],
+ questions=[{"question": "Pick", "options": ["0", "1", "2"]}],
)
assert isinstance(result, ClarificationNeededResponse)
- assert len(result.questions) == 1
- assert result.questions[0].question == "Real question?"
- assert result.questions[0].keyword == "real"
+ assert result.questions[0].example == "0, 1, 2"
@pytest.mark.asyncio
-async def test_execute_empty_questions_falls_back_to_single(
+async def test_options_filters_none_and_empty(
tool: AskQuestionTool, session: ChatSession
):
- """An empty 'questions' list falls back to the single-question path."""
result = await tool._execute(
user_id=None,
session=session,
- question="Fallback question?",
- questions=[],
+ questions=[{"question": "Pick", "options": ["Email", "", "Slack", None]}],
)
assert isinstance(result, ClarificationNeededResponse)
- assert len(result.questions) == 1
- assert result.questions[0].question == "Fallback question?"
-
-
-# ── Edge cases (from review) ────────────────────────────────────────
+ assert result.questions[0].example == "Email, Slack"
@pytest.mark.asyncio
-async def test_execute_with_none_session(tool: AskQuestionTool):
- """session_id should be None when session has no session_id."""
-
- class FakeSession:
- session_id = None
-
+async def test_no_options_gives_none_example(
+ tool: AskQuestionTool, session: ChatSession
+):
result = await tool._execute(
user_id=None,
- session=FakeSession(), # type: ignore[arg-type]
- question="Does this work?",
+ session=session,
+ questions=[{"question": "Thoughts?"}],
)
+
assert isinstance(result, ClarificationNeededResponse)
- assert result.session_id is None
- assert result.questions[0].question == "Does this work?"
+ assert result.questions[0].example is None
+
+
+# ── Invalid input handling ───────────────────────────────────────────
@pytest.mark.asyncio
-async def test_execute_single_item_questions_array(
- tool: AskQuestionTool, session: ChatSession
-):
- """A questions array with a single item should work like the single path."""
+async def test_skips_non_dict_items(tool: AskQuestionTool, session: ChatSession):
result = await tool._execute(
user_id=None,
session=session,
- questions=[{"question": "Only one?", "keyword": "solo"}],
+ questions=["not-a-dict", {"question": "Valid?", "keyword": "v"}],
)
assert isinstance(result, ClarificationNeededResponse)
assert len(result.questions) == 1
- assert result.questions[0].question == "Only one?"
- assert result.questions[0].keyword == "solo"
- assert result.message == "Only one?"
+ assert result.questions[0].question == "Valid?"
@pytest.mark.asyncio
-async def test_execute_duplicate_keywords_preserved(
+async def test_skips_empty_question_items(
tool: AskQuestionTool, session: ChatSession
):
- """Duplicate keywords from the LLM are passed through; the frontend
- normalizes them via normalizeClarifyingQuestions()."""
result = await tool._execute(
user_id=None,
session=session,
questions=[
- {"question": "First?", "keyword": "same"},
- {"question": "Second?", "keyword": "same"},
+ {"keyword": "missing-question"},
+ {"question": ""},
+ {"question": " Valid ", "keyword": "v"},
],
)
assert isinstance(result, ClarificationNeededResponse)
- assert len(result.questions) == 2
- assert result.questions[0].keyword == "same"
- assert result.questions[1].keyword == "same"
+ assert len(result.questions) == 1
+ assert result.questions[0].question == "Valid"
@pytest.mark.asyncio
-async def test_execute_options_with_falsy_values(
+async def test_rejects_all_invalid_items(
tool: AskQuestionTool, session: ChatSession
):
- """Falsy but valid option values like '0' should be preserved."""
- result = await tool._execute(
- user_id=None,
- session=session,
- question="Pick a number",
- options=["0", "1", "2"],
- keyword="number",
- )
-
- assert isinstance(result, ClarificationNeededResponse)
- assert result.questions[0].example == "0, 1, 2"
+ with pytest.raises(ValueError, match="at least one valid question"):
+ await tool._execute(
+ user_id=None,
+ session=session,
+ questions=[{"keyword": "no-q"}, "bad"],
+ )
@pytest.mark.asyncio
-async def test_execute_questions_as_non_list_falls_back(
+async def test_rejects_empty_questions_array(
tool: AskQuestionTool, session: ChatSession
):
- """If 'questions' is a truthy non-list (e.g. a dict), fall back to single path."""
- result = await tool._execute(
- user_id=None,
- session=session,
- question="Fallback?",
- questions={"question": "Not a list"}, # type: ignore[arg-type]
- )
-
- assert isinstance(result, ClarificationNeededResponse)
- assert len(result.questions) == 1
- assert result.questions[0].question == "Fallback?"
+ with pytest.raises(ValueError, match="non-empty"):
+ await tool._execute(user_id=None, session=session, questions=[])
@pytest.mark.asyncio
-async def test_execute_multi_keyword_null_gets_fallback(
+async def test_rejects_missing_questions(
tool: AskQuestionTool, session: ChatSession
):
- """If keyword is None (JSON null), use the question-{idx} fallback."""
- result = await tool._execute(
- user_id=None,
- session=session,
- questions=[
- {"question": "First?", "keyword": None},
- {"question": "Second?"},
- ],
- )
-
- assert isinstance(result, ClarificationNeededResponse)
- assert len(result.questions) == 2
- assert result.questions[0].keyword == "question-0"
- assert result.questions[1].keyword == "question-1"
+ with pytest.raises(ValueError, match="non-empty"):
+ await tool._execute(user_id=None, session=session)
@pytest.mark.asyncio
-async def test_execute_options_filters_empty_strings(
+async def test_rejects_non_list_questions(
tool: AskQuestionTool, session: ChatSession
):
- """Empty-string options should be filtered out to avoid artifacts."""
- result = await tool._execute(
- user_id=None,
- session=session,
- question="Pick one",
- options=["Email", "", "Slack", None], # type: ignore[list-item]
- keyword="channel",
- )
-
- assert isinstance(result, ClarificationNeededResponse)
- assert result.questions[0].example == "Email, Slack"
+ with pytest.raises(ValueError, match="non-empty"):
+ await tool._execute(
+ user_id=None,
+ session=session,
+ questions="not-a-list",
+ )