markdown-flow 0.2.6__py3-none-any.whl → 0.2.8__py3-none-any.whl

markdown_flow/__init__.py

@@ -83,4 +83,4 @@ __all__ = [
     "replace_variables_in_text",
 ]
 
-__version__ = "0.2.6"
+__version__ = "0.2.8"

markdown_flow/core.py

@@ -6,7 +6,7 @@ Refactored MarkdownFlow class with built-in LLM processing capabilities and unif
 
 import json
 import re
-from collections.abc import AsyncGenerator
+from collections.abc import Generator
 from copy import copy
 from typing import Any
 
@@ -69,7 +69,6 @@ class MarkdownFlow:
         document_prompt: str | None = None,
         interaction_prompt: str | None = None,
         interaction_error_prompt: str | None = None,
-        enable_dynamic_interaction: bool = False,
     ):
         """
         Initialize MarkdownFlow instance.
@@ -80,14 +79,12 @@ class MarkdownFlow:
             document_prompt: Document-level system prompt
             interaction_prompt: Interaction content rendering prompt
             interaction_error_prompt: Interaction error rendering prompt
-            enable_dynamic_interaction: Enable dynamic content to interaction conversion
         """
         self._document = document
         self._llm_provider = llm_provider
         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._enable_dynamic_interaction = enable_dynamic_interaction
         self._blocks = None
         self._interaction_configs: dict[int, InteractionValidationConfig] = {}
 
@@ -179,7 +176,7 @@ class MarkdownFlow:
 
     # Core unified interface
 
-    async def process(
+    def process(
         self,
         block_index: int,
         mode: ProcessMode = ProcessMode.COMPLETE,
@@ -187,7 +184,7 @@ class MarkdownFlow:
         variables: dict[str, str | list[str]] | None = None,
         user_input: dict[str, list[str]] | None = None,
         dynamic_interaction_format: str | None = None,
-    ) -> LLMResult | AsyncGenerator[LLMResult, None]:
+    ) -> LLMResult | Generator[LLMResult, None, None]:
         """
         Unified block processing interface.
 
@@ -200,7 +197,7 @@ class MarkdownFlow:
             dynamic_interaction_format: Dynamic interaction format for validation
 
         Returns:
-            LLMResult or AsyncGenerator[LLMResult, None]
+            LLMResult or Generator[LLMResult, None, None]
         """
         # Process document_prompt variable replacement
         if self._document_prompt:
@@ -211,65 +208,68 @@ class MarkdownFlow:
         if block.block_type == BlockType.CONTENT:
             # Check if this is dynamic interaction validation
             if dynamic_interaction_format and user_input:
-                return await self._process_dynamic_interaction_validation(
-                    block_index, dynamic_interaction_format, user_input, mode, context, variables
-                )
+                return self._process_dynamic_interaction_validation(block_index, dynamic_interaction_format, user_input, mode, context, variables)
             # Normal content processing (possibly with dynamic conversion)
-            return await self._process_content(block_index, mode, context, variables)
+            return self._process_content(block_index, mode, context, variables)
 
         if block.block_type == BlockType.INTERACTION:
             if user_input is None:
                 # Render interaction content
-                return await self._process_interaction_render(block_index, mode, variables)
+                return self._process_interaction_render(block_index, mode, variables)
             # Process user input
-            return await self._process_interaction_input(block_index, user_input, mode, context, variables)
+            return self._process_interaction_input(block_index, user_input, mode, context, variables)
 
         if block.block_type == BlockType.PRESERVED_CONTENT:
             # Preserved content output as-is, no LLM call
-            return await self._process_preserved_content(block_index, variables)
+            return self._process_preserved_content(block_index, variables)
 
         # Handle other types as content
-        return await self._process_content(block_index, mode, context, variables)
+        return self._process_content(block_index, mode, context, variables)
 
     # Internal processing methods
 
-    async def _process_content(
+    def _process_content(
         self,
         block_index: int,
         mode: ProcessMode,
         context: list[dict[str, str]] | None,
         variables: dict[str, str | list[str]] | None,
-    ) -> LLMResult | AsyncGenerator[LLMResult, None]:
+    ) -> LLMResult | Generator[LLMResult, None, None]:
         """Process content block."""
 
-        # Check if dynamic interaction is enabled and should be attempted
-        if self._enable_dynamic_interaction and mode != ProcessMode.PROMPT_ONLY:
-            return await self._process_with_dynamic_check(block_index, mode, context, variables)
-
-        # Original logic: Build messages
-        messages = self._build_content_messages(block_index, variables)
-
+        # For PROMPT_ONLY mode, use standard content processing
         if mode == ProcessMode.PROMPT_ONLY:
+            messages = self._build_content_messages(block_index, variables)
             return LLMResult(prompt=messages[-1]["content"], metadata={"messages": messages})
 
+        # For COMPLETE and STREAM modes with LLM provider, use dynamic interaction check
+        # LLM will decide whether content needs to be converted to interaction block
+        if self._llm_provider:
+            block = self.get_block(block_index)
+            if block.block_type == BlockType.CONTENT:
+                return self._process_with_dynamic_check(block_index, mode, context, variables)
+
+        # Fallback: Build messages using standard content processing
+        messages = self._build_content_messages(block_index, variables)
+
         if mode == ProcessMode.COMPLETE:
             if not self._llm_provider:
                 raise ValueError(LLM_PROVIDER_REQUIRED_ERROR)
 
