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

markdown_flow/__init__.py

@@ -32,12 +32,12 @@ Basic Usage:
     blocks = mf.get_all_blocks()
 
     # Process blocks using unified interface
-    result = await mf.process(0, variables={'name': 'John'}, mode=ProcessMode.COMPLETE)
+    result = mf.process(0, variables={'name': 'John'}, mode=ProcessMode.COMPLETE)
 
     # Different processing modes
-    prompt_result = await mf.process(0, mode=ProcessMode.PROMPT_ONLY)
-    complete_result = await mf.process(0, mode=ProcessMode.COMPLETE)
-    stream_result = await mf.process(0, mode=ProcessMode.STREAM)
+    prompt_result = mf.process(0, mode=ProcessMode.PROMPT_ONLY)
+    complete_result = mf.process(0, mode=ProcessMode.COMPLETE)
+    stream_result = mf.process(0, mode=ProcessMode.STREAM)
 
 Variable System:
     - {{variable}} - Regular variables, replaced with actual values
@@ -83,4 +83,4 @@ __all__ = [
     "replace_variables_in_text",
 ]
 
-__version__ = "0.2.16"
+__version__ = "0.2.18"

markdown_flow/constants.py

@@ -9,7 +9,7 @@ import re
 
 # Pre-compiled regex patterns
 COMPILED_PERCENT_VARIABLE_REGEX = re.compile(
-    r"%\{\{([\w]+)\}\}"  # Match %{{variable}} format for preserved variables
+    r"%\{\{([^}]+)\}\}"  # Match %{{variable}} format for preserved variables
 )
 
 # Interaction regex base patterns
@@ -20,11 +20,11 @@ INTERACTION_PATTERN_SPLIT = r"((?<!\\)\?\[[^\]]*\](?!\())"  # Pattern for re.spl
 # InteractionParser specific regex patterns
 COMPILED_INTERACTION_REGEX = re.compile(INTERACTION_PATTERN)  # Main interaction pattern matcher
 COMPILED_LAYER1_INTERACTION_REGEX = COMPILED_INTERACTION_REGEX  # Layer 1: Basic format validation (alias)
