hyperforge-smart 1.0.0.post129__tar.gz → 1.0.0.post136__tar.gz

{hyperforge_smart-1.0.0.post129 → hyperforge_smart-1.0.0.post136}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hyperforge_smart
-Version: 1.0.0.post129
+Version: 1.0.0.post136
 Summary: Conditional Hyperforge agent
 Author-email: Nuclia <nucliadb@nuclia.com>
 License-Expression: Apache-2.0

{hyperforge_smart-1.0.0.post129 → hyperforge_smart-1.0.0.post136}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "hyperforge_smart"
-version = "1.0.0.post129"
+version = "1.0.0.post136"
 license = "Apache-2.0"
 description = "Conditional Hyperforge agent"
 authors = [{ name = "Nuclia", email = "nucliadb@nuclia.com" }]

{hyperforge_smart-1.0.0.post129 → hyperforge_smart-1.0.0.post136}/src/hyperforge_smart/agent.py

@@ -95,12 +95,16 @@ USER_FEEDBACK_TOOL = Tool(
     parameters={
         "type": "object",
         "properties": {
+            "decision_id": {
+                "type": "string",
+                "description": "Stable identifier for the underlying decision. Reuse it if the question is rephrased.",
+            },
             "question": {
                 "type": "string",
                 "description": "The question to ask the user",
             },
         },
-        "required": ["question"],
+        "required": ["decision_id", "question"],
     },
 )
 
@@ -706,28 +710,45 @@ class SmartAgent(Agent[SmartAgentConfig], ContextAgent):
         messages: List[Message],
         tool_calls: List[Tuple[str, Any]],
         turn_label: str,
+        resolved_feedback: Optional[Dict[str, str]] = None,
         collected_contexts: Optional[List[Context]] = None,
         attempted_tool_calls: Optional[Dict[str, ToolAttempt]] = None,
     ) -> List[Tuple[str, Any]]:
         """Handle one turn of tool calls.
 
-        If the LLM requested user feedback, sends the feedback request, records it as a
-        step, stores it via _process_results and returns (results, True) so the caller
-        can ``continue`` to the next iteration without executing other tools.
-
-        Otherwise executes all tool calls in parallel, records an execution step and
-        returns (results, False).
+        New feedback pauses other tool execution for the turn. Already-resolved
+        feedback becomes a synthetic result, and any other requested tools continue.
         """
         agent_path = f"/context/{self.config.id or 'default'}"
+        synthetic_results: List[Tuple[str, Any]] = []
 
         # --- user_feedback path ---
         if any(name == "user_feedback" for name, _ in tool_calls):
             for name, args in tool_calls:
                 if name == "user_feedback":
+                    decision_id: Optional[str] = (
+                        args.get("decision_id") if args else None
+                    )
                     feedback_question: Optional[str] = (
                         args.get("question") if args else None
                     )
                     if feedback_question:
+                        decision_id = decision_id or (
+                            f"legacy:{feedback_question.strip().lower()}"
+                        )
+                        if (
+                            resolved_feedback is not None
+                            and decision_id in resolved_feedback
+                        ):
+                            cached_feedback_result = (
+                                "user_feedback",
+                                "Feedback resolved. Do not request this feedback again. "
+                                f"Decision ID: {decision_id}\n"
+                                f"Question: {feedback_question}\n"
+                                f"Response: {resolved_feedback[decision_id]}",
+                            )
+                            synthetic_results.append(cached_feedback_result)
+                            continue
                         feedback = Feedback(
                             request_id=memory.get_session_id(),
                             question=feedback_question,
@@ -744,10 +765,7 @@ class SmartAgent(Agent[SmartAgentConfig], ContextAgent):
                         answer = await memory.send_feedback(feedback)
                         feedback_text = (
                             answer.response
-                            if (
-                                answer is not None
-                                and answer.request_id == memory.get_session_id()
-                            )
+                            if answer is not None
                             else "(No response received)"
                         )
                         messages.append(Message(author=Author.USER, text=feedback_text))
@@ -762,10 +780,16 @@ class SmartAgent(Agent[SmartAgentConfig], ContextAgent):
                         )
                         feedback_result: Tuple[str, Any] = (
                             "user_feedback",
-                            feedback_text,
+                            "Feedback resolved. Do not request this feedback again. "
+                            f"Decision ID: {decision_id}\n"
+                            f"Question: {feedback_question}\n"
+                            f"Response: {feedback_text}",
                         )