-            result = await self._llm_provider.complete(messages)
+            result = self._llm_provider.complete(messages)
             return LLMResult(content=result.content, prompt=messages[-1]["content"], metadata=result.metadata)
 
         if mode == ProcessMode.STREAM:
             if not self._llm_provider:
                 raise ValueError(LLM_PROVIDER_REQUIRED_ERROR)
 
-            async def stream_generator():
-                async for chunk in self._llm_provider.stream(messages):  # type: ignore[attr-defined]
+            def stream_generator():
+                for chunk in self._llm_provider.stream(messages):
                     yield LLMResult(content=chunk, prompt=messages[-1]["content"])
 
             return stream_generator()
 
-    async def _process_preserved_content(self, block_index: int, variables: dict[str, str | list[str]] | None) -> LLMResult:
+    def _process_preserved_content(self, block_index: int, variables: dict[str, str | list[str]] | None) -> LLMResult:
         """Process preserved content block, output as-is without LLM call."""
         block = self.get_block(block_index)
 
@@ -281,7 +281,7 @@ class MarkdownFlow:
 
         return LLMResult(content=content)
 
-    async def _process_interaction_render(self, block_index: int, mode: ProcessMode, variables: dict[str, str | list[str]] | None = None) -> LLMResult | AsyncGenerator[LLMResult, None]:
+    def _process_interaction_render(self, block_index: int, mode: ProcessMode, variables: dict[str, str | list[str]] | None = None) -> LLMResult | Generator[LLMResult, None, None]:
         """Process interaction content rendering."""
         block = self.get_block(block_index)
 
@@ -314,7 +314,7 @@ class MarkdownFlow:
             if not self._llm_provider:
                 return LLMResult(content=processed_block.content)  # Fallback processing
 
-            result = await self._llm_provider.complete(messages)
+            result = self._llm_provider.complete(messages)
             rendered_question = result.content
             rendered_content = self._reconstruct_interaction_content(processed_block.content, rendered_question)
 
@@ -332,7 +332,7 @@ class MarkdownFlow:
                 # For interaction blocks, return reconstructed content (one-time output)
                 rendered_content = self._reconstruct_interaction_content(processed_block.content, question_text or "")
 
-                async def stream_generator():
+                def stream_generator():
                     yield LLMResult(
                         content=rendered_content,
                         prompt=messages[-1]["content"],
@@ -341,9 +341,9 @@ class MarkdownFlow:
                 return stream_generator()
 
             # With LLM provider, collect full response then return once
-            async def stream_generator():
+            def stream_generator():
                 full_response = ""
-                async for chunk in self._llm_provider.stream(messages):  # type: ignore[attr-defined]
+                for chunk in self._llm_provider.stream(messages):
                     full_response += chunk
 
                 # Reconstruct final interaction content
@@ -357,22 +357,23 @@ class MarkdownFlow:
 
             return stream_generator()
 
-    async def _process_interaction_input(
+    def _process_interaction_input(
         self,
         block_index: int,
         user_input: dict[str, list[str]],
         mode: ProcessMode,
         context: list[dict[str, str]] | None,
         variables: dict[str, str | list[str]] | None = None,
-    ) -> LLMResult | AsyncGenerator[LLMResult, None]:
+    ) -> LLMResult | Generator[LLMResult, None, None]:
         """Process interaction user input."""
+        _ = context  # Mark as intentionally unused
         block = self.get_block(block_index)
         target_variable = block.variables[0] if block.variables else "user_input"
 
         # Basic validation
         if not user_input or not any(values for values in user_input.values()):
             error_msg = INPUT_EMPTY_ERROR
-            return await self._render_error(error_msg, mode)
+            return self._render_error(error_msg, mode)
 
         # Get the target variable value from user_input
         target_values = user_input.get(target_variable, [])
@@ -386,7 +387,7 @@ class MarkdownFlow:
 
         if "error" in parse_result:
             error_msg = INTERACTION_PARSE_ERROR.format(error=parse_result["error"])
-            return await self._render_error(error_msg, mode)
+            return self._render_error(error_msg, mode)
 
         interaction_type = parse_result.get("type")
 
@@ -398,7 +399,7 @@ class MarkdownFlow:
             InteractionType.BUTTONS_MULTI_WITH_TEXT,
         ]:
             # All button types: validate user input against available buttons
-            return await self._process_button_validation(
+            return self._process_button_validation(
                 parse_result,
                 target_values,
                 target_variable,
@@ -431,16 +432,16 @@ class MarkdownFlow:
                 },
             )
         error_msg = f"No input provided for variable '{target_variable}'"
-        return await self._render_error(error_msg, mode)
+        return self._render_error(error_msg, mode)
 
