refactor(generation): decompose LLMGenerationActions into single-responsibility helpers

tests/recorded/rails/public_api/configs.py

@@ -53,6 +53,7 @@
 NIM_BASELINE_CONFIG = RailsConfigSource.from_path(CONFIGS_DIR, "nim_baseline")
 NEMOGUARDS_FULL_CONFIG = RailsConfigSource.from_path(CONFIGS_DIR, "nemoguards_full")
 DIALOG_CONFIG = RailsConfigSource.from_path(CONFIGS_DIR, "dialog")
+DIALOG_GENERATION_CONFIG = RailsConfigSource.from_path(CONFIGS_DIR, "dialog_generation")
 SINGLE_CALL_CONFIG = RailsConfigSource.from_path(CONFIGS_DIR, "single_call")
 TASK_MODELS_CONFIG = RailsConfigSource.from_path(CONFIGS_DIR, "task_models")
 STREAMING_OUTPUT_RAILS_CONFIG = RailsConfigSource.from_path(CONFIGS_DIR, "streaming_output_rails")

tests/recorded/rails/public_api/configs/dialog_generation/config.py

@@ -0,0 +1,20 @@
+# SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from tests.recorded.rails.public_api.simple_embedding_provider import SimpleEmbeddingSearchProvider
+
+
+def init(app):
+    app.register_embedding_search_provider("simple", SimpleEmbeddingSearchProvider)

tests/recorded/rails/public_api/configs/dialog_generation/config.yml

@@ -0,0 +1,12 @@
+models:
+  - type: main
+    engine: openai
+    model: gpt-5.4-nano
+    parameters:
+      max_retries: 0
+core:
+  embedding_search_provider:
+    name: simple
+knowledge_base:
+  embedding_search_provider:
+    name: simple

tests/recorded/rails/public_api/configs/dialog_generation/kb/product.md

@@ -0,0 +1,5 @@
+# Product overview
+
+The product is a guardrails toolkit for large language models. It lets
+developers add programmable rails that check user input, steer the dialog, and
+validate bot output before it reaches the user.

tests/recorded/rails/public_api/configs/dialog_generation/rails.co

@@ -0,0 +1,21 @@
+define user express greeting
+  "hello"
+  "hi"
+
+define user ask about the product
+  "tell me about your product"
+  "what does the product do"
+
+define bot express greeting
+  "Hey there!"
+
+define bot offer help
+  "I'm here to help with anything you need."
+
+define flow greeting
+  user express greeting
+  bot express greeting
+
+define flow product
+  user ask about the product
+  bot describe the product

tests/recorded/rails/public_api/test_dialog.py

@@ -21,7 +21,7 @@
 from nemoguardrails.rails.llm.options import RailStatus
 from tests.recorded.assertions import assert_generated_message, assert_rails_result
 from tests.recorded.normalization import normalize_rails_result
-from tests.recorded.rails.public_api.configs import DIALOG_CONFIG, SINGLE_CALL_CONFIG
+from tests.recorded.rails.public_api.configs import DIALOG_CONFIG, DIALOG_GENERATION_CONFIG, SINGLE_CALL_CONFIG
 from tests.recorded.rails_config import load_config
 from tests.recorded.snapshots import snapshot
 
@@ -43,6 +43,41 @@ async def test_dialog_generate_async_public_contract(openai_api_key):
     )
 
 
+@pytest.mark.vcr
+async def test_dialog_generation_bot_message_public_contract(openai_api_key):
+    """Bot-message GENERATION prompt carries few-shot examples + retrieved kb chunks.
+
+    "tell me about your product" maps (via a flow) to the bot intent
+    "describe the product", which has no predefined message, so
+    ``generate_bot_message`` calls the LLM with the bot-message index examples and
+    the retrieved kb chunks. VCR matches on ``recorded_body``, so this cassette
+    pins all three dialog prompts (intent, next-step, bot-message) by their exact
+    request bodies. It was verified to replay byte-identically against both the
+    pre-refactor ``generation.py`` on ``develop`` and the refactored branch, so
+    the prompts are unchanged pre/post -- a prompt-fidelity equivalence check the
+    prompt-independent ``FakeLLMModel`` oracle cannot make.
+    """
+    rails = LLMRails(load_config(DIALOG_GENERATION_CONFIG), verbose=False)
+
+    result = await rails.generate_async(messages=[{"role": "user", "content": "tell me about your product"}])
+
+    assert_generated_message(result)
+    assert result == snapshot(
+        {
+            "role": "assistant",
+            "content": """\
+Sure! If you mean the **guardrails toolkit for large language models** you mentioned in the context, here’s what it is and what it helps you do:
+- **Programmable “rails” for LLMs:** Lets developers define rules and logic that run during the conversation.
+- **Check user input:** You can validate or filter what users send (e.g., detect disallowed content, enforce formatting, constrain requests).
+- **Steer the dialog:** You can route or modify the assistant’s behavior based on the input or conversation state (e.g., ask clarifying questions, refuse safely, switch modes).
+- **Validate bot output:** Before the response is shown to the user, rails can verify it meets requirements (e.g., must include/avoid certain content, follow a policy, adhere to a schema).
+- **Reduce unsafe or off-policy responses:** The overall goal is to make LLM behavior more controlled, consistent, and safer.
+If you tell me what kind of use case you’re building (customer support, tutoring, legal/health Q&A, internal tools, etc.), I can suggest what kinds of rails you’d typically implement.\
+""",
+        }
+    )
+
+
 @pytest.mark.vcr
 async def test_single_call_generate_async_public_contract(openai_api_key):
     rails = LLMRails(load_config(SINGLE_CALL_CONFIG), verbose=False)