+                        if resolved_feedback is not None:
+                            resolved_feedback[decision_id] = feedback_text
+                        feedback_results = [*synthetic_results, feedback_result]
                         result_texts = self._process_results(
-                            [feedback_result], collected_contexts=collected_contexts
+                            feedback_results, collected_contexts=collected_contexts
                         )
                         if result_texts:
                             messages.append(
@@ -774,8 +798,20 @@ class SmartAgent(Agent[SmartAgentConfig], ContextAgent):
                                     text="\n\n".join(result_texts),
                                 )
                             )
-                        return [feedback_result]
-            return []
+                        return feedback_results
+
+            tool_calls = [
+                (name, args) for name, args in tool_calls if name != "user_feedback"
+            ]
+            if not tool_calls:
+                result_texts = self._process_results(
+                    synthetic_results, collected_contexts=collected_contexts
+                )
+                if result_texts:
+                    messages.append(
+                        Message(author=Author.NUCLIA, text="\n\n".join(result_texts))
+                    )
+                return synthetic_results
 
         # --- normal tool execution path ---
         attempted_tool_calls = (
@@ -818,16 +854,34 @@ class SmartAgent(Agent[SmartAgentConfig], ContextAgent):
             )
             calls_to_execute.append((name, tool_arguments))
 
+        async def execute_with_delegation(
+            tool_name: str, tool_arguments: Dict[str, Any]
+        ) -> Tuple[str, Any]:
+            await memory.add_step(
+                step_module=self.config.module,
+                step_title=self.step_title(f"Delegating to {tool_name}"),
+                step_reason="Starting selected tool",
+                step_agent_path=agent_path,
+                step_value=tool_name,
+                timeit=0,
+            )
+            return await self.execute_tool_call(
+                memory, manager, tool_name, tool_arguments
+            )
+
         executed_results = []
-        if calls_to_execute:
+        if calls_to_execute and self.config.parallel_tool_calls:
             executed_results = await asyncio.gather(
                 *[
-                    self.execute_tool_call(memory, manager, name, args)
+                    execute_with_delegation(name, args)
                     for name, args in calls_to_execute
                 ]
             )
+        elif calls_to_execute:
+            for name, args in calls_to_execute:
+                executed_results.append(await execute_with_delegation(name, args))
 
-        results = [*executed_results, *skipped_results]
+        results = [*synthetic_results, *executed_results, *skipped_results]
         for (tool_name, tool_arguments), (_, result) in zip(
             calls_to_execute, executed_results
         ):
@@ -867,6 +921,20 @@ class SmartAgent(Agent[SmartAgentConfig], ContextAgent):
             )
         return list(results)
 
+    @staticmethod
+    def _has_unresolved_feedback(
+        tool_calls: List[Tuple[str, Any]], resolved_feedback: Dict[str, str]
+    ) -> bool:
+        for name, args in tool_calls:
+            if name != "user_feedback" or not args or not args.get("question"):
+                continue
+            decision_id = args.get("decision_id") or (
+                f"legacy:{args['question'].strip().lower()}"
+            )
+            if decision_id not in resolved_feedback:
+                return True
+        return False
+
     async def _reactive_loop(
         self,
         question: str,
@@ -899,6 +967,7 @@ class SmartAgent(Agent[SmartAgentConfig], ContextAgent):
         finished = False
         total_input_tokens = 0.0
         total_output_tokens = 0.0
+        resolved_feedback: Dict[str, str] = {}
         attempted_tool_calls: Dict[str, ToolAttempt] = {}
         while not finished and iteration < self.config.max_iterations:
             iteration += 1
@@ -937,20 +1006,28 @@ class SmartAgent(Agent[SmartAgentConfig], ContextAgent):
                 output_nuclia_tokens=output_tokens,
             )
 
-            if not tool_calls or any(name == "task_complete" for name, _ in tool_calls):
+            if not tool_calls:
                 finished = True
                 break
 
             # Execute tool calls (handles user_feedback and normal tool calls)
