Merge branch 'fix-agent-no-user-infinite-loop' into 'main'

Fix Infinite Loop in CallerInputMode.NEVER

See merge request wayflow-dev/wayflow-public!202

Author: wayflow-bot

wayflowcore/src/wayflowcore/agent.py

@@ -38,12 +38,16 @@ class CallerInputMode(Enum):
     ALWAYS = "always"  # doc: The agent is allowed to ask the user for more information if needed
 
 
+NOT_SET_INITIAL_MESSAGE = "N/A"
 DEFAULT_INITIAL_MESSAGE = "Hi! How can I help you?"
 
 
 @dataclass
 class Agent(ConversationalComponent, SerializableDataclassMixin, SerializableObject):
 
+    NOT_SET_INITIAL_MESSAGE: ClassVar[str] = NOT_SET_INITIAL_MESSAGE
+    """str: Placeholder for non-explicitly set initial message."""
+
     DEFAULT_INITIAL_MESSAGE: ClassVar[str] = DEFAULT_INITIAL_MESSAGE
     """str: Message the agent will post if no previous user message to welcome them."""
 
@@ -111,7 +115,7 @@ def __init__(
         max_iterations: int = 10,
         context_providers: Optional[List["ContextProvider"]] = None,
         can_finish_conversation: bool = False,
-        initial_message: Optional[str] = DEFAULT_INITIAL_MESSAGE,
+        initial_message: Optional[str] = NOT_SET_INITIAL_MESSAGE,
         caller_input_mode: CallerInputMode = CallerInputMode.ALWAYS,
         input_descriptors: Optional[List["Property"]] = None,
         output_descriptors: Optional[List["Property"]] = None,
@@ -185,9 +189,9 @@ def __init__(
         can_finish_conversation
             Whether the agent can decide to end the conversation or not.
         initial_message:
-            Initial message the agent will post if no previous user message.
-            Default to ``Agent.DEFAULT_INITIAL_MESSAGE``. If None, the LLM will generate it but the agent requires
-            a custom_instruction.
+            Initial message the agent will post if no previous user message. It must be None for `CallerInputMode.NEVER`
+            If None for `CallerInputMode.ALWAYS`, the LLM will generate it given the `custom_instruction`. Default to
+            `Agent.DEFAULT_INITIAL_MESSAGE` for `CallerInputMode.ALWAYS` and None for `CallerInputMode.NEVER`.
         caller_input_mode:
             whether the agent is allowed to ask the user questions (CallerInputMode.ALWAYS) or not (CallerInputMode.NEVER).
             If set to NEVER, the agent won't be able to yield.
@@ -253,13 +257,44 @@ def __init__(
             flows = [_convert_described_flow_into_named_flow(flow) for flow in flows]
             self._validate_flow_can_be_used_in_composition(flows)
 
+        if caller_input_mode not in [CallerInputMode.ALWAYS, CallerInputMode.NEVER]:
+            raise ValueError(
+                f"`caller_input_mode` value {caller_input_mode} is not within the domain of `CallerInputMode`."
+            )
+
+        if initial_message == NOT_SET_INITIAL_MESSAGE:
+            if caller_input_mode == CallerInputMode.ALWAYS:
+                initial_message = DEFAULT_INITIAL_MESSAGE
+            elif caller_input_mode == CallerInputMode.NEVER:
+                initial_message = None
+            else:
+                raise NotImplementedError(
+                    f"The case of not explicitly setting the `initial message` with caller_input_mode = {caller_input_mode} is not supported. This is probably a problem from our side. Please try to proceed with explicitly setting a value for `initial_message`."
+                )
+
         if output_descriptors is not None and len(
             set(descriptor.name for descriptor in output_descriptors)
         ) < len(output_descriptors):
             raise ValueError(
                 f"Detected name conflicts in outputs of the Agent. Please ensure output names are unique: {output_descriptors}"
             )
 
+        if caller_input_mode == CallerInputMode.NEVER and initial_message is not None:
+            raise ValueError(
+                "The caller input mode for the agent is set to `CallerInputMode.NEVER`, which does not allow setting an initial message."
+            )
+
+        if (
+            caller_input_mode == CallerInputMode.NEVER
+            and tools is not None
+            and len(tools) > 0
+            and max_iterations <= 1
+        ):
+            warnings.warn(
+                "Maximum number of iterations is set to one for the Agent. The agent will be not able to call the tools and report the result.",
+                UserWarning,
+            )
+
         self.llm = llm
 
         self.tools = _convert_previously_supported_tools_if_needed(tools) or []

wayflowcore/tests/integration/steps/test_agentexecution_step.py

@@ -256,6 +256,7 @@ def test_agent_executor_step_can_read_previous_messages(
     agent = Agent(
         llm=remotely_hosted_llm,
         caller_input_mode=CallerInputMode.NEVER,
+        custom_instruction="Please help me with my tasks.",
         _filter_messages_by_recipient=False,
     )
     output_step = OutputMessageStep(

wayflowcore/tests/integration/test_agent.py

@@ -29,7 +29,7 @@
 from wayflowcore.models.llmmodel import LlmModel
 from wayflowcore.models.llmmodelfactory import LlmModelFactory
 from wayflowcore.models.vllmmodel import VllmModel
-from wayflowcore.property import IntegerProperty, StringProperty
+from wayflowcore.property import BooleanProperty, IntegerProperty, StringProperty
 from wayflowcore.steps import (
     AgentExecutionStep,
     InputMessageStep,
@@ -1618,3 +1618,145 @@ async def test_agent_can_run_async(remotely_hosted_llm):
     conversation = agent.start_conversation()
     status = await conversation.execute_async()
     assert isinstance(status, UserMessageRequestStatus)
+
+
+def test_error_on_caller_input_mode_never_with_initial_message(big_llama):
+    with pytest.raises(
+        ValueError, match="The caller input mode for the agent is set to `CallerInputMode.NEVER`"
+    ):
+        Agent(
+            llm=big_llama,
+            caller_input_mode=CallerInputMode.NEVER,
+            initial_message="Hi, what's your name?",
+        )
+
+
+def _get_haiku_tool(
+    submitted_haikus: List[str],
+    success_message: str = "Haiku Submitted Successfully.",
+):
+    @tool(description_mode="only_docstring")
+    def submit_haiku(haiku: str) -> str:
+        """Submit your haiku.
+
+        Parameters
+        ----------
+        haiku :
+            the full haiku (all three verses of it)
+
+        Returns
+        -------
+        A status code
+        """
+        submitted_haikus.append(haiku)
+        return success_message
+
+    return submit_haiku
+
+
+@retry_test(max_attempts=3)
+@pytest.mark.parametrize("can_finish_conversation", [True])
+def test_caller_input_mode_never(big_llama, can_finish_conversation):
+    """
+    Failure rate:          0 out of 20
+    Observed on:           2025-07-28
+    Average success time:  4.20 seconds per successful attempt
+    Average failure time:  No time measurement
+    Max attempt:           3
+    Justification:         (0.05 ** 3) ~= 9.4 / 100'000
+    """
+
+    submitted_haikus = []
+
+    agent = Agent(
+        llm=big_llama,
+        tools=[_get_haiku_tool(submitted_haikus)],
+        caller_input_mode=CallerInputMode.NEVER,
+        custom_instruction="You are a helpful assistant, who always uses the appropriate tool to submit a single Haiku, and then finishes the conversation.",
+        initial_message=None,
+        can_finish_conversation=can_finish_conversation,
+        max_iterations=5,
+    )
+
+    conv = agent.start_conversation()
+    conv.execute()
+    assert len(submitted_haikus) == 1
+
+
+@retry_test(max_attempts=3)
+@pytest.mark.parametrize("can_finish_conversation", [True, False])
+def test_caller_input_mode_never_with_agent_template(big_llama, can_finish_conversation):
+    """
+    Failure rate:          0 out of 20
+    Observed on:           2025-07-28
+    Average success time:  4.20 seconds per successful attempt
+    Average failure time:  No time measurement
+    Max attempt:           3
+    Justification:         (0.05 ** 3) ~= 9.4 / 100'000
+    """
+    submitted_haikus = []
+
+    agent = Agent(
+        llm=big_llama,
+        tools=[_get_haiku_tool(submitted_haikus)],
+        caller_input_mode=CallerInputMode.NEVER,
+        initial_message=None,
+        custom_instruction="You are a helpful assistant, who always uses the appropriate tool to submit a single Haiku, and then finishes the conversation.",
+        agent_template=PromptTemplate(
+            messages=[
+                Message("{{user_input}}", MessageType.USER),
+                PromptTemplate.CHAT_HISTORY_PLACEHOLDER,
+            ],
+        ),
+        output_descriptors=[
+            BooleanProperty(
+                "haiku_submitted",
+                description="true if the haiku was successfully submitted",
+                default_value=False,
+            )
+        ],
+        can_finish_conversation=can_finish_conversation,
+        max_iterations=5,
+    )
+
+    conv = agent.start_conversation(inputs={"user_input": "I want my haiku to be about trees"})
+    status = conv.execute()
+    assert isinstance(status, FinishedStatus)
+    assert status.output_values["haiku_submitted"]
+    assert len(submitted_haikus) == 1
+
+
+@retry_test(max_attempts=3)
+def test_caller_input_mode_never_with_single_iteration(big_llama):
+    """
+    Failure rate:          0 out of 20
+    Observed on:           2025-07-28
+    Average success time:  0.87 seconds per successful attempt
+    Average failure time:  No time measurement
+    Max attempt:           3
+    Justification:         (0.05 ** 3) ~= 9.4 / 100'000
+    """
+    submitted_haikus = []
+
+    with pytest.warns(
+        UserWarning, match="Maximum number of iterations is set to one for the Agent.*"
+    ):
+        agent = Agent(
+            llm=big_llama,
+            tools=[_get_haiku_tool(submitted_haikus)],
+            caller_input_mode=CallerInputMode.NEVER,
+            custom_instruction="You are a helpful assistant, who always uses the appropriate tool to submit a single Haiku, and then finishes the conversation.",
+            output_descriptors=[
+                BooleanProperty(
+                    "haiku_submitted", "true if the haiku was submitted", default_value=False
+                )
+            ],
+            initial_message=None,
+            can_finish_conversation=False,
+            max_iterations=1,
+        )
+
+    conv = agent.start_conversation()
+    status = conv.execute()
+    assert isinstance(status, FinishedStatus)
+    assert not status.output_values["haiku_submitted"]

wayflowcore/tests/test_caller_input_mode.py

@@ -182,4 +182,9 @@ def test_agent_raises_when_passing_talk_to_user_tool_when_callerinputmode_is_set
         ValueError,
         match=f"Caller input mode is set to 'NEVER' but found a tool with name {_TALK_TO_USER_TOOL_NAME}. Make sure to not pass any tool with this name.",
     ):
-        _ = Agent(llm=llm, tools=[talk_to_user_tool], caller_input_mode=CallerInputMode.NEVER)
+        _ = Agent(
+            llm=llm,
+            tools=[talk_to_user_tool],
+            caller_input_mode=CallerInputMode.NEVER,
+            custom_instruction="A random custom instruction. If custom instruction is not provided, an earlier exception will appear.",
+        )