-COMPILED_LAYER2_VARIABLE_REGEX = re.compile(r"^%\{\{([\w]+)\}\}(.*)$")  # Layer 2: Variable detection
+COMPILED_LAYER2_VARIABLE_REGEX = re.compile(r"^%\{\{([^}]+)\}\}(.*)$")  # Layer 2: Variable detection
 COMPILED_LAYER3_ELLIPSIS_REGEX = re.compile(r"^(.*)\.\.\.(.*)")  # Layer 3: Split content around ellipsis
 COMPILED_LAYER3_BUTTON_VALUE_REGEX = re.compile(r"^(.+)//(.+)$")  # Layer 3: Parse Button//value format
 COMPILED_BRACE_VARIABLE_REGEX = re.compile(
-    r"(?<!%)\{\{([\w]+)\}\}"  # Match {{variable}} format for replaceable variables
+    r"(?<!%)\{\{([^}]+)\}\}"  # Match {{variable}} format for replaceable variables
 )
 COMPILED_INTERACTION_CONTENT_RECONSTRUCT_REGEX = re.compile(
     r"(\?\[[^]]*\.\.\.)([^]]*\])"  # Reconstruct interaction content: prefix + question + suffix
@@ -47,8 +47,8 @@ INLINE_PRESERVE_PATTERN = r"^===(.+)=== *$"
 COMPILED_INLINE_PRESERVE_REGEX = re.compile(INLINE_PRESERVE_PATTERN)
 
 # Output instruction markers
-OUTPUT_INSTRUCTION_PREFIX = "[输出]"
-OUTPUT_INSTRUCTION_SUFFIX = "[/输出]"
+OUTPUT_INSTRUCTION_PREFIX = "<preserve_or_translate>"
+OUTPUT_INSTRUCTION_SUFFIX = "</preserve_or_translate>"
 
 # System message templates
 DEFAULT_VALIDATION_SYSTEM_MESSAGE = "你是一个输入验证助手，需要严格按照指定的格式和规则处理用户输入。"
@@ -90,19 +90,44 @@ VALIDATION_RESPONSE_OK = "ok"
 VALIDATION_RESPONSE_ILLEGAL = "illegal"
 
 # Output instruction processing
-OUTPUT_INSTRUCTION_EXPLANATION = f"""请按照以下指令执行：
-
-当遇到{OUTPUT_INSTRUCTION_PREFIX}content{OUTPUT_INSTRUCTION_SUFFIX}这样的标签对时：
-1. **完全原样输出**中间的content内容，不要进行任何格式转换或修改
-2. 不要输出{OUTPUT_INSTRUCTION_PREFIX}和{OUTPUT_INSTRUCTION_SUFFIX}标签本身
-3. 即使content内容包含标题符号（如#）、特殊格式等，也要原样输出，不要转换成Markdown格式
-4. 保持content中的所有原始字符、空格、换行符等
-5. 然后继续执行后面的指令
-
-重要提醒：
-- {OUTPUT_INSTRUCTION_PREFIX}和{OUTPUT_INSTRUCTION_SUFFIX}只是指令标记，不要将这些标记作为内容输出
-- 标签内的内容必须原样输出，不要按照文档提示词的格式要求进行转换
-- 这是绝对的输出指令，优先级高于任何格式要求
+OUTPUT_INSTRUCTION_EXPLANATION = f"""<preserve_or_translate_instruction>
+对{OUTPUT_INSTRUCTION_PREFIX}{OUTPUT_INSTRUCTION_SUFFIX}标记之间的内容的处理规则:
+
+<default_behavior>
+默认行为: 完全保持原样输出
+- 标记之间的内容必须逐字原样输出
+- 严禁改写、润色、优化或调整任何表达方式
+- 严禁添加、删除或替换任何文字
+</default_behavior>
+
+<exception_rule>
+唯一例外: 语言翻译
+- 仅当内容需要从一种语言翻译成另一种语言时，才可以翻译
+- 翻译时必须保持原文的完整含义、语气和格式
+- 如果内容无需翻译，则绝对不允许做任何改动
+</exception_rule>
+
+<output_requirement>
+输出要求:
+- 不要输出{OUTPUT_INSTRUCTION_PREFIX}{OUTPUT_INSTRUCTION_SUFFIX}标记本身
+- 只输出标记之间的实际内容
+</output_requirement>
+
+<examples>
+示例1 - 保持原样:
+  <original_content>{OUTPUT_INSTRUCTION_PREFIX}**下面我们做个练习。**{OUTPUT_INSTRUCTION_SUFFIX}</original_content>
+  <resolved_content>**下面我们做个练习。**</resolved_content>
+
+示例2 - 语言翻译:
+  <original_content>{OUTPUT_INSTRUCTION_PREFIX}**Let's do an exercise.**{OUTPUT_INSTRUCTION_SUFFIX}</original_content>
+  <resolved_content>**让我们做个练习。**</resolved_content>
+
+示例3 - 错误示范(同语言改写):
+  <original_content>{OUTPUT_INSTRUCTION_PREFIX}**下面我们做个练习。**{OUTPUT_INSTRUCTION_SUFFIX}</original_content>
+  <wrong_output>**来，咱们做个有趣的小练习**</wrong_output>
+  <reason>错误: 擅自改写了中文内容</reason>
+</examples>
+</preserve_or_translate_instruction>
 
 """
 

markdown_flow/core.py

@@ -28,6 +28,7 @@ from .constants import (
     INTERACTION_PATTERN_SPLIT,
     INTERACTION_RENDER_INSTRUCTIONS,
     LLM_PROVIDER_REQUIRED_ERROR,
+    OUTPUT_INSTRUCTION_EXPLANATION,
     UNSUPPORTED_PROMPT_TYPE_ERROR,
 )
 from .enums import BlockType
@@ -183,8 +184,7 @@ class MarkdownFlow:
         context: list[dict[str, str]] | None = None,
         variables: dict[str, str | list[str]] | None = None,
         user_input: dict[str, list[str]] | None = None,
-        dynamic_interaction_format: str | None = None,
-    ) -> LLMResult | Generator[LLMResult, None, None]:
+    ):
         """
         Unified block processing interface.
 
@@ -194,7 +194,6 @@ class MarkdownFlow:
             context: Context message list
             variables: Variable mappings
             user_input: User input (for interaction blocks)
-            dynamic_interaction_format: Dynamic interaction format for validation
 
         Returns:
             LLMResult or Generator[LLMResult, None, None]
@@ -206,10 +205,6 @@ class MarkdownFlow:
         block = self.get_block(block_index)
 
         if block.block_type == BlockType.CONTENT:
-            # Check if this is dynamic interaction validation
-            if dynamic_interaction_format and user_input:
-                return self._process_dynamic_interaction_validation(block_index, dynamic_interaction_format, user_input, mode, context, variables)
-            # Normal content processing (possibly with dynamic conversion)
             return self._process_content(block_index, mode, context, variables)
 
         if block.block_type == BlockType.INTERACTION:
@@ -234,37 +229,27 @@ class MarkdownFlow:
         mode: ProcessMode,
         context: list[dict[str, str]] | None,
         variables: dict[str, str | list[str]] | None,
-    ) -> LLMResult | Generator[LLMResult, None, None]:
+    ):
         """Process content block."""
+        # 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 = self._llm_provider.complete(messages)
-            return LLMResult(content=result.content, prompt=messages[-1]["content"], metadata=result.metadata)
+            content = self._llm_provider.complete(messages)
+            return LLMResult(content=content, prompt=messages[-1]["content"])
 
         if mode == ProcessMode.STREAM:
             if not self._llm_provider:
                 raise ValueError(LLM_PROVIDER_REQUIRED_ERROR)
 
             def stream_generator():
-                for chunk in self._llm_provider.stream(messages):
+                for chunk in self._llm_provider.stream(messages):  # type: ignore[attr-defined]
                     yield LLMResult(content=chunk, prompt=messages[-1]["content"])
 
             return stream_generator()
@@ -281,7 +266,7 @@ class MarkdownFlow:
 
         return LLMResult(content=content)
 
-    def _process_interaction_render(self, block_index: int, mode: ProcessMode, variables: dict[str, str | list[str]] | None = None) -> LLMResult | Generator[LLMResult, None, None]:
+    def _process_interaction_render(self, block_index: int, mode: ProcessMode, variables: dict[str, str | list[str]] | None = None):
         """Process interaction content rendering."""
         block = self.get_block(block_index)
 