+            requested_new_feedback = SmartAgent._has_unresolved_feedback(
+                tool_calls, resolved_feedback
+            )
             _ = await self._execute_tool_calls_turn(
                 memory=memory,
                 manager=manager,
                 messages=messages,
                 tool_calls=tool_calls,
                 turn_label=f"iteration {iteration}/{self.config.max_iterations}",
+                resolved_feedback=resolved_feedback,
                 collected_contexts=contexts,
                 attempted_tool_calls=attempted_tool_calls,
             )
+            if not requested_new_feedback and any(
+                name == "task_complete" for name, _ in tool_calls
+            ):
+                finished = True
 
         reason = (
             "Task complete signal received"
@@ -1026,6 +1103,8 @@ class SmartAgent(Agent[SmartAgentConfig], ContextAgent):
         steps: List[Dict[str, Any]],
         summary: str,
         tools: List[Tool],
+        messages: List[Message],
+        resolved_feedback: Dict[str, str],
     ) -> Tuple[List[Tuple[str, Any]], float, float, List[ToolAttempt]]:
         """Run the executor LLM turn: call tools guided by the current plan steps."""
         system = PLAN_EXECUTE_EXECUTOR_SYSTEM_PROMPT_TEMPLATE.render(
@@ -1034,10 +1113,6 @@ class SmartAgent(Agent[SmartAgentConfig], ContextAgent):
             summary=summary,
             extra_instructions=self.config.extra_prompt or "",
         )
-        messages: List[Message] = [
-            Message(author=Author.USER, text=question),
-        ]
-
         all_results: List[Tuple[str, Any]] = []
         total_input_tokens = 0.0
         total_output_tokens = 0.0
@@ -1060,19 +1135,34 @@ class SmartAgent(Agent[SmartAgentConfig], ContextAgent):
 
             tool_calls = list(iterate_tools_resp(resp))
 
-            if not tool_calls or any(name == "task_complete" for name, _ in tool_calls):
+            if not tool_calls:
+                finished = True
+                break
+
+            executable_calls = [
+                (name, args) for name, args in tool_calls if name != "task_complete"
+            ]
+            if not executable_calls:
                 finished = True
                 break
 
+            requested_new_feedback = SmartAgent._has_unresolved_feedback(
+                executable_calls, resolved_feedback
+            )
             results = await self._execute_tool_calls_turn(
                 memory=memory,
                 manager=manager,
                 messages=messages,
-                tool_calls=tool_calls,
+                tool_calls=executable_calls,
                 turn_label=f"executor turn {executor_turn}/{max_executor_turns}",
+                resolved_feedback=resolved_feedback,
                 attempted_tool_calls=attempted_tool_calls,
             )
             all_results.extend(results)
+            if not requested_new_feedback and any(
+                name == "task_complete" for name, _ in tool_calls
+            ):
+                finished = True
 
         return (
             all_results,
@@ -1100,6 +1190,8 @@ class SmartAgent(Agent[SmartAgentConfig], ContextAgent):
         iteration = 0
         total_input_tokens = 0.0
         total_output_tokens = 0.0
+        executor_messages = [Message(author=Author.USER, text=question)]
+        resolved_feedback: Dict[str, str] = {}
         status = "done"
         steps: List[Dict[str, Any]] = []
 
@@ -1172,6 +1264,8 @@ class SmartAgent(Agent[SmartAgentConfig], ContextAgent):
                 steps=steps,
                 summary=summary,
                 tools=tools,
+                messages=executor_messages,
+                resolved_feedback=resolved_feedback,
             )
             total_input_tokens += exec_in_tokens
             total_output_tokens += exec_out_tokens

{hyperforge_smart-1.0.0.post129 → hyperforge_smart-1.0.0.post136}/src/hyperforge_smart/config.py

@@ -121,6 +121,14 @@ class SmartAgentConfig(ContextAgentConfig):
         title="Max iterations",
         description="Maximum number of planning and execution iterations before stopping",
     )
