fix(colang): parse generated actions from current OpenAI models

docs/configure-rails/colang/colang-2/language-reference/make-use-of-llms.mdx

@@ -49,6 +49,20 @@ model: meta/llama-3.1-70b-instruct
 ```
 To support other models, you would need to create a set of new [template prompts](https://github.com/NVIDIA-NeMo/Guardrails/tree/develop/nemoguardrails/llm/prompts) that consider the specific capabilities and the API of the model and add them to your bot configuration.
 
+For `engine: openai` with GPT-5 or GPT-6 model names, dedicated chat templates cover
+user-intent detection, combined intent and bot-action generation, interaction
+continuation, and value generation. These tasks use the `main` model unless you
+configure a task-specific model. The default OpenAI-compatible framework requires
+`OPENAI_API_KEY` and no optional integration extra. These templates do not change
+the prompts for generating whole flows from names or natural-language descriptions.
+
+Generated bot actions must use the `bot action:` format shown in the templates.
+The parser accepts straight or paired curly double quotes as string delimiters,
+preserves quotes inside the string, and stops before subsequent dialogue turns.
+An answer with no bot action raises an `LlmResponseError` instead of creating an
+empty continuation flow. Custom prompts should request only the next turn;
+provider-side stop sequences are not available on every model.
+
 ## Natural Language Description (NLD)
 
 One of the main LLM generation mechanisms in Colang is the so-called Natural Language Description (NLD) in combination with the "generation" operator `...`.

docs/configure-rails/yaml-schema/prompt-configuration.mdx

@@ -317,11 +317,19 @@ The library includes predefined prompts for these models:
 - `openai/gpt-3.5-turbo-instruct`
 - `openai/gpt-3.5-turbo`
 - `openai/gpt-4`
+- `openai/gpt-5` and `openai/gpt-6` model families
 - `databricks/dolly-v2-3b`
 - `cohere/command`
 - `cohere/command-light`
 - `cohere/command-light-nightly`
 
+For Colang 1, the GPT-5 and GPT-6 prompt families use chat messages for intent
+classification, next-step generation, bot messages, single-call dialog generation,
+and value generation. Intent prompts request structured output instead of a spoken
+reply. Single-call generation requests two intent lines followed by the bot message;
+the parser also accepts an optional leading quoted user-message echo in buffered
+and streaming modes. Custom prompts can override these templates using `models`.
+
 <Note>
 
 Predefined prompts are continuously evaluated and improved. Test and customize prompts for your specific use case before deploying to production.

nemoguardrails/actions/llm/generation.py

@@ -121,6 +121,19 @@ def _streaming_pattern_for(output_parser, *, include_bot_message_parser: bool):
     return ('  "', "  “"), ('"', "”")
 
 
+def _remove_echoed_user_message(completion: str) -> Tuple[str, bool]:
+    """Remove an optional quoted user-message line before the generated intents."""
+    lines = completion.splitlines(keepends=True)
+    for index, line in enumerate(lines):
+        line = line.strip()
+        if not line or line.startswith("#"):
+            continue
+        if re.fullmatch(r'(?:user|User message:)\s+["“].*["”]', line, flags=re.IGNORECASE):
+            return "".join(lines[index + 1 :]), True
+        break
+    return completion, False
+
+
 @dataclass
 class SingleCallPayload:
     """The bot intent/message events computed by the single-call generation.
@@ -1433,6 +1446,11 @@ async def generate_intent_steps_message(
                 )
                 _streaming_handler.set_producer_task(producer_task)
                 result = await _streaming_handler.wait_top_k_nonempty_lines(k=2)
+                result, echoed_user_message = _remove_echoed_user_message(result)
+                if echoed_user_message:
+                    # The echo consumed one of the two buffered intent lines.
+                    bot_intent_line = await _streaming_handler.wait_top_k_nonempty_lines(k=1)
+                    result += "\n" + bot_intent_line
 
                 # Moving forward we need to set the expected pattern to correctly
                 # parse the message.
@@ -1452,6 +1470,7 @@ async def generate_intent_steps_message(
                     "temperature": self.config.lowest_temperature,
                 }
                 result = (await llm_call(generation_llm, prompt, llm_params=additional_params)).content
+                result, _ = _remove_echoed_user_message(result)
 
             # Parse the output using the associated parser
             result = self.llm_task_manager.parse_task_output(Task.GENERATE_INTENT_STEPS_MESSAGE, output=result)

nemoguardrails/actions/llm/utils.py

@@ -438,10 +438,52 @@ def get_first_bot_intent(strings: List[str]) -> Optional[str]:
     return None
 
 
+def _normalize_action_quotes(action: str) -> str:
+    """Normalize generated curly string delimiters, preserving quoted content."""
+    if "“" not in action:
+        return action
+    result = []
+    delimiter = None
+    curly_depth = 0
+    escaped = False
+    for char in action:
+        if escaped:
+            result.append(char)
+            escaped = False
+            continue
+        if char == "\\" and delimiter is not None:
+            result.append(char)
+            escaped = True
+            continue
+        if delimiter == "“":
+            if char == "“":
+                curly_depth += 1
+            elif char == "”":
+                curly_depth -= 1
+                if curly_depth == 0:
+                    delimiter = None
+                    result.append('"')
+                    continue
+            elif char == '"':
+                result.append('\\"')
+                continue
+        elif delimiter is not None:
+            if char == delimiter:
+                delimiter = None
+        elif char in ('"', "'", "“"):
+            delimiter = char
+            if char == "“":
+                curly_depth = 1
+                result.append('"')
+                continue
+        result.append(char)
+    return "".join(result)
+
+
 def _has_unclosed_quote(s: str) -> bool:
     """Check if a string has an unclosed double quote (ignoring escaped quotes)."""
     # Strip escaped backslashes first so that \\" is not misread as \" (escaped quote).
-    return s.replace("\\\\", "").replace('\\"', "").count('"') % 2 == 1
+    return _normalize_action_quotes(s).replace("\\\\", "").replace('\\"', "").count('"') % 2 == 1
 
 
 _MAX_QUOTE_CONTINUATION_LINES = 50
@@ -458,7 +500,7 @@ def get_first_bot_action(strings: List[str]) -> Optional[str]:
         if action and _has_unclosed_quote(action):
             if continuation_lines >= _MAX_QUOTE_CONTINUATION_LINES:
                 # Safety bound: stop collecting to avoid absorbing all input.
-                return action
+                return _normalize_action_quotes(action)
             action += "\\n" + string
             continuation_lines += 1
             if not _has_unclosed_quote(action):
@@ -467,16 +509,16 @@ def get_first_bot_action(strings: List[str]) -> Optional[str]:
         if string.startswith("bot action: "):
             if action != "":
                 action += "\n"
-            action += string.replace("bot action: ", "")
+            action += string.removeprefix("bot action: ")
             action_started = True
         elif (string.startswith("  and") or string.startswith("  or")) and action_started:
             action = action + string
         elif string == "":
             action_started = False
             continue
         elif action != "":
-            return action
-    return action
+            return _normalize_action_quotes(action)
+    return _normalize_action_quotes(action)
 
 
 def escape_flow_name(name: str) -> str:

nemoguardrails/actions/v2_x/generation.py

@@ -389,7 +389,7 @@ async def generate_user_intent_and_bot_action(
         bot_intent = get_first_bot_intent(result.splitlines())
         bot_action = get_first_bot_action(result.splitlines())
 
-        if bot_action is None:
+        if not bot_action or not bot_action.strip():
             raise LlmResponseError(f"Issue with LLM response: {result}")
 
         user_intent = escape_flow_name(user_intent.strip(" "))
@@ -705,7 +705,7 @@ async def generate_flow_continuation(
             bot_intent = get_first_bot_intent(result.splitlines())
         bot_action = get_first_bot_action(result.splitlines())
 
-        if bot_action is None:
+        if not bot_action or not bot_action.strip():
             raise LlmResponseError(f"Issue with LLM response: {result}")
 
         if bot_intent:
@@ -719,7 +719,7 @@ async def generate_flow_continuation(
         return {
             "name": flow_name,
             "parameters": flow_parameters,
-            "body": f'@meta(bot_intent="{bot_intent}")\n' + f"flow {flow_name}\n" + f"  {bot_action}",
+            "body": f'@meta(bot_intent="{bot_intent}")\n' + f"flow {flow_name}\n" + textwrap.indent(bot_action, "  "),
         }
 
     @action(name="CreateFlowAction", is_system_action=True, execute_async=True)
@@ -738,7 +738,7 @@ async def create_flow(
         flow_name = f"_dynamic_{uuid} {name}"
         # TODO: parse potential parameters from flow name with a regex
 
-        body = f"flow {flow_name}\n  " + body
+        body = f"flow {flow_name}\n" + textwrap.indent(body, "  ")
         if decorators:
             body = decorators + "\n" + body
 

nemoguardrails/llm/prompts/openai-colang1.yml

@@ -0,0 +1,139 @@
+prompts:
+  - task: generate_user_intent
+    models: &models
+      - openai/gpt-5
+      - openai/gpt-6
+    messages:
+      - type: system
+        content: |-
+          {{ general_instructions }}
+
+          Classify the latest user message into a Colang 1 user intent.
+          Prefer a matching intent from the examples. If none matches, generate
+          a short intent name that describes the user's request.
+          Return exactly one line: User intent: <intent name>
+          Do not answer the user, repeat their message, or include explanations
+          or Markdown fences.
+      - type: user
+        content: |-
+          Example conversation:
+          {{ sample_conversation | verbose_v1 }}
+
+          Intent examples:
+          {{ examples | verbose_v1 }}
+
+          Candidate intents: {{ potential_user_intents }}
+
+          Conversation:
+          {{ history | colang | verbose_v1 }}
+    output_parser: user_intent
+
+  - task: generate_next_steps
+    models: *models
+    messages:
+      - type: system
+        content: |-
+          {{ general_instructions }}
+
+          Generate the next Colang 1 flow steps for the latest user intent,
+          following the matching examples. For a bot response, return only:
+          Bot intent: <intent name>
+          When an example calls for actions or other flow steps, return those
+          Colang steps instead. Do not write the spoken answer, repeat the user
+          intent, or include explanations or Markdown fences.
+      - type: user
+        content: |-
+          Example conversation:
+          {{ sample_conversation | remove_text_messages | verbose_v1 }}
+
+          Flow examples:
+          {{ examples | remove_text_messages | verbose_v1 }}
+
+          Conversation:
+          {{ history | colang | remove_text_messages | verbose_v1 }}
+    output_parser: verbose_v1
+
+  - task: generate_bot_message
+    models: *models
+    messages:
+      - type: system
+        content: |-
+          {{ general_instructions }}
+
+          Write the spoken response for the latest bot intent in the conversation.
+          Return only: Bot message: "<response>"
+          Use straight double quotes around the response. Do not repeat intents,
+          invent another turn, or include explanations or Markdown fences.
+      - type: user
+        content: |-
+          Example conversation:
+          {{ sample_conversation | verbose_v1 }}
+
+          Bot response examples:
+          {{ examples | verbose_v1 }}
+
+          {% if relevant_chunks %}
+          Reference information:
+          {{ relevant_chunks }}
+          {% endif %}
+
+          Conversation:
+          {{ history | colang | verbose_v1 }}
+    output_parser: bot_message
+
+  - task: generate_intent_steps_message
+    models: *models
+    messages:
+      - type: system
+        content: |-
+          {{ general_instructions }}
+
+          Generate the next turn of a Colang 1 interaction, using exactly this format:
+          User intent: <intent name>
+          Bot intent: <intent name>
+          Bot message: "<response>"
+
+          Prefer a matching user intent from the examples. If none matches,
+          generate a short intent name that describes the user's request.
+          Use straight double quotes around the response. Generate only these
+          two intents and the bot message. Do not repeat the user message,
+          invent another turn, or include explanations or Markdown fences.
+      - type: user
+        content: |-
+          Example conversation:
+          {{ sample_conversation | verbose_v1 }}
+
+          Flow examples:
+          {{ examples | verbose_v1 }}
+
+          Candidate intents: {{ potential_user_intents }}
+
+          {% if relevant_chunks %}
+          Reference information:
+          {{ relevant_chunks }}
+          {% endif %}
+
+          Conversation:
+          {{ history | colang | verbose_v1 }}
+    output_parser: verbose_v1
+
+  - task: generate_value
+    models: *models
+    messages:
+      - type: system
+        content: |-
+          {{ general_instructions }}
+
+          Generate a value for the variable {{ var_name }} following the instruction.
+          Return only a Python literal on one line, with no assignment, explanation,
+          or Markdown fences. Use True and False for booleans and straight quotes
+          for strings.
+      - type: user
+        content: |-
+          Flow examples:
+          {{ examples }}
+
+          Conversation:
+          {{ history | colang }}
+
+          Instruction: {{ instructions }}