@@ -314,8 +299,7 @@ class MarkdownFlow:
             if not self._llm_provider:
                 return LLMResult(content=processed_block.content)  # Fallback processing
 
-            result = self._llm_provider.complete(messages)
-            rendered_question = result.content
+            rendered_question = self._llm_provider.complete(messages)
             rendered_content = self._reconstruct_interaction_content(processed_block.content, rendered_question)
 
             return LLMResult(
@@ -343,7 +327,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):
+                for chunk in self._llm_provider.stream(messages):  # type: ignore[attr-defined]
                     full_response += chunk
 
                 # Reconstruct final interaction content
@@ -366,7 +350,6 @@ class MarkdownFlow:
         variables: dict[str, str | list[str]] | None = 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"
 
@@ -478,7 +461,7 @@ class MarkdownFlow:
             error_msg = f"Please select from: {', '.join(button_displays)}"
             return self._render_error(error_msg, mode)
 
-        # First, check if user input matches available buttons
+        # Validate input values against available buttons
         valid_values = []
         invalid_values = []
 
@@ -491,30 +474,19 @@ class MarkdownFlow:
                     break
 
             if not matched:
-                invalid_values.append(value)
-
-        # If there are invalid values and this interaction allows text input, use LLM validation
-        if invalid_values and allow_text_input:
-            # Use LLM validation for text input interactions
-            button_displays = [btn["display"] for btn in buttons]
-            question = parse_result.get("question", "")
-
-            return self._process_llm_validation_with_options(
-                block_index=0,  # Not used in the method
-                user_input={target_variable: target_values},
-                target_variable=target_variable,
-                options=button_displays,
-                question=question,
-                mode=mode,
-            )
-
-        # Check for validation errors in pure button mode or when text input not allowed
-        if invalid_values:
+                if allow_text_input:
+                    # Allow custom text in buttons+text mode
+                    valid_values.append(value)
+                else:
+                    invalid_values.append(value)
+
+        # Check for validation errors
+        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)
 
-        # Success: return validated button values
+        # Success: return validated values
         return LLMResult(
             content="",
             variables={target_variable: valid_values},
@@ -524,7 +496,6 @@ class MarkdownFlow:
                 "valid_values": valid_values,
                 "invalid_values": invalid_values,
                 "total_input_count": len(target_values),
-                "llm_validated": False,
             },
         )
 
@@ -553,8 +524,7 @@ class MarkdownFlow:
                 # Fallback processing, return variables directly
                 return LLMResult(content="", variables=user_input)  # type: ignore[arg-type]
 
-            result = self._llm_provider.complete(messages)
-            llm_response = result.content
+            llm_response = self._llm_provider.complete(messages)
 
             # Parse validation response and convert to LLMResult
             # Use joined target values for fallback; avoids JSON string injection
@@ -568,7 +538,7 @@ class MarkdownFlow:
 
             def stream_generator():
                 full_response = ""
-                for chunk in self._llm_provider.stream(messages):
+                for chunk in self._llm_provider.stream(messages):  # type: ignore[attr-defined]
                     full_response += chunk
 
                 # Parse complete response and convert to LLMResult
@@ -592,7 +562,6 @@ class MarkdownFlow:
         mode: ProcessMode,
     ) -> 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)
 
@@ -612,8 +581,7 @@ class MarkdownFlow:
                 # Fallback processing, return variables directly
                 return LLMResult(content="", variables=user_input)  # type: ignore[arg-type]
 
-            result = self._llm_provider.complete(messages)
-            llm_response = result.content
+            llm_response = self._llm_provider.complete(messages)
 
             # Parse validation response and convert to LLMResult
             # Use joined target values for fallback; avoids JSON string injection
@@ -627,7 +595,7 @@ class MarkdownFlow:
 
             def stream_generator():
                 full_response = ""
-                for chunk in self._llm_provider.stream(messages):
+                for chunk in self._llm_provider.stream(messages):  # type: ignore[attr-defined]
                     full_response += chunk
                     # For validation scenario, don't output chunks in real-time, only final result
 
@@ -658,8 +626,7 @@ class MarkdownFlow:
             if not self._llm_provider:
                 return LLMResult(content=error_message)  # Fallback processing
 
-            result = self._llm_provider.complete(messages)
-            friendly_error = result.content
+            friendly_error = self._llm_provider.complete(messages)
             return LLMResult(content=friendly_error, prompt=messages[-1]["content"])
 
         if mode == ProcessMode.STREAM:
@@ -667,7 +634,7 @@ class MarkdownFlow:
                 return LLMResult(content=error_message)
 
             def stream_generator():
-                for chunk in self._llm_provider.stream(messages):
+                for chunk in self._llm_provider.stream(messages):  # type: ignore[attr-defined]
                     yield LLMResult(content=chunk, prompt=messages[-1]["content"])
 
             return stream_generator()
@@ -683,8 +650,9 @@ class MarkdownFlow:
         block = self.get_block(block_index)
         block_content = block.content
 
-        # Process output instructions
-        block_content = process_output_instructions(block_content)
+        # Process output instructions and detect if preserved content exists
+        # Returns: (processed_content, has_preserved_content)
+        block_content, has_preserved_content = process_output_instructions(block_content)
 
         # Replace variables
         block_content = replace_variables_in_text(block_content, variables or {})