-    async def _process_button_validation(
+    def _process_button_validation(
         self,
         parse_result: dict[str, Any],
         target_values: list[str],
         target_variable: str,
         mode: ProcessMode,
         interaction_type: InteractionType,
-    ) -> LLMResult | AsyncGenerator[LLMResult, None]:
+    ) -> LLMResult | Generator[LLMResult, None, None]:
         """
         Simplified button validation with new input format.
 
@@ -475,7 +476,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 await self._render_error(error_msg, mode)
+            return self._render_error(error_msg, mode)
 
         # Validate input values against available buttons
         valid_values = []
@@ -500,7 +501,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 await self._render_error(error_msg, mode)
+            return self._render_error(error_msg, mode)
 
         # Success: return validated values
         return LLMResult(
@@ -515,13 +516,13 @@ class MarkdownFlow:
             },
         )
 
-    async def _process_llm_validation(
+    def _process_llm_validation(
         self,
         block_index: int,
         user_input: dict[str, list[str]],
         target_variable: str,
         mode: ProcessMode,
-    ) -> LLMResult | AsyncGenerator[LLMResult, None]:
+    ) -> LLMResult | Generator[LLMResult, None, None]:
         """Process LLM validation."""
         # Build validation messages
         messages = self._build_validation_messages(block_index, user_input, target_variable)
@@ -540,7 +541,7 @@ class MarkdownFlow:
                 # Fallback processing, return variables directly
                 return LLMResult(content="", variables=user_input)  # type: ignore[arg-type]
 
-            result = await self._llm_provider.complete(messages)
+            result = self._llm_provider.complete(messages)
             llm_response = result.content
 
             # Parse validation response and convert to LLMResult
@@ -553,9 +554,9 @@ class MarkdownFlow:
             if not self._llm_provider:
                 return LLMResult(content="", variables=user_input)  # type: ignore[arg-type]
 
-            async def stream_generator():
+            def stream_generator():
                 full_response = ""
-                async for chunk in self._llm_provider.stream(messages):  # type: ignore[attr-defined]
+                for chunk in self._llm_provider.stream(messages):
                     full_response += chunk
 
                 # Parse complete response and convert to LLMResult
@@ -569,7 +570,7 @@ class MarkdownFlow:
 
             return stream_generator()
 
-    async def _process_llm_validation_with_options(
+    def _process_llm_validation_with_options(
         self,
         block_index: int,
         user_input: dict[str, list[str]],
@@ -577,8 +578,9 @@ class MarkdownFlow:
         options: list[str],
         question: str,
         mode: ProcessMode,
-    ) -> LLMResult | AsyncGenerator[LLMResult, None]:
+    ) -> LLMResult | Generator[LLMResult, None, None]:
         """Process LLM validation with button options (third case)."""
+        _ = block_index  # Mark as intentionally unused
         # Build special validation messages containing button option information
         messages = self._build_validation_messages_with_options(user_input, target_variable, options, question)
 
@@ -598,7 +600,7 @@ class MarkdownFlow:
                 # Fallback processing, return variables directly
                 return LLMResult(content="", variables=user_input)  # type: ignore[arg-type]
 
-            result = await self._llm_provider.complete(messages)
+            result = self._llm_provider.complete(messages)
             llm_response = result.content
 
             # Parse validation response and convert to LLMResult
@@ -611,9 +613,9 @@ class MarkdownFlow:
             if not self._llm_provider:
                 return LLMResult(content="", variables=user_input)  # type: ignore[arg-type]
 
-            async def stream_generator():
+            def stream_generator():
                 full_response = ""
-                async for chunk in self._llm_provider.stream(messages):  # type: ignore[attr-defined]
+                for chunk in self._llm_provider.stream(messages):
                     full_response += chunk
                     # For validation scenario, don't output chunks in real-time, only final result
 
@@ -630,7 +632,7 @@ class MarkdownFlow:
 
             return stream_generator()
 
-    async def _render_error(self, error_message: str, mode: ProcessMode) -> LLMResult | AsyncGenerator[LLMResult, None]:
+    def _render_error(self, error_message: str, mode: ProcessMode) -> LLMResult | Generator[LLMResult, None, None]:
         """Render user-friendly error message."""
         messages = self._build_error_render_messages(error_message)
 
@@ -644,7 +646,7 @@ class MarkdownFlow:
             if not self._llm_provider:
                 return LLMResult(content=error_message)  # Fallback processing
 
-            result = await self._llm_provider.complete(messages)
+            result = self._llm_provider.complete(messages)
             friendly_error = result.content
             return LLMResult(content=friendly_error, prompt=messages[-1]["content"])
 
@@ -652,8 +654,8 @@ class MarkdownFlow:
             if not self._llm_provider:
                 return LLMResult(content=error_message)
 
-            async def stream_generator():
-                async for chunk in self._llm_provider.stream(messages):  # type: ignore[attr-defined]
+            def stream_generator():
+                for chunk in self._llm_provider.stream(messages):
                     yield LLMResult(content=chunk, prompt=messages[-1]["content"])
 
             return stream_generator()
@@ -818,64 +820,50 @@ Original Error: {error_message}
 
     # Dynamic Interaction Methods
 
-    async def _process_with_dynamic_check(
+    def _process_with_dynamic_check(
         self,
         block_index: int,
         mode: ProcessMode,
         context: list[dict[str, str]] | None,
         variables: dict[str, str | list[str]] | None,
-    ) -> LLMResult | AsyncGenerator[LLMResult, None]:
+    ) -> LLMResult | Generator[LLMResult, None, None]:
         """Process content with dynamic interaction detection and conversion."""
 
         block = self.get_block(block_index)
         messages = self._build_dynamic_check_messages(block, context, variables)
 
         # Define Function Calling tools with structured approach
-        tools = [{
-            "type": "function",
-            "function": {
-                "name": "create_interaction_block",
-                "description": "Convert content to interaction block with structured data when it needs to collect user input",
-                "parameters": {
-                    "type": "object",
-                    "properties": {
-                        "needs_interaction": {
-                            "type": "boolean",
-                            "description": "Whether this content needs to be converted to interaction block"
-                        },
-                        "variable_name": {
-                            "type": "string",
-                            "description": "Name of the variable to collect (without {{}} brackets)"
-                        },
-                        "interaction_type": {
-                            "type": "string",
-                            "enum": ["single_select", "multi_select", "text_input", "mixed"],
-                            "description": "Type of interaction: single_select (|), multi_select (||), text_input (...), mixed (options + text)"
+        tools = [
+            {
+                "type": "function",
+                "function": {
+                    "name": "create_interaction_block",
+                    "description": "Convert content to interaction block with structured data when it needs to collect user input",
+                    "parameters": {
+                        "type": "object",
+                        "properties": {
+                            "needs_interaction": {"type": "boolean", "description": "Whether this content needs to be converted to interaction block"},
+                            "variable_name": {"type": "string", "description": "Name of the variable to collect (without {{}} brackets)"},
+                            "interaction_type": {
+                                "type": "string",
+                                "enum": ["single_select", "multi_select", "text_input", "mixed"],
+                                "description": "Type of interaction: single_select (|), multi_select (||), text_input (...), mixed (options + text)",
+                            },
+                            "options": {"type": "array", "items": {"type": "string"}, "description": "List of selectable options (3-4 specific options based on context)"},
+                            "allow_text_input": {"type": "boolean", "description": "Whether to include a text input option for 'Other' cases"},
+                            "text_input_prompt": {"type": "string", "description": "Prompt text for the text input option (e.g., '其他请输入', 'Other, please specify')"},
                         },
-                        "options": {
-                            "type": "array",
-                            "items": {"type": "string"},
-                            "description": "List of selectable options (3-4 specific options based on context)"
-                        },
-                        "allow_text_input": {
-                            "type": "boolean",
-                            "description": "Whether to include a text input option for 'Other' cases"
-                        },
-                        "text_input_prompt": {
-                            "type": "string",
-                            "description": "Prompt text for the text input option (e.g., '其他请输入', 'Other, please specify')"
-                        }
+                        "required": ["needs_interaction"],
                     },
-                    "required": ["needs_interaction"]
-                }
+                },
             }
-        }]
+        ]
 
         if not self._llm_provider:
             raise ValueError(LLM_PROVIDER_REQUIRED_ERROR)
 
         # Call LLM with tools
-        result = await self._llm_provider.complete(messages, tools)
+        result = self._llm_provider.complete(messages, tools)
 
         # If interaction was generated through Function Calling, construct the MarkdownFlow format
         if result.transformed_to_interaction and result.metadata and "tool_args" in result.metadata:
@@ -889,15 +877,21 @@ Original Error: {error_message}
         if result.transformed_to_interaction:
             return result
 
-        # If not transformed, continue with normal processing
+        # If not transformed, continue with normal processing using standard content messages
+        normal_messages = self._build_content_messages(block_index, variables)
+
         if mode == ProcessMode.STREAM:
-            async def stream_wrapper():
-                async for chunk in self._llm_provider.stream(messages):
+
+            def stream_wrapper():
+                stream_generator = self._llm_provider.stream(normal_messages)
+                for chunk in stream_generator:
                     yield LLMResult(content=chunk)
+
             return stream_wrapper()
 
-        # Complete mode - already handled by complete_with_tools
-        return result
+        # Complete mode - use normal content processing
+        normal_result = self._llm_provider.complete(normal_messages)
+        return LLMResult(content=normal_result.content, prompt=normal_messages[-1]["content"], metadata=normal_result.metadata)
 
     def _build_dynamic_check_messages(
         self,
@@ -940,6 +934,7 @@ If conversion is needed, generate a STANDARD interaction block format with SPECI
         resolved_content = original_content
         if variables:
             from .utils import replace_variables_in_text
+
             resolved_content = replace_variables_in_text(original_content, variables)
 
         content_analysis = f"""Current content block to analyze:
