markdown-flow 0.2.18__py3-none-any.whl → 0.2.26__py3-none-any.whl

markdown_flow/core.py

@@ -18,6 +18,7 @@ from .constants import (
     COMPILED_INTERACTION_CONTENT_RECONSTRUCT_REGEX,
     COMPILED_VARIABLE_REFERENCE_CLEANUP_REGEX,
     COMPILED_WHITESPACE_CLEANUP_REGEX,
+    DEFAULT_BASE_SYSTEM_PROMPT,
     DEFAULT_INTERACTION_ERROR_PROMPT,
     DEFAULT_INTERACTION_PROMPT,
     DEFAULT_VALIDATION_SYSTEM_MESSAGE,
@@ -35,7 +36,7 @@ from .enums import BlockType
 from .exceptions import BlockIndexError
 from .llm import LLMProvider, LLMResult, ProcessMode
 from .models import Block, InteractionValidationConfig
-from .utils import (
+from .parser import (
     InteractionParser,
     InteractionType,
     extract_interaction_question,
@@ -60,48 +61,105 @@ class MarkdownFlow:
     _document_prompt: str | None
     _interaction_prompt: str | None
     _interaction_error_prompt: str | None
+    _max_context_length: int
     _blocks: list[Block] | None
     _interaction_configs: dict[int, InteractionValidationConfig]
+    _model: str | None
+    _temperature: float | None
 
     def __init__(
         self,
         document: str,
         llm_provider: LLMProvider | None = None,
+        base_system_prompt: str | None = None,
         document_prompt: str | None = None,
         interaction_prompt: str | None = None,
         interaction_error_prompt: str | None = None,
+        max_context_length: int = 0,
     ):
         """
         Initialize MarkdownFlow instance.
 
         Args:
             document: Markdown document content
-            llm_provider: LLM provider, if None only PROMPT_ONLY mode is available
+            llm_provider: LLM provider (required for COMPLETE and STREAM modes)
+            base_system_prompt: MarkdownFlow base system prompt (framework-level, content blocks only)
             document_prompt: Document-level system prompt
             interaction_prompt: Interaction content rendering prompt
             interaction_error_prompt: Interaction error rendering prompt
+            max_context_length: Maximum number of context messages to keep (0 = unlimited)
         """
         self._document = document
         self._llm_provider = llm_provider
+        self._base_system_prompt = base_system_prompt or DEFAULT_BASE_SYSTEM_PROMPT
         self._document_prompt = document_prompt
         self._interaction_prompt = interaction_prompt or DEFAULT_INTERACTION_PROMPT
         self._interaction_error_prompt = interaction_error_prompt or DEFAULT_INTERACTION_ERROR_PROMPT
+        self._max_context_length = max_context_length
         self._blocks = None
         self._interaction_configs: dict[int, InteractionValidationConfig] = {}
+        self._model: str | None = None
+        self._temperature: float | None = None
 
     def set_llm_provider(self, provider: LLMProvider) -> None:
         """Set LLM provider."""
         self._llm_provider = provider
 
+    def set_model(self, model: str) -> "MarkdownFlow":
+        """
+        Set model name for this instance.
+
+        Args:
+            model: Model name to use
+
+        Returns:
+            Self for method chaining
+        """
+        self._model = model
+        return self
+
+    def set_temperature(self, temperature: float) -> "MarkdownFlow":
+        """
+        Set temperature for this instance.
+
+        Args:
+            temperature: Temperature value (typically 0.0-2.0)
+
+        Returns:
+            Self for method chaining
+        """
+        self._temperature = temperature
+        return self
+
+    def get_model(self) -> str | None:
+        """
+        Get model name for this instance.
+
+        Returns:
+            Model name if set, None otherwise
+        """
+        return self._model
+
+    def get_temperature(self) -> float | None:
+        """
+        Get temperature for this instance.
+
+        Returns:
+            Temperature value if set, None otherwise
+        """
+        return self._temperature
+
     def set_prompt(self, prompt_type: str, value: str | None) -> None:
         """
         Set prompt template.
 
         Args:
-            prompt_type: Prompt type ('document', 'interaction', 'interaction_error')
+            prompt_type: Prompt type ('base_system', 'document', 'interaction', 'interaction_error')
             value: Prompt content
         """
-        if prompt_type == "document":
+        if prompt_type == "base_system":
+            self._base_system_prompt = value or DEFAULT_BASE_SYSTEM_PROMPT
+        elif prompt_type == "document":
             self._document_prompt = value
         elif prompt_type == "interaction":
             self._interaction_prompt = value or DEFAULT_INTERACTION_PROMPT
@@ -110,6 +168,44 @@ class MarkdownFlow:
         else:
             raise ValueError(UNSUPPORTED_PROMPT_TYPE_ERROR.format(prompt_type=prompt_type))
 
+    def _truncate_context(
+        self,
+        context: list[dict[str, str]] | None,
+    ) -> list[dict[str, str]] | None:
+        """
+        Filter and truncate context to specified maximum length.
+
+        Processing steps:
+        1. Filter out messages with empty content (empty string or whitespace only)
+        2. Truncate to max_context_length if configured (0 = unlimited)
+
+        Args:
+            context: Original context list
+
+        Returns:
+            Filtered and truncated context. Returns None if no valid messages remain.
+        """
+        if not context:
+            return None
+
+        # Step 1: Filter out messages with empty or whitespace-only content
+        filtered_context = [msg for msg in context if msg.get("content", "").strip()]
+
+        # Return None if no valid messages remain after filtering
+        if not filtered_context:
+            return None
+
+        # Step 2: Truncate to max_context_length if configured
+        if self._max_context_length == 0:
+            # No limit, return all filtered messages
+            return filtered_context
+
+        # Keep the most recent N messages
+        if len(filtered_context) > self._max_context_length:
+            return filtered_context[-self._max_context_length :]
+
+        return filtered_context
+
     @property
     def document(self) -> str:
         """Get document content."""
@@ -198,6 +294,10 @@ class MarkdownFlow:
         Returns:
             LLMResult or Generator[LLMResult, None, None]
         """
+        # Process base_system_prompt variable replacement
+        if self._base_system_prompt:
+            self._base_system_prompt = replace_variables_in_text(self._base_system_prompt, variables or {})
+
         # Process document_prompt variable replacement
         if self._document_prompt:
             self._document_prompt = replace_variables_in_text(self._document_prompt, variables or {})
@@ -210,7 +310,7 @@ class MarkdownFlow:
         if block.block_type == BlockType.INTERACTION:
             if user_input is None:
                 # Render interaction content
-                return self._process_interaction_render(block_index, mode, variables)
+                return self._process_interaction_render(block_index, mode, context, variables)
             # Process user input
             return self._process_interaction_input(block_index, user_input, mode, context, variables)
 
@@ -231,17 +331,17 @@ class MarkdownFlow:
         variables: dict[str, str | list[str]] | None,
     ):
         """Process content block."""
-        # Build messages
-        messages = self._build_content_messages(block_index, variables)
+        # Truncate context to configured maximum length
+        truncated_context = self._truncate_context(context)
 
-        if mode == ProcessMode.PROMPT_ONLY:
-            return LLMResult(prompt=messages[-1]["content"], metadata={"messages": messages})
+        # Build messages with context
+        messages = self._build_content_messages(block_index, variables, truncated_context)
 
         if mode == ProcessMode.COMPLETE:
             if not self._llm_provider:
                 raise ValueError(LLM_PROVIDER_REQUIRED_ERROR)
 
-            content = self._llm_provider.complete(messages)
+            content = self._llm_provider.complete(messages, model=self._model, temperature=self._temperature)
             return LLMResult(content=content, prompt=messages[-1]["content"])
 
         if mode == ProcessMode.STREAM:
@@ -249,7 +349,7 @@ class MarkdownFlow:
                 raise ValueError(LLM_PROVIDER_REQUIRED_ERROR)
 
             def stream_generator():
-                for chunk in self._llm_provider.stream(messages):  # type: ignore[attr-defined]
+                for chunk in self._llm_provider.stream(messages, model=self._model, temperature=self._temperature):  # type: ignore[attr-defined]
                     yield LLMResult(content=chunk, prompt=messages[-1]["content"])
 
             return stream_generator()
@@ -266,7 +366,13 @@ class MarkdownFlow:
 
         return LLMResult(content=content)
 
-    def _process_interaction_render(self, block_index: int, mode: ProcessMode, variables: dict[str, str | list[str]] | None = None):
+    def _process_interaction_render(
+        self,
+        block_index: int,
+        mode: ProcessMode,
+        context: list[dict[str, str]] | None = None,
+        variables: dict[str, str | list[str]] | None = None,
+    ):
         """Process interaction content rendering."""
         block = self.get_block(block_index)
 
@@ -283,23 +389,17 @@ class MarkdownFlow:
             # Unable to extract, return processed content
             return LLMResult(content=processed_block.content)
 
-        # Build render messages
-        messages = self._build_interaction_render_messages(question_text)
+        # Truncate context to configured maximum length
+        truncated_context = self._truncate_context(context)
 
-        if mode == ProcessMode.PROMPT_ONLY:
-            return LLMResult(
-                prompt=messages[-1]["content"],
-                metadata={
-                    "original_content": processed_block.content,
-                    "question_text": question_text,
-                },
-            )
+        # Build render messages with context
+        messages = self._build_interaction_render_messages(question_text, truncated_context)
 
         if mode == ProcessMode.COMPLETE:
             if not self._llm_provider:
                 return LLMResult(content=processed_block.content)  # Fallback processing
 
-            rendered_question = self._llm_provider.complete(messages)
+            rendered_question = self._llm_provider.complete(messages, model=self._model, temperature=self._temperature)
             rendered_content = self._reconstruct_interaction_content(processed_block.content, rendered_question)
 
             return LLMResult(
@@ -327,7 +427,7 @@ class MarkdownFlow:
             # With LLM provider, collect full response then return once
             def stream_generator():
                 full_response = ""
-                for chunk in self._llm_provider.stream(messages):  # type: ignore[attr-defined]
+                for chunk in self._llm_provider.stream(messages, model=self._model, temperature=self._temperature):  # type: ignore[attr-defined]
                     full_response += chunk
 
                 # Reconstruct final interaction content
@@ -356,7 +456,7 @@ class MarkdownFlow:
         # Basic validation
         if not user_input or not any(values for values in user_input.values()):
             error_msg = INPUT_EMPTY_ERROR
-            return self._render_error(error_msg, mode)
+            return self._render_error(error_msg, mode, context)
 
         # Get the target variable value from user_input
         target_values = user_input.get(target_variable, [])
@@ -370,24 +470,99 @@ class MarkdownFlow:
 
         if "error" in parse_result:
             error_msg = INTERACTION_PARSE_ERROR.format(error=parse_result["error"])
-            return self._render_error(error_msg, mode)
+            return self._render_error(error_msg, mode, context)
 
         interaction_type = parse_result.get("type")
 
         # Process user input based on interaction type
         if interaction_type in [
-            InteractionType.BUTTONS_ONLY,
             InteractionType.BUTTONS_WITH_TEXT,
-            InteractionType.BUTTONS_MULTI_SELECT,
             InteractionType.BUTTONS_MULTI_WITH_TEXT,
         ]:
-            # All button types: validate user input against available buttons
+            # Buttons with text input: smart validation (match buttons first, then LLM validate custom text)
+            buttons = parse_result.get("buttons", [])
+
+            # Step 1: Match button values
+            matched_values, unmatched_values = self._match_button_values(buttons, target_values)
+
+            # Step 2: If there are unmatched values (custom text), validate with LLM
+            if unmatched_values:
+                # Create user_input for LLM validation (only custom text)
+                custom_input = {target_variable: unmatched_values}
+
+                validation_result = self._process_llm_validation(
+                    block_index=block_index,
+                    user_input=custom_input,
+                    target_variable=target_variable,
+                    mode=mode,
+                    context=context,
+                )
+
+                # Handle validation result based on mode
+                if mode == ProcessMode.COMPLETE:
+                    # Check if validation passed
+                    if isinstance(validation_result, LLMResult) and validation_result.variables:
+                        validated_values = validation_result.variables.get(target_variable, [])
+                        # Merge matched button values + validated custom text
+                        all_values = matched_values + validated_values
+                        return LLMResult(
+                            content="",
+                            variables={target_variable: all_values},
+                            metadata={
+                                "interaction_type": str(interaction_type),
+                                "matched_button_values": matched_values,
+                                "validated_custom_values": validated_values,
+                            },
+                        )
+                    else:
+                        # Validation failed, return error
+                        return validation_result
+
+                if mode == ProcessMode.STREAM:
+                    # For stream mode, collect validation result
+                    def stream_merge_generator():
+                        # Consume the validation stream
+                        for result in validation_result:  # type: ignore[attr-defined]
+                            if isinstance(result, LLMResult) and result.variables:
+                                validated_values = result.variables.get(target_variable, [])
+                                all_values = matched_values + validated_values
+                                yield LLMResult(
+                                    content="",
+                                    variables={target_variable: all_values},
+                                    metadata={
+                                        "interaction_type": str(interaction_type),
+                                        "matched_button_values": matched_values,
+                                        "validated_custom_values": validated_values,
+                                    },
+                                )
+                            else:
+                                # Validation failed
+                                yield result
+
+                    return stream_merge_generator()
+            else:
+                # All values matched buttons, return directly
+                return LLMResult(
+                    content="",
+                    variables={target_variable: matched_values},
+                    metadata={
+                        "interaction_type": str(interaction_type),
+                        "all_matched_buttons": True,
+                    },
+                )
+
+        if interaction_type in [
+            InteractionType.BUTTONS_ONLY,
+            InteractionType.BUTTONS_MULTI_SELECT,
+        ]:
+            # Pure button types: only basic button validation (no LLM)
             return self._process_button_validation(
                 parse_result,
                 target_values,
                 target_variable,
                 mode,
                 interaction_type,
+                context,
             )
 
         if interaction_type == InteractionType.NON_ASSIGNMENT_BUTTON:
@@ -403,19 +578,50 @@ class MarkdownFlow:
             )
 
         # Text-only input type: ?[%{{sys_user_nickname}}...question]
-        # For text-only inputs, directly use the target variable values
+        # Use LLM validation to check if input is relevant to the question
         if target_values:
-            return LLMResult(
-                content="",
-                variables={target_variable: target_values},
-                metadata={
-                    "interaction_type": "text_only",
-                    "target_variable": target_variable,
-                    "values": target_values,
-                },
+            return self._process_llm_validation(
+                block_index=block_index,
+                user_input=user_input,
+                target_variable=target_variable,
+                mode=mode,
+                context=context,
             )
         error_msg = f"No input provided for variable '{target_variable}'"
-        return self._render_error(error_msg, mode)
+        return self._render_error(error_msg, mode, context)
+
+    def _match_button_values(
+        self,
+        buttons: list[dict[str, str]],
+        target_values: list[str],
+    ) -> tuple[list[str], list[str]]:
+        """
+        Match user input values against button options.
+
+        Args:
+            buttons: List of button dictionaries with 'display' and 'value' keys
+            target_values: User input values to match
+
+        Returns:
+            Tuple of (matched_values, unmatched_values)
+            - matched_values: Values that match button options (using button value)
+            - unmatched_values: Values that don't match any button
+        """
+        matched_values = []
+        unmatched_values = []
+
+        for value in target_values:
+            matched = False
+            for button in buttons:
+                if value in [button["display"], button["value"]]:
+                    matched_values.append(button["value"])  # Use button value
+                    matched = True
+                    break
+
+            if not matched:
+                unmatched_values.append(value)
+
+        return matched_values, unmatched_values
 
     def _process_button_validation(
         self,
@@ -424,6 +630,7 @@ class MarkdownFlow:
         target_variable: str,
         mode: ProcessMode,
         interaction_type: InteractionType,
+        context: list[dict[str, str]] | None = None,
     ) -> LLMResult | Generator[LLMResult, None, None]:
         """
         Simplified button validation with new input format.
@@ -434,6 +641,7 @@ class MarkdownFlow:
             target_variable: Target variable name
             mode: Processing mode
             interaction_type: Type of interaction
+            context: Conversation history context (optional)
         """
         buttons = parse_result.get("buttons", [])
         is_multi_select = interaction_type in [
@@ -459,7 +667,7 @@ class MarkdownFlow:
             # Pure button mode requires input
             button_displays = [btn["display"] for btn in buttons]
             error_msg = f"Please select from: {', '.join(button_displays)}"
-            return self._render_error(error_msg, mode)
+            return self._render_error(error_msg, mode, context)
 
         # Validate input values against available buttons
         valid_values = []
@@ -484,7 +692,7 @@ class MarkdownFlow:
         if invalid_values and not allow_text_input:
             button_displays = [btn["display"] for btn in buttons]
             error_msg = f"Invalid options: {', '.join(invalid_values)}. Please select from: {', '.join(button_displays)}"
-            return self._render_error(error_msg, mode)
+            return self._render_error(error_msg, mode, context)
 
         # Success: return validated values
         return LLMResult(
@@ -505,26 +713,18 @@ class MarkdownFlow:
         user_input: dict[str, list[str]],
         target_variable: str,
         mode: ProcessMode,
+        context: list[dict[str, str]] | None = None,
     ) -> LLMResult | Generator[LLMResult, None, None]:
         """Process LLM validation."""
         # Build validation messages
-        messages = self._build_validation_messages(block_index, user_input, target_variable)
-
-        if mode == ProcessMode.PROMPT_ONLY:
-            return LLMResult(
-                prompt=messages[-1]["content"],
-                metadata={
-                    "validation_target": user_input,
-                    "target_variable": target_variable,
-                },
-            )
+        messages = self._build_validation_messages(block_index, user_input, target_variable, context)
 
         if mode == ProcessMode.COMPLETE:
             if not self._llm_provider:
                 # Fallback processing, return variables directly
                 return LLMResult(content="", variables=user_input)  # type: ignore[arg-type]
 
-            llm_response = self._llm_provider.complete(messages)
+            llm_response = self._llm_provider.complete(messages, model=self._model, temperature=self._temperature)
 
             # Parse validation response and convert to LLMResult
             # Use joined target values for fallback; avoids JSON string injection
@@ -538,7 +738,7 @@ class MarkdownFlow:
 
             def stream_generator():
                 full_response = ""
-                for chunk in self._llm_provider.stream(messages):  # type: ignore[attr-defined]
+                for chunk in self._llm_provider.stream(messages, model=self._model, temperature=self._temperature):  # type: ignore[attr-defined]
                     full_response += chunk
 
                 # Parse complete response and convert to LLMResult
@@ -565,23 +765,12 @@ class MarkdownFlow:
         # Build special validation messages containing button option information
         messages = self._build_validation_messages_with_options(user_input, target_variable, options, question)
 
-        if mode == ProcessMode.PROMPT_ONLY:
-            return LLMResult(
-                prompt=messages[-1]["content"],
-                metadata={
-                    "validation_target": user_input,
-                    "target_variable": target_variable,
-                    "options": options,
-                    "question": question,
-                },
-            )
-
         if mode == ProcessMode.COMPLETE:
             if not self._llm_provider:
                 # Fallback processing, return variables directly
                 return LLMResult(content="", variables=user_input)  # type: ignore[arg-type]
 
-            llm_response = self._llm_provider.complete(messages)
+            llm_response = self._llm_provider.complete(messages, model=self._model, temperature=self._temperature)
 
             # Parse validation response and convert to LLMResult
             # Use joined target values for fallback; avoids JSON string injection
@@ -595,7 +784,7 @@ class MarkdownFlow:
 
             def stream_generator():
                 full_response = ""
-                for chunk in self._llm_provider.stream(messages):  # type: ignore[attr-defined]
+                for chunk in self._llm_provider.stream(messages, model=self._model, temperature=self._temperature):  # type: ignore[attr-defined]
                     full_response += chunk
                     # For validation scenario, don't output chunks in real-time, only final result
 
@@ -612,21 +801,24 @@ class MarkdownFlow:
 
             return stream_generator()
 
-    def _render_error(self, error_message: str, mode: ProcessMode) -> LLMResult | Generator[LLMResult, None, None]:
+    def _render_error(
+        self,
+        error_message: str,
+        mode: ProcessMode,
+        context: list[dict[str, str]] | None = None,
+    ) -> LLMResult | Generator[LLMResult, None, None]:
         """Render user-friendly error message."""
-        messages = self._build_error_render_messages(error_message)
+        # Truncate context to configured maximum length
+        truncated_context = self._truncate_context(context)
 
-        if mode == ProcessMode.PROMPT_ONLY:
-            return LLMResult(
-                prompt=messages[-1]["content"],
-                metadata={"original_error": error_message},
-            )
+        # Build error messages with context
+        messages = self._build_error_render_messages(error_message, truncated_context)
 
         if mode == ProcessMode.COMPLETE:
             if not self._llm_provider:
                 return LLMResult(content=error_message)  # Fallback processing
 
-            friendly_error = self._llm_provider.complete(messages)
+            friendly_error = self._llm_provider.complete(messages, model=self._model, temperature=self._temperature)
             return LLMResult(content=friendly_error, prompt=messages[-1]["content"])
 
         if mode == ProcessMode.STREAM:
@@ -634,7 +826,7 @@ class MarkdownFlow:
                 return LLMResult(content=error_message)
 
             def stream_generator():
-                for chunk in self._llm_provider.stream(messages):  # type: ignore[attr-defined]
+                for chunk in self._llm_provider.stream(messages, model=self._model, temperature=self._temperature):  # type: ignore[attr-defined]
                     yield LLMResult(content=chunk, prompt=messages[-1]["content"])
 
             return stream_generator()
@@ -645,6 +837,7 @@ class MarkdownFlow:
         self,
         block_index: int,
         variables: dict[str, str | list[str]] | None,
+        context: list[dict[str, str]] | None = None,
     ) -> list[dict[str, str]]:
         """Build content block messages."""
         block = self.get_block(block_index)
@@ -660,29 +853,43 @@ class MarkdownFlow:
         # Build message array
         messages = []
 
-        # Conditionally add system prompts
+        # Build system message with XML tags
+        system_parts = []
+
+        # 1. Base system prompt (if exists and non-empty)
+        if self._base_system_prompt:
+            system_parts.append(f"<base_system>\n{self._base_system_prompt}\n</base_system>")
+
+        # 2. Document prompt (if exists and non-empty)
         if self._document_prompt:
-            system_msg = self._document_prompt
-            # Only add output instruction explanation when preserved content detected
-            if has_preserved_content:
-                system_msg += "\n\n" + OUTPUT_INSTRUCTION_EXPLANATION.strip()
+            system_parts.append(f"<document_prompt>\n{self._document_prompt}\n</document_prompt>")
+
+        # 3. Output instruction (if preserved content exists)
+        # Note: OUTPUT_INSTRUCTION_EXPLANATION already contains <preserve_or_translate_instruction> tags
+        if has_preserved_content:
+            system_parts.append(OUTPUT_INSTRUCTION_EXPLANATION.strip())
+
+        # Combine all parts and add as system message
+        if system_parts:
+            system_msg = "\n\n".join(system_parts)
             messages.append({"role": "system", "content": system_msg})
-        elif has_preserved_content:
-            # No document prompt but has preserved content, add explanation alone
-            messages.append({"role": "system", "content": OUTPUT_INSTRUCTION_EXPLANATION.strip()})
 
-        # For most content blocks, historical conversation context is not needed
-        # because each document block is an independent instruction
-        # If future specific scenarios need context, logic can be added here
-        # if context:
-        #     messages.extend(context)
+        # Add conversation history context if provided
+        # Context is inserted after system message and before current user message
+        truncated_context = self._truncate_context(context)
+        if truncated_context:
+            messages.extend(truncated_context)
 
         # Add processed content as user message (as instruction to LLM)
         messages.append({"role": "user", "content": block_content})
 
         return messages
 
-    def _build_interaction_render_messages(self, question_text: str) -> list[dict[str, str]]:
+    def _build_interaction_render_messages(
+        self,
+        question_text: str,
+        context: list[dict[str, str]] | None = None,
+    ) -> list[dict[str, str]]:
         """Build interaction rendering messages."""
         # Check if using custom interaction prompt
         if self._interaction_prompt != DEFAULT_INTERACTION_PROMPT:
@@ -696,15 +903,32 @@ class MarkdownFlow:
         messages = []
 
         messages.append({"role": "system", "content": render_prompt})
+
+        # NOTE: Context is temporarily disabled for interaction rendering
+        # Mixing conversation history with interaction content rewriting can cause issues
+        # The context parameter is kept in the signature for future use
+        # truncated_context = self._truncate_context(context)
+        # if truncated_context:
+        #     messages.extend(truncated_context)
+
         messages.append({"role": "user", "content": question_text})
 
         return messages
 
-    def _build_validation_messages(self, block_index: int, user_input: dict[str, list[str]], target_variable: str) -> list[dict[str, str]]:
+    def _build_validation_messages(
+        self,
+        block_index: int,
+        user_input: dict[str, list[str]],
+        target_variable: str,
+        context: list[dict[str, str]] | None = None,
+    ) -> list[dict[str, str]]:
         """Build validation messages."""
         block = self.get_block(block_index)
         config = self.get_interaction_validation_config(block_index)
 
+        # Truncate context to configured maximum length
+        truncated_context = self._truncate_context(context)
+
         if config and config.validation_template:
             # Use custom validation template
             validation_prompt = config.validation_template
@@ -715,7 +939,8 @@ class MarkdownFlow:
             system_message = DEFAULT_VALIDATION_SYSTEM_MESSAGE
         else:
             # Use smart default validation template
-            from .utils import (
+            from .parser import (
+                InteractionParser,
                 extract_interaction_question,
                 generate_smart_validation_template,
             )
@@ -723,11 +948,17 @@ class MarkdownFlow:
             # Extract interaction question
             interaction_question = extract_interaction_question(block.content)
 
-            # Generate smart validation template
+            # Parse interaction to extract button information
+            parser = InteractionParser()
+            parse_result = parser.parse(block.content)
+            buttons = parse_result.get("buttons") if "buttons" in parse_result else None
+
+            # Generate smart validation template with context and buttons
             validation_template = generate_smart_validation_template(
                 target_variable,
-                context=None,  # Could consider passing context here
+                context=truncated_context,
                 interaction_question=interaction_question,
+                buttons=buttons,
             )
 
             # Replace template variables
@@ -740,6 +971,11 @@ class MarkdownFlow:
         messages = []
 
         messages.append({"role": "system", "content": system_message})
+
+        # Add conversation history context if provided (only if not using custom template)
+        if truncated_context and not (config and config.validation_template):
+            messages.extend(truncated_context)
+
         messages.append({"role": "user", "content": validation_prompt})
 
         return messages
@@ -770,7 +1006,11 @@ class MarkdownFlow:
 
         return messages
 
-    def _build_error_render_messages(self, error_message: str) -> list[dict[str, str]]:
+    def _build_error_render_messages(
+        self,
+        error_message: str,
+        context: list[dict[str, str]] | None = None,
+    ) -> list[dict[str, str]]:
         """Build error rendering messages."""
         render_prompt = f"""{self._interaction_error_prompt}
 
@@ -783,6 +1023,12 @@ Original Error: {error_message}
             messages.append({"role": "system", "content": self._document_prompt})
 
         messages.append({"role": "system", "content": render_prompt})
+
+        # Add conversation history context if provided
+        truncated_context = self._truncate_context(context)
+        if truncated_context:
+            messages.extend(truncated_context)
+
         messages.append({"role": "user", "content": error_message})
 
         return messages