@@ -692,9 +660,16 @@ class MarkdownFlow:
         # Build message array
         messages = []
 
-        # Add document prompt
+        # Conditionally add system prompts
         if self._document_prompt:
-            messages.append({"role": "system", "content": 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()
+            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
@@ -827,411 +802,5 @@ Original Error: {error_message}
         if match:
             prefix = match.group(1)
             suffix = match.group(2)
-            # Extract only the closing bracket from suffix, remove original question
-            # suffix format is "original_question]", we only want "]"
-            if suffix.endswith("]"):
-                clean_suffix = "]"
-            else:
-                clean_suffix = suffix
-
-            return f"{prefix}{cleaned_question}{clean_suffix}"
+            return f"{prefix}{cleaned_question}{suffix}"
         return original_content  # type: ignore[unreachable]
-
-    # Dynamic Interaction Methods
-
-    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 | 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)",
-                            },
-                            "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"],
-                    },
-                },
-            }
-        ]
-
-        if not self._llm_provider:
-            raise ValueError(LLM_PROVIDER_REQUIRED_ERROR)
-
-        # Call LLM with 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:
-            tool_args = result.metadata["tool_args"]
-            if tool_args.get("needs_interaction"):
-                # Construct MarkdownFlow format from structured data
-                interaction_content = self._build_interaction_format(tool_args)
-                result.content = interaction_content
-
-        # If transformed to interaction, return as is
-        if result.transformed_to_interaction:
-            return result
-
-        # If not transformed, continue with normal processing using standard content messages
-        normal_messages = self._build_content_messages(block_index, variables)
-
-        if mode == ProcessMode.STREAM:
-
-            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 - 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,
-        block: "Block",
-        context: list[dict[str, str]] | None,
-        variables: dict[str, str | list[str]] | None,
-    ) -> list[dict[str, str]]:
-        """Build messages for dynamic interaction detection."""
-
-        import json
-
-        # System prompt for detection
-        system_prompt = """You are an intelligent document processing assistant specializing in creating interactive forms.
-
-Task: Analyze the given content block and determine if it needs to be converted to an interaction block to collect user information.
-
-**ABSOLUTE RULE**: Convert ONLY when ALL THREE mandatory elements are explicitly present:
-1. Storage action word + target connector + variable
-2. No exceptions, no implications, no assumptions
-
-**MANDATORY TRIPLE PATTERN (ALL REQUIRED):**
-
-**Element 1: Storage Action Words**
-- Chinese: "记录", "保存", "存储", "收集", "采集"
-- English: "save", "store", "record", "collect", "gather"
-
-**Element 2: Target Connection Words**
-- Chinese: "到", "为", "在", "至"
-- English: "to", "as", "in", "into"
-
-**Element 3: Target Variable**
-- Must contain {{variable_name}} syntax for NEW data storage
-- Variable must be for collecting NEW information, not using existing data
-
-**VALID CONVERSION FORMULA:**
-[Storage Word] + [Connector] + {{new_variable}}
-
-Examples of VALID patterns:
-- "...记录到{{姓名}}"
-- "...保存为{{偏好}}"
-- "...存储在{{选择}}"
-- "...save to {{preference}}"
-- "...collect as {{user_input}}"
-
-**STRICT EXCLUSION RULES:**
-
-❌ NEVER convert if missing ANY element:
-- No storage action word = NO conversion
-- No target connector = NO conversion
-- No {{variable}} = NO conversion
-- Using existing {{variable}} instead of collecting new = NO conversion
-
-❌ NEVER convert casual conversation:
-- Simple questions without storage intent
-- Introduction requests without persistence
-- General inquiries without data collection
-- Educational or exploratory content
-
-❌ NEVER infer or assume storage intent:
-- Don't assume "询问姓名" means "保存姓名"
-- Don't assume "了解偏好" means "记录偏好"
-- Don't assume data collection without explicit storage words
-
-**PATTERN ANALYSIS METHOD:**
-1. **Exact Pattern Match**: Search for [Storage Word] + [Connector] + {{variable}}
-2. **No Pattern = No Conversion**: If exact pattern not found, return needs_interaction: false
-3. **Zero Tolerance**: No partial matches, no similar meanings, no interpretations
-
-**ULTRA-CONSERVATIVE APPROACH:**
-- If there's ANY doubt about storage intent = DON'T convert
-- If storage pattern is not 100% explicit = DON'T convert
-- If you need to "interpret" or "infer" storage intent = DON'T convert
-- Prefer false negatives over false positives
-
-When exact pattern is found, generate structured interaction data. Otherwise, always return needs_interaction: false."""
-
-        # User message with content and context
-        # Build user prompt with document context
-        user_prompt_parts = []
-
-        # Add document-level prompt context if exists
-        if self._document_prompt:
-            user_prompt_parts.append(f"""Document-level instructions:
-{self._document_prompt}
-
-(Note: The above are the user's document-level instructions that provide context and requirements for processing.)
-""")
-
-        # Prepare content analysis with both original and resolved versions
-        original_content = block.content
-
-        # Create resolved content with variable substitution for better context
-        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:
-
-**Original content (shows variable structure):**
-{original_content}
-
-**Resolved content (with current variable values):**
-{resolved_content}
-
-**Existing variable values:**
-{json.dumps(variables, ensure_ascii=False) if variables else "None"}"""
-
-        # 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)
-            new_variables = content_variables - (set(variables.keys()) if variables else set())
-            existing_used_variables = content_variables & (set(variables.keys()) if variables else set())
-
-            content_analysis += f"""
-
-**Variable analysis:**
-- Variables used from previous steps: {list(existing_used_variables) if existing_used_variables else "None"}
-- New variables to collect: {list(new_variables) if new_variables else "None"}
-
-**Context guidance:**
-- Use the resolved content to understand the actual context and requirements
-- Generate options based on the real variable values shown in the resolved content
-- Collect user input for the new variables identified above"""
-
-        user_prompt_parts.append(content_analysis)
-
-        # Add analysis requirements and structured output guide
-        user_prompt_parts.append("""## Analysis Task:
-1. Determine if this content needs to be converted to an interaction block
-2. If conversion is needed, provide structured interaction data
-
-## Context-based Analysis:
-- Use the "Resolved content" to understand actual context (e.g., if it shows "川菜", generate Sichuan dish options)
-- Extract the "New variables to collect" identified in the variable analysis above
-- Generate 3-4 specific options based on the resolved context and document-level instructions
-- Follow ALL document-level instruction requirements (language, domain, terminology)
-
-## Selection Type Decision Logic:
-Ask: "Can a user realistically want/choose multiple of these options simultaneously?"
-
-**Use MULTI_SELECT when:**
-- Food dishes (can order multiple: 宫保鸡丁, 麻婆豆腐)
-- Programming skills (can know multiple: Python, JavaScript)
-- Interests/hobbies (can have multiple: 读书, 运动, 旅游)
-- Product features (can want multiple: 定制颜色, 个性化logo)
-- Exercise types (can do multiple: 跑步, 游泳, 瑜伽)
-
-**Use SINGLE_SELECT when:**
-- Job positions (usually apply for one: 软件工程师 OR 产品经理)
-- Experience levels (have one current level: Beginner OR Advanced)
-- Budget ranges (have one range: 5-10万 OR 10-20万)
-- Education levels (have one highest: Bachelor's OR Master's)
-
-## Output Instructions:
-If this content needs interaction, use the create_interaction_block function with:
-- `needs_interaction`: true/false
-- `variable_name`: the variable to collect (from "New variables" above)
-- `interaction_type`: "single_select", "multi_select", "text_input", or "mixed"
-- `options`: array of 3-4 specific options based on context
-- `allow_text_input`: true if you want to include "other" option
-- `text_input_prompt`: text for the "other" option (in appropriate language)
-
-Analyze the content and provide the structured interaction data.""")
-
-        user_prompt = "\n\n".join(user_prompt_parts)
-
-        messages = [{"role": "system", "content": system_prompt}]
-
-        # Add context if provided
-        if context:
-            messages.extend(context)
-
-        messages.append({"role": "user", "content": user_prompt})
-
-        return messages
-
-    def _build_interaction_format(self, tool_args: dict) -> str:
-        """Build MarkdownFlow interaction format from structured Function Calling data."""
-        variable_name = tool_args.get("variable_name", "")
-        interaction_type = tool_args.get("interaction_type", "single_select")
-        options = tool_args.get("options", [])
-        allow_text_input = tool_args.get("allow_text_input", False)
-        text_input_prompt = tool_args.get("text_input_prompt", "...请输入")
-
-        if not variable_name:
-            return ""
-
-        # For text_input type, options can be empty
-        if interaction_type != "text_input" and not options:
-            return ""
-
-        # Choose separator based on interaction type
-        if interaction_type in ["multi_select", "mixed"]:
-            separator = "||"
-        else:
-            separator = "|"
-
-        # Build options string
-        if interaction_type == "text_input":
-            # Text input only
-            options_str = f"...{text_input_prompt}"
-        else:
-            # Options with potential text input
-            options_str = separator.join(options)
-
-            if allow_text_input and text_input_prompt:
-                # Ensure text input has ... prefix
-                text_option = text_input_prompt if text_input_prompt.startswith("...") else f"...{text_input_prompt}"
-                options_str += f"{separator}{text_option}"
-
-        return f"?[%{{{{{variable_name}}}}} {options_str}]"
-
-    def _process_dynamic_interaction_validation(
-        self,
-        block_index: int,
-        interaction_format: str,
-        user_input: dict[str, list[str]],
-        mode: ProcessMode,
-        context: list[dict[str, str]] | None,
-        variables: dict[str, str | list[str]] | None,
-    ) -> LLMResult:
-        """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 using the same parser as normal interactions
-        parser = InteractionParser()
-        parse_result = parser.parse(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 and interaction type
-        variable_name = parse_result.get("variable")
-        interaction_type = parse_result.get("type")
-
-        if not variable_name:
-            error_msg = f"No variable found in interaction format: {interaction_format}"
-            return self._render_error(error_msg, mode)
-
-        # Get user input for the target variable
-        target_values = user_input.get(variable_name, [])
-
-        # 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,
-            ]
-
-            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,
-                    },
-                )
-            error_msg = f"No input provided for variable '{variable_name}'"
-            return self._render_error(error_msg, mode)
-
-        # 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 button_result.variables is not None 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
-
-        if 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,
-                },
-            )
-        # 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,6 @@ Provides LLM provider interfaces and related data models, supporting multiple pr
 """
 
 from abc import ABC, abstractmethod
-from collections.abc import Generator
 from dataclasses import dataclass
 from enum import Enum
 from typing import Any
@@ -29,7 +28,6 @@ class LLMResult:
     prompt: str | None = None  # Used prompt
     variables: dict[str, str | list[str]] | None = None  # Extracted variables
     metadata: dict[str, Any] | None = None  # Metadata
-    transformed_to_interaction: bool = False  # Whether content block was transformed to interaction block
 
     def __bool__(self):
         """Support boolean evaluation."""
@@ -40,23 +38,22 @@ class LLMProvider(ABC):
     """Abstract LLM provider interface."""
 
     @abstractmethod
-    def complete(self, messages: list[dict[str, str]], tools: list[dict[str, Any]] | None = None) -> LLMResult:
+    def complete(self, messages: list[dict[str, str]]) -> str:
         """