@@ -956,6 +951,7 @@ If conversion is needed, generate a STANDARD interaction block format with SPECI
         # Add different analysis based on whether content has variables
         if "{{" in original_content and "}}" in original_content:
             from .utils import extract_variables_from_text
+
             content_variables = set(extract_variables_from_text(original_content))
 
             # Find new variables (not yet collected)
@@ -1015,9 +1011,7 @@ Analyze the content and provide the structured interaction data.""")
 
         user_prompt = "\n\n".join(user_prompt_parts)
 
-        messages = [
-            {"role": "system", "content": system_prompt}
-        ]
+        messages = [{"role": "system", "content": system_prompt}]
 
         # Add context if provided
         if context:
@@ -1063,7 +1057,7 @@ Analyze the content and provide the structured interaction data.""")
 
         return f"?[%{{{{{variable_name}}}}} {options_str}]"
 
-    async def _process_dynamic_interaction_validation(
+    def _process_dynamic_interaction_validation(
         self,
         block_index: int,
         interaction_format: str,
@@ -1072,47 +1066,102 @@ Analyze the content and provide the structured interaction data.""")
         context: list[dict[str, str]] | None,
         variables: dict[str, str | list[str]] | None,
     ) -> LLMResult:
-        """Validate user input for dynamically generated interaction blocks."""
+        """Validate user input for dynamically generated interaction blocks using same logic as normal interactions."""
+        _ = block_index  # Mark as intentionally unused
+        _ = context  # Mark as intentionally unused
 
         from .utils import InteractionParser
 
-        # Parse the interaction format
+        # Parse the interaction format using the same parser as normal interactions
         parser = InteractionParser()
-        interaction = parser.parse(interaction_format)
+        parse_result = parser.parse(interaction_format)
 
-        if interaction is None:
-            raise ValueError(f"Invalid interaction format: {interaction_format}")
+        if "error" in parse_result:
+            error_msg = f"Invalid interaction format: {parse_result['error']}"
+            return self._render_error(error_msg, mode)
 
-        # Extract variable name from the interaction format
-        # This is a simplified extraction - in real implementation you'd use the parser result
-        import re
-        var_match = re.search(r'%\{\{([^}]+)\}\}', interaction_format)
-        if not var_match:
-            raise ValueError(f"No variable found in interaction format: {interaction_format}")
+        # Extract variable name and interaction type
+        variable_name = parse_result.get("variable")
+        interaction_type = parse_result.get("type")
 
-        variable_name = var_match.group(1)
+        if not variable_name:
+            error_msg = f"No variable found in interaction format: {interaction_format}"
+            return self._render_error(error_msg, mode)
 
-        # Validate the user input
-        user_values = user_input.get(variable_name, [])
-        if not user_values:
-            raise ValueError(f"No input provided for variable: {variable_name}")
+        # Get user input for the target variable
+        target_values = user_input.get(variable_name, [])
 
-        # Process the validation result
-        updated_variables = dict(variables or {})
+        # Basic validation - check if input is provided when required
+        if not target_values:
+            # Check if this is a text input or allows empty input
+            allow_text_input = interaction_type in [
+                InteractionType.BUTTONS_WITH_TEXT,
+                InteractionType.BUTTONS_MULTI_WITH_TEXT,
+            ]
 
-        # Handle single vs multiple values
-        if len(user_values) == 1:
-            updated_variables[variable_name] = user_values[0]
-        else:
-            updated_variables[variable_name] = user_values
+            if allow_text_input:
+                # Allow empty input for buttons+text mode - merge with existing variables
+                merged_variables = dict(variables or {})
+                merged_variables[variable_name] = []
+                return LLMResult(
+                    content="",
+                    variables=merged_variables,
+                    metadata={
+                        "interaction_type": "dynamic_interaction",
+                        "empty_input": True,
+                    },
+                )
+            else:
+                error_msg = f"No input provided for variable '{variable_name}'"
+                return self._render_error(error_msg, mode)
 
-        # Return successful validation result
-        return LLMResult(
-            content=f"Successfully collected {variable_name}: {user_values}",
-            variables=updated_variables,
-            metadata={
-                "validation_success": True,
-                "variable_collected": variable_name,
-                "values_collected": user_values
-            }
-        )
+        # Use the same validation logic as normal interactions
+        if interaction_type in [
+            InteractionType.BUTTONS_ONLY,
+            InteractionType.BUTTONS_WITH_TEXT,
+            InteractionType.BUTTONS_MULTI_SELECT,
+            InteractionType.BUTTONS_MULTI_WITH_TEXT,
+        ]:
+            # Button validation - reuse the existing button validation logic
+            button_result = self._process_button_validation(
+                parse_result,
+                target_values,
+                variable_name,
+                mode,
+                interaction_type,
+            )
+
+            # Merge with existing variables for dynamic interactions
+            if hasattr(button_result, 'variables') and variables:
+                merged_variables = dict(variables)
+                merged_variables.update(button_result.variables)
+                return LLMResult(
+                    content=button_result.content,
+                    variables=merged_variables,
+                    metadata=button_result.metadata,
+                )
+            return button_result
+
+        elif interaction_type == InteractionType.NON_ASSIGNMENT_BUTTON:
+            # Non-assignment buttons: don't set variables, keep existing ones
+            return LLMResult(
+                content="",
+                variables=dict(variables or {}),
+                metadata={
+                    "interaction_type": "non_assignment_button",
+                    "user_input": user_input,
+                },
+            )
+        else:
+            # Text-only input type - merge with existing variables
+            merged_variables = dict(variables or {})
+            merged_variables[variable_name] = target_values
+            return LLMResult(
+                content="",
+                variables=merged_variables,
+                metadata={
+                    "interaction_type": "text_only",
+                    "target_variable": variable_name,
+                    "values": target_values,
+                },
+            )

markdown_flow/llm.py

@@ -5,7 +5,7 @@ Provides LLM provider interfaces and related data models, supporting multiple pr
 """
 
 from abc import ABC, abstractmethod
-from collections.abc import AsyncGenerator
+from collections.abc import AsyncGenerator, Generator
 from dataclasses import dataclass
 from enum import Enum
 from typing import Any
@@ -40,11 +40,7 @@ class LLMProvider(ABC):
     """Abstract LLM provider interface."""
 
     @abstractmethod
-    async def complete(
-        self,
-        messages: list[dict[str, str]],
-        tools: list[dict[str, Any]] | None = None
-    ) -> LLMResult:
+    def complete(self, messages: list[dict[str, str]], tools: list[dict[str, Any]] | None = None) -> LLMResult:
         """
         Non-streaming LLM call with optional function calling support.
 
@@ -60,7 +56,7 @@ class LLMProvider(ABC):
         """
 
     @abstractmethod
-    async def stream(self, messages: list[dict[str, str]]) -> AsyncGenerator[str, None]:
+    def stream(self, messages: list[dict[str, str]]) -> Generator[str, None, None]:
         """
         Streaming LLM call.
 
@@ -75,16 +71,11 @@ class LLMProvider(ABC):
         """
 
 
-
 class NoLLMProvider(LLMProvider):
     """Empty LLM provider for prompt-only scenarios."""
 
-    async def complete(
-        self,
-        messages: list[dict[str, str]],
-        tools: list[dict[str, Any]] | None = None
-    ) -> LLMResult:
+    def complete(self, messages: list[dict[str, str]], tools: list[dict[str, Any]] | None = None) -> LLMResult:
         raise NotImplementedError(NO_LLM_PROVIDER_ERROR)
 
-    async def stream(self, messages: list[dict[str, str]]) -> AsyncGenerator[str, None]:
+    def stream(self, messages: list[dict[str, str]]) -> Generator[str, None, None]:
         raise NotImplementedError(NO_LLM_PROVIDER_ERROR)

{markdown_flow-0.2.6.dist-info → markdown_flow-0.2.8.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: markdown-flow
-Version: 0.2.6
+Version: 0.2.8
 Summary: An agent library designed to parse and process MarkdownFlow documents
 Project-URL: Homepage, https://github.com/ai-shifu/markdown-flow-agent-py
 Project-URL: Bug Tracker, https://github.com/ai-shifu/markdown-flow-agent-py/issues
@@ -73,7 +73,7 @@ llm_provider = YourLLMProvider(api_key="your-key")
 mf = MarkdownFlow(document, llm_provider=llm_provider)
 
 # Process with different modes
-result = await mf.process(
+result = mf.process(
     block_index=0,
     mode=ProcessMode.COMPLETE,
     variables={'name': 'Alice', 'level': 'Intermediate'}
@@ -84,7 +84,7 @@ result = await mf.process(
 
 ```python
 # Stream processing for real-time responses
-async for chunk in mf.process(
+for chunk in mf.process(
     block_index=0,
     mode=ProcessMode.STREAM,
     variables={'name': 'Bob'}
@@ -92,6 +92,36 @@ async for chunk in mf.process(
     print(chunk.content, end='')
 ```
 
+### Dynamic Interaction Generation ✨
+
+Transform natural language content into interactive elements automatically:
+
+```python
+from markdown_flow import MarkdownFlow, ProcessMode
+
+# Dynamic interaction generation works automatically
+mf = MarkdownFlow(
+    document="询问用户的菜品偏好，并记录到变量{{菜品选择}}",
+    llm_provider=llm_provider,
+    document_prompt="你是中餐厅服务员，提供川菜、粤菜、鲁菜等选项"
+)
+
+# Process with Function Calling
+result = mf.process(0, ProcessMode.COMPLETE)
+
+if result.transformed_to_interaction:
+    print(f"Generated interaction: {result.content}")
+    # Output: ?[%{{菜品选择}} 宫保鸡丁||麻婆豆腐||水煮鱼||...其他菜品]
+
+# Continue with user input
+user_result = mf.process(
+    block_index=0,
+    mode=ProcessMode.COMPLETE,
+    user_input={"菜品选择": ["宫保鸡丁", "麻婆豆腐"]},
+    dynamic_interaction_format=result.content
+)
+```
+
 ### Interactive Elements
 
 ```python
@@ -122,13 +152,66 @@ user_input = {
     'skills': ['Python', 'JavaScript', 'Go']  # Multi-selection
 }
 
-result = await mf.process(
+result = mf.process(
     block_index=1,  # Process skills interaction
     user_input=user_input,
     mode=ProcessMode.COMPLETE
 )
 ```
 
+## ✨ Key Features
+
+### 🏗️ Three-Layer Architecture
+
+- **Document Level**: Parse `---` separators and `?[]` interaction patterns
+- **Block Level**: Categorize as CONTENT, INTERACTION, or PRESERVED_CONTENT
+- **Interaction Level**: Handle 6 different interaction types with smart validation
+
+### 🔄 Dynamic Interaction Generation
+
+- **Natural Language Input**: Write content in plain language
+- **AI-Powered Conversion**: LLM automatically detects interaction needs using Function Calling
+- **Structured Data Generation**: LLM returns structured data, core builds MarkdownFlow format
+- **Language Agnostic**: Support for any language with proper document prompts
+- **Context Awareness**: Both original and resolved variable contexts provided to LLM
+
+### 🤖 Unified LLM Integration
+
+- **Single Interface**: One `complete()` method for both regular and Function Calling modes
+- **Automatic Detection**: Tools parameter determines processing mode automatically
+- **Consistent Returns**: Always returns `LLMResult` with structured metadata
+- **Error Handling**: Automatic fallback from Function Calling to regular completion
+- **Provider Agnostic**: Abstract interface supports any LLM service
+
+### 📝 Variable System
+
+- **Replaceable Variables**: `{{variable}}` for content personalization
+- **Preserved Variables**: `%{{variable}}` for LLM understanding in interactions
+- **Multi-Value Support**: Handle both single values and arrays
+- **Smart Extraction**: Automatic detection from document content
+
+### 🎯 Interaction Types
+
+- **Text Input**: `?[%{{var}}...question]` - Free text entry
+- **Single Select**: `?[%{{var}} A|B|C]` - Choose one option
+- **Multi Select**: `?[%{{var}} A||B||C]` - Choose multiple options
+- **Mixed Mode**: `?[%{{var}} A||B||...custom]` - Predefined + custom input
+- **Display Buttons**: `?[Continue|Cancel]` - Action buttons without assignment
+- **Value Separation**: `?[%{{var}} Display//value|...]` - Different display/stored values
+
+### 🔒 Content Preservation
+
+- **Multiline Format**: `!===content!===` blocks output exactly as written
+- **Inline Format**: `===content===` for single-line preserved content
+- **Variable Support**: Preserved content can contain variables for substitution
+
+### ⚡ Performance Optimized
+
+- **Pre-compiled Regex**: All patterns compiled once for maximum performance
+- **Synchronous Interface**: Clean synchronous operations with optional streaming
+- **Stream Processing**: Real-time streaming responses supported
+- **Memory Efficient**: Lazy evaluation and generator patterns
+
 ## 📖 API Reference
 
 ### Core Classes
@@ -148,7 +231,7 @@ class MarkdownFlow:
     def get_all_blocks(self) -> List[Block]: ...
     def extract_variables(self) -> Set[str]: ...
 
-    async def process(
+    def process(
         self,
         block_index: int,
         mode: ProcessMode = ProcessMode.COMPLETE,
@@ -193,15 +276,15 @@ class ProcessMode(Enum):
 
 ```python
 # Generate prompt only
-prompt_result = await mf.process(0, ProcessMode.PROMPT_ONLY)
+prompt_result = mf.process(0, ProcessMode.PROMPT_ONLY)
 print(prompt_result.content)  # Raw prompt text
 
 # Complete response
-complete_result = await mf.process(0, ProcessMode.COMPLETE)
+complete_result = mf.process(0, ProcessMode.COMPLETE)
 print(complete_result.content)  # Full LLM response
 
 # Streaming response
-async for chunk in mf.process(0, ProcessMode.STREAM):
+for chunk in mf.process(0, ProcessMode.STREAM):
     print(chunk.content, end='')
 ```
 
@@ -211,14 +294,14 @@ Abstract base class for implementing LLM providers.
 
 ```python
 from abc import ABC, abstractmethod
-from typing import AsyncGenerator
+from typing import Generator
 
 class LLMProvider(ABC):
     @abstractmethod
-    async def complete(self, prompt: str) -> LLMResult: ...
+    def complete(self, prompt: str) -> LLMResult: ...
 
     @abstractmethod
-    async def stream(self, prompt: str) -> AsyncGenerator[str, None]: ...
+    def stream(self, prompt: str) -> Generator[str, None, None]: ...
 ```
 
 **Custom Implementation:**
@@ -226,23 +309,23 @@ class LLMProvider(ABC):
 ```python
 class OpenAIProvider(LLMProvider):
     def __init__(self, api_key: str):
-        self.client = openai.AsyncOpenAI(api_key=api_key)
+        self.client = openai.OpenAI(api_key=api_key)
 
-    async def complete(self, prompt: str) -> LLMResult:
-        response = await self.client.completions.create(
+    def complete(self, prompt: str) -> LLMResult:
+        response = self.client.completions.create(
             model="gpt-3.5-turbo",
             prompt=prompt,
             max_tokens=500
         )
         return LLMResult(content=response.choices[0].text.strip())
 
-    async def stream(self, prompt: str):
-        stream = await self.client.completions.create(
+    def stream(self, prompt: str):
+        stream = self.client.completions.create(
             model="gpt-3.5-turbo",
             prompt=prompt,
             stream=True
         )
-        async for chunk in stream:
+        for chunk in stream:
             if chunk.choices[0].text:
                 yield chunk.choices[0].text
 ```
@@ -402,7 +485,7 @@ The new version introduces multi-select interaction support with improvements to
 user_input = "Python"
 
 # Process interaction
-result = await mf.process(
+result = mf.process(
     block_index=1,
     user_input=user_input,
     mode=ProcessMode.COMPLETE
@@ -419,7 +502,7 @@ user_input = {
 }
 
 # Process interaction
-result = await mf.process(
+result = mf.process(
     block_index=1,
     user_input=user_input,
     mode=ProcessMode.COMPLETE
@@ -462,10 +545,10 @@ class CustomAPIProvider(LLMProvider):
     def __init__(self, base_url: str, api_key: str):
         self.base_url = base_url
         self.api_key = api_key
-        self.client = httpx.AsyncClient()
+        self.client = httpx.Client()
 
-    async def complete(self, prompt: str) -> LLMResult:
-        response = await self.client.post(
+    def complete(self, prompt: str) -> LLMResult:
+        response = self.client.post(
             f"{self.base_url}/complete",
             headers={"Authorization": f"Bearer {self.api_key}"},
             json={"prompt": prompt, "max_tokens": 1000}
@@ -473,14 +556,14 @@ class CustomAPIProvider(LLMProvider):
         data = response.json()
         return LLMResult(content=data["text"])
 
-    async def stream(self, prompt: str):
-        async with self.client.stream(
+    def stream(self, prompt: str):
+        with self.client.stream(
             "POST",
             f"{self.base_url}/stream",
             headers={"Authorization": f"Bearer {self.api_key}"},
             json={"prompt": prompt}
         ) as response:
-            async for chunk in response.aiter_text():
+            for chunk in response.iter_text():
                 if chunk.strip():
                     yield chunk
 
@@ -492,7 +575,7 @@ mf = MarkdownFlow(document, llm_provider=provider)
 ### Multi-Block Document Processing
 
 ```python
-async def process_conversation():
+def process_conversation():
     conversation = """
 # AI Assistant
 
@@ -529,7 +612,7 @@ Would you like to start with the basics?
     for i, block in enumerate(blocks):
         if block.block_type == BlockType.CONTENT:
             print(f"\n--- Processing Block {i} ---")
-            result = await mf.process(
+            result = mf.process(
                 block_index=i,
                 mode=ProcessMode.COMPLETE,
                 variables=variables
@@ -544,9 +627,8 @@ Would you like to start with the basics?
 
 ```python
 from markdown_flow import MarkdownFlow, ProcessMode
-import asyncio
 
-async def stream_with_progress():
+def stream_with_progress():
     document = """
 Generate a comprehensive Python tutorial for {{user_name}}
 focusing on {{topic}} with practical examples.
@@ -560,7 +642,7 @@ Include code samples, explanations, and practice exercises.
     content = ""
     chunk_count = 0
 
-    async for chunk in mf.process(
+    for chunk in mf.process(
         block_index=0,
         mode=ProcessMode.STREAM,
         variables={
@@ -599,13 +681,13 @@ class InteractiveDocumentBuilder:
         self.user_responses = {}
         self.current_block = 0
 
-    async def start_interaction(self):
+    def start_interaction(self):
         blocks = self.mf.get_all_blocks()
 
         for i, block in enumerate(blocks):
             if block.block_type == BlockType.CONTENT:
                 # Process content block with current variables
-                result = await self.mf.process(
+                result = self.mf.process(
                     block_index=i,
                     mode=ProcessMode.COMPLETE,
                     variables=self.user_responses
@@ -614,11 +696,11 @@ class InteractiveDocumentBuilder:
 
             elif block.block_type == BlockType.INTERACTION:
                 # Handle user interaction
-                response = await self.handle_interaction(block.content)
+                response = self.handle_interaction(block.content)
                 if response:
                     self.user_responses.update(response)
 
-    async def handle_interaction(self, interaction_content: str):
+    def handle_interaction(self, interaction_content: str):
         from markdown_flow.utils import InteractionParser
 
         interaction = InteractionParser.parse(interaction_content)
@@ -635,7 +717,7 @@ class InteractiveDocumentBuilder:
                 return {interaction.variable: selected}
             except (ValueError, IndexError):
                 print("Invalid choice")
-                return await self.handle_interaction(interaction_content)
+                return self.handle_interaction(interaction_content)
 
         elif interaction.name == "TEXT_ONLY":
             response = input(f"{interaction.question}: ")
@@ -657,7 +739,7 @@ Great choice, {{name}}! {{subject}} is an excellent field to study.
 """
 
 builder = InteractiveDocumentBuilder(template, your_llm_provider)
-await builder.start_interaction()
+builder.start_interaction()
 ```
 
 ### Variable System Deep Dive

markdown_flow-0.2.8.dist-info/RECORD

@@ -0,0 +1,13 @@
+markdown_flow/__init__.py,sha256=rx_PP6l0JOJ3CriXTjlMOycNclrIyvxbgHakpx37SxM,2874
+markdown_flow/constants.py,sha256=pd_KCpTEVlz_IXYekrByqb9VWCQR_XHXoGsFYdLW1Eg,8006
+markdown_flow/core.py,sha256=k_6cNDp3a0PSnWF3yOWmuIpFHRp7wTsPUcGbnMpw5bg,48548
+markdown_flow/enums.py,sha256=Wr41zt0Ce5b3fyLtOTE2erEVp1n92g9OVaBF_BZg_l8,820
+markdown_flow/exceptions.py,sha256=9sUZ-Jd3CPLdSRqG8Pw7eMm7cv_S3VZM6jmjUU8OhIc,976
+markdown_flow/llm.py,sha256=7DjOL2h2N1g0L4NF9kn0M5mR45ZL0vPsW3TzuOGy1bw,2547
+markdown_flow/models.py,sha256=ENcvXMVXwpFN-RzbeVHhXTjBN0bbmRpJ96K-XS2rizI,2893
+markdown_flow/utils.py,sha256=cVi0zDRK_rCMAr3EDhgITmx6Po5fSvYjqrprYaitYE0,28450
+markdown_flow-0.2.8.dist-info/licenses/LICENSE,sha256=qz3BziejhHPd1xa5eVtYEU5Qp6L2pn4otuj194uGxmc,1069
+markdown_flow-0.2.8.dist-info/METADATA,sha256=Yv38um7zSpnztRo60I1bVCsi3U6_XMcg-9WcVFILPg4,24286
+markdown_flow-0.2.8.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+markdown_flow-0.2.8.dist-info/top_level.txt,sha256=DpigGvQuIt2L0TTLnDU5sylhiTGiZS7MmAMa2hi-AJs,14
+markdown_flow-0.2.8.dist-info/RECORD,,

markdown_flow-0.2.6.dist-info/RECORD

@@ -1,13 +0,0 @@
-markdown_flow/__init__.py,sha256=BudzfDYsTYYeQnjQXA0WTe5AOHT73l8YMKqjJccL4l0,2874
-markdown_flow/constants.py,sha256=pd_KCpTEVlz_IXYekrByqb9VWCQR_XHXoGsFYdLW1Eg,8006
-markdown_flow/core.py,sha256=IctWJ8gbe90RhNOOzsWOlc7jJaYLexKtnZmbEgleqU0,46319
-markdown_flow/enums.py,sha256=Wr41zt0Ce5b3fyLtOTE2erEVp1n92g9OVaBF_BZg_l8,820
-markdown_flow/exceptions.py,sha256=9sUZ-Jd3CPLdSRqG8Pw7eMm7cv_S3VZM6jmjUU8OhIc,976
-markdown_flow/llm.py,sha256=7A2jy8wfVwLWieWVjV8ZTe6y0-1pYmLW0pyuenuci3s,2619
-markdown_flow/models.py,sha256=ENcvXMVXwpFN-RzbeVHhXTjBN0bbmRpJ96K-XS2rizI,2893
-markdown_flow/utils.py,sha256=cVi0zDRK_rCMAr3EDhgITmx6Po5fSvYjqrprYaitYE0,28450
-markdown_flow-0.2.6.dist-info/licenses/LICENSE,sha256=qz3BziejhHPd1xa5eVtYEU5Qp6L2pn4otuj194uGxmc,1069
-markdown_flow-0.2.6.dist-info/METADATA,sha256=gEvq6LxkTTtL-igF15HWMtaDgCu4nZNVW0IRJzxycd8,21009
-markdown_flow-0.2.6.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-markdown_flow-0.2.6.dist-info/top_level.txt,sha256=DpigGvQuIt2L0TTLnDU5sylhiTGiZS7MmAMa2hi-AJs,14
-markdown_flow-0.2.6.dist-info/RECORD,,