allow user prompt to be optional and update regression test to be correct

Author: sjrl

haystack/components/generators/chat/llm.py

@@ -48,7 +48,7 @@ def __init__(
         *,
         chat_generator: ChatGenerator,
         system_prompt: str | None = None,
-        user_prompt: str,
+        user_prompt: str | None = None,
         required_variables: list[str] | Literal["*"] = "*",
         streaming_callback: StreamingCallbackT | None = None,
     ) -> None:
@@ -59,12 +59,13 @@ def __init__(
         :param system_prompt: System prompt for the LLM.
         :param user_prompt: User prompt for the LLM. This prompt is appended to the messages provided at
             runtime. If it contains Jinja2 template variables (e.g., `{{ variable_name }}`), they become
-            inputs to the component. If there are no template variables, `messages` must be provided at
-            runtime instead.
+            inputs to the component. If omitted or if there are no template variables, `messages` must be
+            provided at runtime instead.
         :param required_variables:
             Variables that must be provided as input to user_prompt.
             If a variable listed as required is not provided, an exception is raised.
             If set to `"*"`, all variables found in the prompt are required. Defaults to `"*"`.
+            Only relevant when `user_prompt` contains template variables.
         :param streaming_callback: A callback that will be invoked when a response is streamed from the LLM.
         :raises ValueError: If user_prompt contains template variables but required_variables is an empty list.
         """

test/components/generators/chat/test_llm.py

@@ -301,41 +301,45 @@ class TestLLMNotTriggeredByInjectedInput:
     when its required inputs (e.g. `query`) never arrive.
     """
 
-    USER_PROMPT = '{% message role="user" %}{{ query }}{% endmessage %}'
-
     def test_llm_not_triggered_by_injected_streaming_callback(self):
+
         @component
         class Planner:
-            @component.output_types(query=str, last_role=str)
+            @component.output_types(messages=list[ChatMessage], last_role=str)
             def run(self) -> dict:
-                return {"query": "What is 2+2?", "last_role": "assistant"}
+                return {"messages": [ChatMessage.from_user("hello")], "last_role": "assistant"}
 
         chat_generator = MockChatGenerator()
-        llm = LLM(chat_generator=chat_generator, user_prompt=self.USER_PROMPT)
+        llm = LLM(chat_generator=chat_generator)
         chat_generator.run = MagicMock(return_value={"replies": [ChatMessage.from_assistant("x")]})
 
         router = ConditionalRouter(
             routes=[
                 {
                     "condition": "{{ last_role == 'tool' }}",
-                    "output": "{{ query }}",
+                    "output": "{{ messages }}",
                     "output_name": "processing",
-                    "output_type": str,
+                    "output_type": list[ChatMessage],
+                },
+                {
+                    "condition": "{{ True }}",
+                    "output": "{{ messages }}",
+                    "output_name": "planning",
+                    "output_type": list[ChatMessage],
                 },
-                {"condition": "{{ True }}", "output": "{{ query }}", "output_name": "planning", "output_type": str},
             ],
             unsafe=True,
         )
 
         pipeline = Pipeline()
         pipeline.add_component("planner", Planner())
         pipeline.add_component("router", router)
-        pipeline.add_component("branch_joiner", BranchJoiner(type_=str))
+        pipeline.add_component("branch_joiner", BranchJoiner(type_=list[ChatMessage]))
         pipeline.add_component("llm", llm)
-        pipeline.connect("planner.query", "router.query")
+        pipeline.connect("planner.messages", "router.messages")
         pipeline.connect("planner.last_role", "router.last_role")
         pipeline.connect("router.processing", "branch_joiner.value")
-        pipeline.connect("branch_joiner.value", "llm.query")
+        pipeline.connect("branch_joiner.value", "llm.messages")
 
         result = pipeline.run(data={"llm": {"streaming_callback": sync_streaming_callback}})