-        Non-streaming LLM call with optional function calling support.
+        Non-streaming LLM call.
 
         Args:
             messages: Message list in format [{"role": "system/user/assistant", "content": "..."}]
-            tools: Optional tools/functions for LLM to call
 
         Returns:
-            LLMResult: Structured result with content and metadata
+            str: LLM response content
 
         Raises:
             ValueError: When LLM call fails
         """
 
     @abstractmethod
-    def stream(self, messages: list[dict[str, str]]) -> Generator[str, None, None]:
+    def stream(self, messages: list[dict[str, str]]):
         """
         Streaming LLM call.
 
@@ -74,8 +71,8 @@ class LLMProvider(ABC):
 class NoLLMProvider(LLMProvider):
     """Empty LLM provider for prompt-only scenarios."""
 
-    def complete(self, messages: list[dict[str, str]], tools: list[dict[str, Any]] | None = None) -> LLMResult:
+    def complete(self, messages: list[dict[str, str]]) -> str:
         raise NotImplementedError(NO_LLM_PROVIDER_ERROR)
 
-    def stream(self, messages: list[dict[str, str]]) -> Generator[str, None, None]:
+    def stream(self, messages: list[dict[str, str]]):
         raise NotImplementedError(NO_LLM_PROVIDER_ERROR)