+    parallel_tool_calls: bool = Field(
+        default=True,
+        title="Parallel tool calls",
+        description=(
+            "Execute tool calls selected in the same turn concurrently. Disable for "
+            "interactive or stateful tools that must complete in order."
+        ),
+    )
     extra_prompt: Optional[str] = Field(
         None,
         title="Extra prompt",

{hyperforge_smart-1.0.0.post129 → hyperforge_smart-1.0.0.post136}/src/hyperforge_smart/prompts.py

@@ -11,6 +11,9 @@ REACTIVE_SYSTEM_PROMPT_TEMPLATE = PROMPT_ENVIRONMENT.from_string(
 You are a smart assistant that selects tools to gather information needed to answer a user's question.
 Choose the best tool or tools for the task. You may call multiple tools in one turn.
 Call task_complete when you have enough information to answer the question.
+When a "Feedback resolved" result exists for a decision ID, that decision is
+answered. Reuse the same decision ID if wording changes and continue with the
+recorded response.
 Guidelines:
 - Prefer finishing as soon as the gathered information is sufficient to answer the question.
 - Do not repeat the exact same tool call with the same arguments unless there is a clear reason that new information will be produced.
@@ -151,6 +154,8 @@ described in the retrieval plan below.
 
 Call the tools needed to fulfil this plan. You may call multiple tools.
 Call task_complete once you have executed all planned retrieval steps.
+When a tool result says "Feedback resolved", its decision ID is already answered.
+Reuse that ID if wording changes and continue using the recorded response.
 {% if extra_instructions %}
 Extra instructions: {{ extra_instructions }}
 {% endif %}"""

{hyperforge_smart-1.0.0.post129 → hyperforge_smart-1.0.0.post136}/src/hyperforge_smart.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hyperforge_smart
-Version: 1.0.0.post129
+Version: 1.0.0.post136
 Summary: Conditional Hyperforge agent
 Author-email: Nuclia <nucliadb@nuclia.com>
 License-Expression: Apache-2.0

{hyperforge_smart-1.0.0.post129 → hyperforge_smart-1.0.0.post136}/tests/test_smart.py

@@ -1,7 +1,7 @@
 import os
 from copy import deepcopy
 from dataclasses import dataclass
-from types import SimpleNamespace
+from types import MethodType, SimpleNamespace
 from typing import Any, ClassVar, cast
 from unittest.mock import patch
 
@@ -97,6 +97,319 @@ CONFIG = {
 }
 
 
+@pytest.mark.asyncio
+async def test_plan_executor_preserves_messages_between_iterations():
+    observed_messages = []
+
+    async def choose_tools(_self, *, messages, **_kwargs):
+        observed_messages.append(messages)
+        return SimpleNamespace(tools=None), 0, 0
+
+    smart: Any = SimpleNamespace(
+        config=SimpleNamespace(extra_prompt=None, max_iterations=1),
+        choose_tools=MethodType(choose_tools, object()),
+        _planner_attempts_from_registry=SmartAgent._planner_attempts_from_registry,
+    )
+    memory: Any = SimpleNamespace(get_tracking_info=lambda: None)
+    manager: Any = None
+    messages = [
+        Message(author=Author.USER, text="Coordinate the incident"),
+        Message(author=Author.NUCLIA, text="Tour Manager approved the change"),
+    ]
+
+    await SmartAgent._call_executor(
+        smart,
+        memory=memory,
+        manager=manager,
+        question="Coordinate the incident",
+        steps=[{"description": "Continue coordination", "reason": "Approval received"}],
+        summary="The Tour Manager approved the change",
+        tools=[],
+        messages=messages,
+        resolved_feedback={},
+    )
+
+    assert observed_messages == [messages]
+    assert observed_messages[0] is messages
+    assert observed_messages[0][-1].text == "Tour Manager approved the change"
+
+
+@pytest.mark.asyncio
+async def test_feedback_decision_id_survives_rephrasing():
+    class Memory:
+        calls = 0
+
+        def get_session_id(self):
+            return "session-1"
+
+        async def send_feedback(self, feedback):
+            self.calls += 1
+            return UserToAgentInteraction(
+                request_id=feedback.request_id,
+                response="Approved",
+            )
+
+        async def add_step(self, **_kwargs):
+            return None
+
+    memory: Any = Memory()
+    manager: Any = None
+    smart: Any = SimpleNamespace(
+        config=SimpleNamespace(
+            id="operations",
+            module="smart",
+            feedback_timeout=5_000,
+            max_tool_result_bytes=None,
+            max_tool_result_item_bytes=None,
+        ),
+        step_title=lambda title: title,
+    )
+    smart._process_results = MethodType(SmartAgent._process_results, smart)
+    smart._inspect_result = MethodType(SmartAgent._inspect_result, smart)
+    messages: list[Message] = []
+    resolved_feedback: dict[str, str] = {}
+
+    for question in (
+        "Approve the shorter set?",
+        "Can we reduce the set to 60 minutes?",
+    ):
+        await SmartAgent._execute_tool_calls_turn(
+            smart,
+            memory=memory,
+            manager=manager,
+            messages=messages,
+            tool_calls=[
+                (
+                    "user_feedback",
+                    {"decision_id": "set-duration", "question": question},
+                )
+            ],
+            turn_label="test",
+            resolved_feedback=resolved_feedback,
+        )
+
+    assert memory.calls == 1
+    assert resolved_feedback == {"set-duration": "Approved"}
+    assert "Decision ID: set-duration" in messages[-1].text
+
+
+@pytest.mark.asyncio
+async def test_different_feedback_decisions_are_both_requested():
+    class Memory:
+        calls = 0
+
+        def get_session_id(self):
+            return "session-1"
+
+        async def send_feedback(self, feedback):
+            self.calls += 1
+            return UserToAgentInteraction(
+                request_id=feedback.request_id,
+                response="Approved",
+            )
+
+        async def add_step(self, **_kwargs):
+            return None
+
+    memory: Any = Memory()
+    manager: Any = None
+    smart: Any = SimpleNamespace(
+        config=SimpleNamespace(
+            id="operations",
+            module="smart",
+            feedback_timeout=5_000,
+            max_tool_result_bytes=None,
+            max_tool_result_item_bytes=None,
+        ),
+        step_title=lambda title: title,
+    )
+    smart._process_results = MethodType(SmartAgent._process_results, smart)
+    smart._inspect_result = MethodType(SmartAgent._inspect_result, smart)
+    messages: list[Message] = []
+    resolved_feedback: dict[str, str] = {}
+
+    for decision_id in ("set-duration", "gate-activation"):
+        await SmartAgent._execute_tool_calls_turn(
+            smart,
+            memory=memory,
+            manager=manager,
+            messages=messages,
+            tool_calls=[
+                (
+                    "user_feedback",
+                    {"decision_id": decision_id, "question": f"Approve {decision_id}?"},
+                )
+            ],
+            turn_label="test",
+            resolved_feedback=resolved_feedback,
+        )
+
+    assert memory.calls == 2
+    assert resolved_feedback == {
+        "set-duration": "Approved",
+        "gate-activation": "Approved",
+    }
+
+
+@pytest.mark.asyncio
+async def test_feedback_response_with_upstream_request_id_is_cached():
+    class Memory:
+        def get_session_id(self):
+            return "session-1"
+
+        async def send_feedback(self, _feedback):
+            return UserToAgentInteraction(
+                request_id="upstream-a2a-request", response="Approved"
+            )
+
+        async def add_step(self, **_kwargs):
+            return None
+
+    smart: Any = SimpleNamespace(
+        config=SimpleNamespace(
+            id="operations",
+            module="smart",
+            feedback_timeout=5_000,
+            max_tool_result_bytes=None,
+            max_tool_result_item_bytes=None,
+        ),
+        step_title=lambda title: title,
+    )
+    smart._process_results = MethodType(SmartAgent._process_results, smart)
+    smart._inspect_result = MethodType(SmartAgent._inspect_result, smart)
+    resolved_feedback: dict[str, str] = {}
+    memory: Any = Memory()
+    manager: Any = None
+
+    await SmartAgent._execute_tool_calls_turn(
+        smart,
+        memory=memory,
+        manager=manager,
+        messages=[],
+        tool_calls=[
+            (
+                "user_feedback",
+                {"decision_id": "set-duration", "question": "Approve?"},
+            )
+        ],
+        turn_label="test",
+        resolved_feedback=resolved_feedback,
+    )
+
+    assert resolved_feedback == {"set-duration": "Approved"}
+
+
+@pytest.mark.asyncio
+async def test_cached_feedback_does_not_skip_other_tools_in_same_turn():
+    class Memory:
+        async def add_step(self, **_kwargs):
+            return None
+
+    async def execute_tool_call(_memory, _manager, name, _args):
+        return name, "tool result"
+
+    smart: Any = SimpleNamespace(
+        config=SimpleNamespace(
+            id="operations",
+            module="smart",
+            parallel_tool_calls=False,
+            max_tool_result_bytes=None,
+            max_tool_result_item_bytes=None,
+        ),
+        step_title=lambda title: title,
+        execute_tool_call=execute_tool_call,
+    )
+    smart._process_results = MethodType(SmartAgent._process_results, smart)
+    smart._inspect_result = MethodType(SmartAgent._inspect_result, smart)
+    smart._tool_call_key = SmartAgent._tool_call_key
+    smart._classify_tool_result = SmartAgent._classify_tool_result
+    memory: Any = Memory()
+    manager: Any = None
+
+    results = await SmartAgent._execute_tool_calls_turn(
+        smart,
+        memory=memory,
+        manager=manager,
+        messages=[],
+        tool_calls=[
+            (
+                "user_feedback",
+                {"decision_id": "set-duration", "question": "Reduce the set?"},
+            ),
+            ("venue_lookup", {"gate": "C"}),
+        ],
+        turn_label="test",
+        resolved_feedback={"set-duration": "Approved"},
+    )
+
+    assert [name for name, _ in results] == ["user_feedback", "venue_lookup"]
+    assert results[1] == ("venue_lookup", "tool result")
+
+
+@pytest.mark.asyncio
+async def test_executor_runs_tools_returned_with_task_complete():
+    smart: Any = SimpleNamespace(
+        config=SimpleNamespace(max_iterations=1, extra_prompt=None),
+    )
+
+    async def choose_tools(**_kwargs):
+        return (
+            SimpleNamespace(
+                tools={
+                    "calls": [
+                        SimpleNamespace(
+                            function=SimpleNamespace(
+                                name="a2a_query_of_logistics", arguments={}
+                            )
+                        ),
+                        SimpleNamespace(
+                            function=SimpleNamespace(name="task_complete", arguments={})
+                        ),
+                    ]
+                }
+            ),
+            0,
+            0,
+        )
+
+    executed_calls = []
+
+    async def execute_turn(**kwargs):
+        executed_calls.extend(kwargs["tool_calls"])
+        return [("a2a_query of logistics", "result")]
+
+    smart.choose_tools = choose_tools
+    smart._execute_tool_calls_turn = execute_turn
+    smart._planner_attempts_from_registry = SmartAgent._planner_attempts_from_registry
+    memory: Any = SimpleNamespace(get_tracking_info=lambda: None)
+    manager: Any = None
+
+    results, _, _, _ = await SmartAgent._call_executor(
+        smart,
+        memory=memory,
+        manager=manager,
+        question="question",
+        steps=[],
+        summary="",
+        tools=[],
+        messages=[],
+        resolved_feedback={},
+    )
+
+    assert executed_calls == [("a2a_query_of_logistics", {})]
+    assert results == [("a2a_query of logistics", "result")]
+
+
+def test_new_feedback_prevents_same_turn_completion():
+    calls = [
+        ("user_feedback", {"decision_id": "approval", "question": "Approve?"}),
+        ("task_complete", {}),
+    ]
+
+    assert SmartAgent._has_unresolved_feedback(calls, {})
+    assert not SmartAgent._has_unresolved_feedback(calls, {"approval": "yes"})
+
+
 @pytest.mark.asyncio
 async def test_choose_tools_uses_auto_tool_choice():
     smart_agent = SmartAgent(
@@ -367,7 +680,7 @@ async def test_smart_with_user_feedback():
 
     async def mock_send_feedback(feedback):
         return UserToAgentInteraction(
-            request_id=feedback.request_id,
+            request_id="upstream-a2a-request",
             response="Snoopy the pet",
         )
 
@@ -391,7 +704,16 @@ async def test_smart_with_user_feedback():
         )
 
     assert question_memory.final_answer
-    assert "Feedback response: Snoopy the pet" in question_memory.steps[1].value
+    feedback_steps = [
+        step
+        for step in question_memory.steps
+        if step.module == "smart" and "user feedback" in step.title.lower()
+    ]
+    assert feedback_steps, "Expected a user feedback step"
+    assert any(
+        "Feedback response: Snoopy the pet" in (step.value or "")
+        for step in feedback_steps
+    )
     assert any(
         keyword.lower() in question_memory.final_answer.lower()
         for keyword in ["Snoopy", "dog", "Carmen"]