markdown_flow/utils.py

@@ -23,7 +23,6 @@ from .constants import (
     CONTEXT_QUESTION_MARKER,
     CONTEXT_QUESTION_TEMPLATE,
     JSON_PARSE_ERROR,
-    OUTPUT_INSTRUCTION_EXPLANATION,
     OUTPUT_INSTRUCTION_PREFIX,
     OUTPUT_INSTRUCTION_SUFFIX,
     SMART_VALIDATION_TEMPLATE,
@@ -559,7 +558,7 @@ def parse_json_response(response_text: str) -> dict[str, Any]:
         raise ValueError(JSON_PARSE_ERROR)
 
 
-def process_output_instructions(content: str) -> str:
+def process_output_instructions(content: str) -> tuple[str, bool]:
     """
     Process output instruction markers, converting !=== format to [output] format.
 
@@ -569,7 +568,9 @@ def process_output_instructions(content: str) -> str:
         content: Raw content containing output instructions
 
     Returns:
-        Processed content with === and !=== markers converted to [output] format
+        Tuple of (processed_content, has_preserved_content):
+        - processed_content: Content with === and !=== markers converted to XML format
+        - has_preserved_content: True if content contained preserved markers
     """
     lines = content.split("\n")
     result_lines = []
@@ -650,11 +651,8 @@ def process_output_instructions(content: str) -> str:
     # Assemble final content
     processed_content = "\n".join(result_lines)
 
-    # Add explanation prefix (if has output instructions)
-    if has_output_instruction:
-        processed_content = OUTPUT_INSTRUCTION_EXPLANATION + processed_content
-
-    return processed_content
+    # Return both processed content and whether it contains preserved content
+    return processed_content, has_output_instruction
 
 
 def extract_preserved_content(content: str) -> str:

{markdown_flow-0.2.16.dist-info → markdown_flow-0.2.18.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: markdown-flow
-Version: 0.2.16
+Version: 0.2.18
 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 = mf.process(
+result = await mf.process(
     block_index=0,
     mode=ProcessMode.COMPLETE,
     variables={'name': 'Alice', 'level': 'Intermediate'}
@@ -84,7 +84,7 @@ result = mf.process(
 
 ```python
 # Stream processing for real-time responses
-for chunk in mf.process(
+async for chunk in mf.process(
     block_index=0,
     mode=ProcessMode.STREAM,
     variables={'name': 'Bob'}
@@ -92,36 +92,6 @@ 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
@@ -152,66 +122,13 @@ user_input = {
     'skills': ['Python', 'JavaScript', 'Go']  # Multi-selection
 }
 
-result = mf.process(
+result = await 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
@@ -231,7 +148,7 @@ class MarkdownFlow:
     def get_all_blocks(self) -> List[Block]: ...
     def extract_variables(self) -> Set[str]: ...
 
-    def process(
+    async def process(
         self,
         block_index: int,
         mode: ProcessMode = ProcessMode.COMPLETE,
@@ -276,15 +193,15 @@ class ProcessMode(Enum):
 
 ```python
 # Generate prompt only
-prompt_result = mf.process(0, ProcessMode.PROMPT_ONLY)
+prompt_result = await mf.process(0, ProcessMode.PROMPT_ONLY)
 print(prompt_result.content)  # Raw prompt text
 
 # Complete response
-complete_result = mf.process(0, ProcessMode.COMPLETE)
+complete_result = await mf.process(0, ProcessMode.COMPLETE)
 print(complete_result.content)  # Full LLM response
 
 # Streaming response
-for chunk in mf.process(0, ProcessMode.STREAM):
+async for chunk in mf.process(0, ProcessMode.STREAM):
     print(chunk.content, end='')
 ```
 
@@ -294,14 +211,14 @@ Abstract base class for implementing LLM providers.
 
 ```python
 from abc import ABC, abstractmethod
-from typing import Generator
+from typing import AsyncGenerator
 
 class LLMProvider(ABC):
     @abstractmethod
-    def complete(self, prompt: str) -> LLMResult: ...
+    async def complete(self, prompt: str) -> LLMResult: ...
 
     @abstractmethod
-    def stream(self, prompt: str) -> Generator[str, None, None]: ...
+    async def stream(self, prompt: str) -> AsyncGenerator[str, None]: ...
 ```
 
 **Custom Implementation:**
@@ -309,23 +226,23 @@ class LLMProvider(ABC):
 ```python
 class OpenAIProvider(LLMProvider):
     def __init__(self, api_key: str):
-        self.client = openai.OpenAI(api_key=api_key)
+        self.client = openai.AsyncOpenAI(api_key=api_key)
 
-    def complete(self, prompt: str) -> LLMResult:
-        response = self.client.completions.create(
+    async def complete(self, prompt: str) -> LLMResult:
+        response = await self.client.completions.create(
             model="gpt-3.5-turbo",
             prompt=prompt,
             max_tokens=500
         )
         return LLMResult(content=response.choices[0].text.strip())
 
-    def stream(self, prompt: str):
-        stream = self.client.completions.create(
+    async def stream(self, prompt: str):
+        stream = await self.client.completions.create(
             model="gpt-3.5-turbo",
             prompt=prompt,
             stream=True
         )
-        for chunk in stream:
+        async for chunk in stream:
             if chunk.choices[0].text:
                 yield chunk.choices[0].text
 ```
@@ -485,7 +402,7 @@ The new version introduces multi-select interaction support with improvements to
 user_input = "Python"
 
 # Process interaction
-result = mf.process(
+result = await mf.process(
     block_index=1,
     user_input=user_input,
     mode=ProcessMode.COMPLETE
@@ -502,7 +419,7 @@ user_input = {
 }
 
 # Process interaction
-result = mf.process(
+result = await mf.process(
     block_index=1,
     user_input=user_input,
     mode=ProcessMode.COMPLETE
@@ -545,10 +462,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.Client()
+        self.client = httpx.AsyncClient()
 
-    def complete(self, prompt: str) -> LLMResult:
-        response = self.client.post(
+    async def complete(self, prompt: str) -> LLMResult:
+        response = await self.client.post(
             f"{self.base_url}/complete",
             headers={"Authorization": f"Bearer {self.api_key}"},
             json={"prompt": prompt, "max_tokens": 1000}
@@ -556,14 +473,14 @@ class CustomAPIProvider(LLMProvider):
         data = response.json()
         return LLMResult(content=data["text"])
 
-    def stream(self, prompt: str):
-        with self.client.stream(
+    async def stream(self, prompt: str):
+        async with self.client.stream(
             "POST",
             f"{self.base_url}/stream",
             headers={"Authorization": f"Bearer {self.api_key}"},
             json={"prompt": prompt}
         ) as response:
-            for chunk in response.iter_text():
+            async for chunk in response.aiter_text():
                 if chunk.strip():
                     yield chunk
 
@@ -575,7 +492,7 @@ mf = MarkdownFlow(document, llm_provider=provider)
 ### Multi-Block Document Processing
 
 ```python
-def process_conversation():
+async def process_conversation():
     conversation = """
 # AI Assistant
 
@@ -612,7 +529,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 = mf.process(
+            result = await mf.process(
                 block_index=i,
                 mode=ProcessMode.COMPLETE,
                 variables=variables
@@ -627,8 +544,9 @@ Would you like to start with the basics?
 
 ```python
 from markdown_flow import MarkdownFlow, ProcessMode
+import asyncio
 
-def stream_with_progress():
+async def stream_with_progress():
     document = """
 Generate a comprehensive Python tutorial for {{user_name}}
 focusing on {{topic}} with practical examples.
@@ -642,7 +560,7 @@ Include code samples, explanations, and practice exercises.
     content = ""
     chunk_count = 0
 
-    for chunk in mf.process(
+    async for chunk in mf.process(
         block_index=0,
         mode=ProcessMode.STREAM,
         variables={
@@ -681,13 +599,13 @@ class InteractiveDocumentBuilder:
         self.user_responses = {}
         self.current_block = 0
 
-    def start_interaction(self):
+    async 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 = self.mf.process(
+                result = await self.mf.process(
                     block_index=i,
                     mode=ProcessMode.COMPLETE,
                     variables=self.user_responses
@@ -696,11 +614,11 @@ class InteractiveDocumentBuilder:
 
             elif block.block_type == BlockType.INTERACTION:
                 # Handle user interaction
-                response = self.handle_interaction(block.content)
+                response = await self.handle_interaction(block.content)
                 if response:
                     self.user_responses.update(response)
 
-    def handle_interaction(self, interaction_content: str):
+    async def handle_interaction(self, interaction_content: str):
         from markdown_flow.utils import InteractionParser
 
         interaction = InteractionParser.parse(interaction_content)
@@ -717,7 +635,7 @@ class InteractiveDocumentBuilder:
                 return {interaction.variable: selected}
             except (ValueError, IndexError):
                 print("Invalid choice")
-                return self.handle_interaction(interaction_content)
+                return await self.handle_interaction(interaction_content)
 
         elif interaction.name == "TEXT_ONLY":
             response = input(f"{interaction.question}: ")
@@ -739,7 +657,7 @@ Great choice, {{name}}! {{subject}} is an excellent field to study.
 """
 
 builder = InteractiveDocumentBuilder(template, your_llm_provider)
-builder.start_interaction()
+await builder.start_interaction()
 ```
 
 ### Variable System Deep Dive

markdown_flow-0.2.18.dist-info/RECORD

@@ -0,0 +1,13 @@
+markdown_flow/__init__.py,sha256=5TBCmuAdWvPqKJHpP5_R2qVOGf4FFkdaL6oUazBIY7E,2851
+markdown_flow/constants.py,sha256=HI061nHbGG9BeN-n9dMX17GlAT7fmYmsRZ6Cr8OSbXY,8809
+markdown_flow/core.py,sha256=Z0c5SssgPhqbDhbO2HZgHAaX6RpJEccb_r9RoGHVEjI,32565
+markdown_flow/enums.py,sha256=Wr41zt0Ce5b3fyLtOTE2erEVp1n92g9OVaBF_BZg_l8,820
+markdown_flow/exceptions.py,sha256=9sUZ-Jd3CPLdSRqG8Pw7eMm7cv_S3VZM6jmjUU8OhIc,976
+markdown_flow/llm.py,sha256=E2aq-OXwt4rS-alpf_iIJd2K38De_O3pzSZHuEaMeoE,2100
+markdown_flow/models.py,sha256=ENcvXMVXwpFN-RzbeVHhXTjBN0bbmRpJ96K-XS2rizI,2893
+markdown_flow/utils.py,sha256=rJOalKxCGuXYiAJzI3WfD-loLc-7BHQGpac934_uC4c,28504
+markdown_flow-0.2.18.dist-info/licenses/LICENSE,sha256=qz3BziejhHPd1xa5eVtYEU5Qp6L2pn4otuj194uGxmc,1069
+markdown_flow-0.2.18.dist-info/METADATA,sha256=-y3oljzO7iSaHHodM8c4id3SRMDxdP3zhSpihSUYW0I,21010
+markdown_flow-0.2.18.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+markdown_flow-0.2.18.dist-info/top_level.txt,sha256=DpigGvQuIt2L0TTLnDU5sylhiTGiZS7MmAMa2hi-AJs,14
+markdown_flow-0.2.18.dist-info/RECORD,,

markdown_flow-0.2.16.dist-info/RECORD

@@ -1,13 +0,0 @@
-markdown_flow/__init__.py,sha256=IOL89FC4C8kH6qU5bjNsmuumPk3YDEHKHEjnJFFzQRU,2875
-markdown_flow/constants.py,sha256=Wq10-gvskBT6CpI3WiNfZpDIfl-lnAMaHVvjGvYpGG0,8006
-markdown_flow/core.py,sha256=INQ5vIJOFOCYHkBszqCbgn0BGVQ0WXMONtQ6AJmRXkM,51237
-markdown_flow/enums.py,sha256=Wr41zt0Ce5b3fyLtOTE2erEVp1n92g9OVaBF_BZg_l8,820
-markdown_flow/exceptions.py,sha256=9sUZ-Jd3CPLdSRqG8Pw7eMm7cv_S3VZM6jmjUU8OhIc,976
-markdown_flow/llm.py,sha256=MhllCwqzrN_RtIG-whfdkNk6e0WQ2H6RJVCRv3lNM_0,2531
-markdown_flow/models.py,sha256=ENcvXMVXwpFN-RzbeVHhXTjBN0bbmRpJ96K-XS2rizI,2893
-markdown_flow/utils.py,sha256=cVi0zDRK_rCMAr3EDhgITmx6Po5fSvYjqrprYaitYE0,28450
-markdown_flow-0.2.16.dist-info/licenses/LICENSE,sha256=qz3BziejhHPd1xa5eVtYEU5Qp6L2pn4otuj194uGxmc,1069
-markdown_flow-0.2.16.dist-info/METADATA,sha256=0uwa1wYOmt5MjukW6x2MTlUxYO-zn9Q4hkKu_NSiKOc,24287
-markdown_flow-0.2.16.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-markdown_flow-0.2.16.dist-info/top_level.txt,sha256=DpigGvQuIt2L0TTLnDU5sylhiTGiZS7MmAMa2hi-AJs,14
-markdown_flow-0.2.16.dist-info/RECORD,,