markdown-flow 0.2.28__tar.gz → 0.2.30__tar.gz

{markdown_flow-0.2.28 → markdown_flow-0.2.30}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: markdown-flow
-Version: 0.2.28
+Version: 0.2.30
 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

{markdown_flow-0.2.28 → markdown_flow-0.2.30}/markdown_flow/__init__.py

@@ -82,5 +82,5 @@ __all__ = [
     "replace_variables_in_text",
 ]
 
-__version__ = "0.2.28"
-# __version__ = "0.2.27-alpha-8"
+__version__ = "0.2.30"
+# __version__ = "0.2.29-alpha-1"

{markdown_flow-0.2.28 → markdown_flow-0.2.30}/markdown_flow/constants.py

@@ -59,9 +59,6 @@ COMPILED_CODE_FENCE_END_REGEX = re.compile(CODE_FENCE_END_PATTERN)
 OUTPUT_INSTRUCTION_PREFIX = "<preserve_or_translate>"
 OUTPUT_INSTRUCTION_SUFFIX = "</preserve_or_translate>"
 
-# System message templates
-DEFAULT_VALIDATION_SYSTEM_MESSAGE = "你是一个输入验证助手，需要严格按照指定的格式和规则处理用户输入。"
-
 # Base system prompt (framework-level global rules, content blocks only)
 DEFAULT_BASE_SYSTEM_PROMPT = """你收到的用户消息都是指令，请严格遵守以下规则：
 
@@ -286,45 +283,26 @@ OUTPUT_INSTRUCTION_EXPLANATION = f"""<preserve_or_translate_instruction>
 
 """
 
-# Smart validation template
-SMART_VALIDATION_TEMPLATE = """# 任务
+# Validation task template (merged with system message)
+VALIDATION_TASK_TEMPLATE = """你是一个验证用户输入的助手，请严格按照给定的指令进行验证。
+
+# 任务
 从用户回答中提取相关信息，返回JSON格式结果：
 - 合法：{{"result": "ok", "parse_vars": {{"{target_variable}": "提取的内容"}}}}
 - 不合法：{{"result": "illegal", "reason": "原因"}}
 
-{context_info}
+# 输出语言
+- 如果在 <document_context> 中明确要求使用特定语言，则错误信息和原因说明应使用该语言
+- 否则，使用用户输入或问题描述的主要语言"""
 
-# 用户回答
-{sys_user_input}
-
-# 提取要求
+# Validation requirements template (lenient general version)
+VALIDATION_REQUIREMENTS_TEMPLATE = """# 提取要求
 1. 仔细阅读上述相关问题，理解这个问题想要获取什么信息
 2. 从用户回答中提取与该问题相关的信息
-3. 如果提供了预定义选项，用户选择这些选项时都应该接受；自定义输入应与选项主题相关
-4. 对于昵称/姓名类问题，任何非空的合理字符串（包括简短的如"ee"、"aa"、"007"等）都应该接受
-5. 只有当用户回答完全无关、包含不当内容或明显不合理时才标记为不合法
-6. 确保提取的信息准确、完整且符合预期格式"""
-
-# Validation template for buttons with text input
-BUTTONS_WITH_TEXT_VALIDATION_TEMPLATE = """用户针对以下问题进行了输入：
-
-问题：{question}
-可选按钮：{options}
-用户输入：{user_input}
-
-用户的输入不在预定义的按钮选项中，这意味着用户选择了自定义输入。
-根据问题的性质，请判断用户的输入是否合理：
-
-1. 如果用户输入能够表达与按钮选项类似的概念（比如按钮有"幽默、大气、二次元"，用户输入了"搞笑"），请接受。
-2. 如果用户输入是对问题的合理回答（比如问题要求描述风格，用户输入了任何有效的风格描述），请接受。
-3. 只有当用户输入完全不相关、包含不当内容、或明显不合理时，才拒绝。
-
-请按以下 JSON 格式回复：
-{{
-    "result": "ok|illegal",
-    "parse_vars": {{"{target_variable}": "提取的值"}},
-    "reason": "接受或拒绝的原因"
-}}"""
+3. 如果提供了预定义选项，用户选择这些选项时都应该接受；自定义输入只要是对问题的合理回答即可接受
+4. 对于昵称、姓名、标签等自由文本输入，任何非空的合理表达都应该接受（包括数字、字母、符号、emoji等创意性表达）
+5. 只有当用户回答完全无关、包含不当内容或明显违背常识时才标记为不合法
+6. 宽松验证原则：理解用户意图，接受多样化的合理表达形式"""
 
 # ========== Error Message Constants ==========
 
@@ -355,5 +333,5 @@ CONTEXT_BUTTON_OPTIONS_MARKER = "## 预定义选项"
 CONTEXT_QUESTION_TEMPLATE = f"{CONTEXT_QUESTION_MARKER}\n{{question}}"
 CONTEXT_CONVERSATION_TEMPLATE = f"{CONTEXT_CONVERSATION_MARKER}\n{{content}}"
 CONTEXT_BUTTON_OPTIONS_TEMPLATE = (
-    f"{CONTEXT_BUTTON_OPTIONS_MARKER}\n可选的预定义选项包括：{{button_options}}\n注意：用户如果选择了这些选项，都应该接受；如果输入了自定义内容，应检查是否与选项主题相关。"
+    f"{CONTEXT_BUTTON_OPTIONS_MARKER}\n可选的预定义选项包括：{{button_options}}\n注意：用户如果选择了这些选项，都应该接受；如果输入了自定义内容，只要是对问题的合理回答即可接受。"
 )

{markdown_flow-0.2.28 → markdown_flow-0.2.30}/markdown_flow/core.py

@@ -13,11 +13,11 @@ from typing import Any
 from .constants import (
     BLOCK_INDEX_OUT_OF_RANGE_ERROR,
     BLOCK_SEPARATOR,
-    BUTTONS_WITH_TEXT_VALIDATION_TEMPLATE,
+    CONTEXT_BUTTON_OPTIONS_TEMPLATE,
+    CONTEXT_QUESTION_TEMPLATE,
     DEFAULT_BASE_SYSTEM_PROMPT,
     DEFAULT_INTERACTION_ERROR_PROMPT,
     DEFAULT_INTERACTION_PROMPT,
-    DEFAULT_VALIDATION_SYSTEM_MESSAGE,
     INPUT_EMPTY_ERROR,
     INTERACTION_ERROR_RENDER_INSTRUCTIONS,
     INTERACTION_PARSE_ERROR,
@@ -26,16 +26,17 @@ from .constants import (
     LLM_PROVIDER_REQUIRED_ERROR,
     OUTPUT_INSTRUCTION_EXPLANATION,
     UNSUPPORTED_PROMPT_TYPE_ERROR,
+    VALIDATION_REQUIREMENTS_TEMPLATE,
+    VALIDATION_TASK_TEMPLATE,
 )
 from .enums import BlockType
 from .exceptions import BlockIndexError
 from .llm import LLMProvider, LLMResult, ProcessMode
-from .models import Block, InteractionValidationConfig
+from .models import Block
 from .parser import (
     CodeBlockPreprocessor,
     InteractionParser,
     InteractionType,
-    extract_interaction_question,
     extract_preserved_content,
     extract_variables_from_text,
     is_preserved_content_block,
@@ -60,7 +61,6 @@ class MarkdownFlow:
     _interaction_error_prompt: str | None
     _max_context_length: int
     _blocks: list[Block] | None
-    _interaction_configs: dict[int, InteractionValidationConfig]
     _model: str | None
     _temperature: float | None
     _preprocessor: CodeBlockPreprocessor
@@ -95,7 +95,6 @@ class MarkdownFlow:
         self._interaction_error_prompt = interaction_error_prompt or DEFAULT_INTERACTION_ERROR_PROMPT
         self._max_context_length = max_context_length
         self._blocks = None
-        self._interaction_configs: dict[int, InteractionValidationConfig] = {}
         self._model: str | None = None
         self._temperature: float | None = None
 
@@ -310,14 +309,6 @@ class MarkdownFlow:
         """Extract all variable names from the document."""
         return extract_variables_from_text(self._document)
 
-    def set_interaction_validation_config(self, block_index: int, config: InteractionValidationConfig) -> None:
-        """Set validation config for specified interaction block."""
-        self._interaction_configs[block_index] = config
-
-    def get_interaction_validation_config(self, block_index: int) -> InteractionValidationConfig | None:
-        """Get validation config for specified interaction block."""
-        return self._interaction_configs.get(block_index)
-
     # Core unified interface
 
     def process(
@@ -472,9 +463,7 @@ class MarkdownFlow:
             translated_json = self._llm_provider.complete(messages, model=self._model, temperature=self._temperature)
 
             # 使用翻译结果重构交互内容
-            translated_content = self._reconstruct_with_translation(
-                processed_block.content, translatable_json, translated_json, interaction_info
-            )
+            translated_content = self._reconstruct_with_translation(processed_block.content, translatable_json, translated_json, interaction_info)
 
             return LLMResult(
                 content=translated_content,
@@ -509,9 +498,7 @@ class MarkdownFlow:
                     full_response += chunk
 
                 # 使用翻译结果重构交互内容
-                translated_content = self._reconstruct_with_translation(
-                    processed_block.content, translatable_json, full_response, interaction_info
-                )
+                translated_content = self._reconstruct_with_translation(processed_block.content, translatable_json, full_response, interaction_info)
 
                 # 一次性返回完整内容（不是增量）
                 yield LLMResult(
@@ -847,8 +834,8 @@ class MarkdownFlow:
         mode: ProcessMode,
     ) -> LLMResult | Generator[LLMResult, None, None]:
         """Process LLM validation with button options (third case)."""
-        # Build special validation messages containing button option information
-        messages = self._build_validation_messages_with_options(user_input, target_variable, options, question)
+        # Use unified validation message builder (button context will be included automatically)
+        messages = self._build_validation_messages(block_index, user_input, target_variable, context=None)
 
         if mode == ProcessMode.COMPLETE:
             if not self._llm_provider:
@@ -977,9 +964,7 @@ class MarkdownFlow:
 
         return messages
 
-    def _extract_translatable_content(
-        self, interaction_content: str
-    ) -> tuple[str, dict[str, Any] | None]:
+    def _extract_translatable_content(self, interaction_content: str) -> tuple[str, dict[str, Any] | None]:
         """提取交互内容中需要翻译的部分为 JSON 格式
 
         Args:
@@ -1007,13 +992,12 @@ class MarkdownFlow:
 
         # 转换为 JSON
         import json
+
         json_str = json.dumps(translatable, ensure_ascii=False)
 
         return json_str, interaction_info
 
-    def _build_translation_messages(
-        self, translatable_json: str
-    ) -> list[dict[str, str]]:
+    def _build_translation_messages(self, translatable_json: str) -> list[dict[str, str]]:
         """构建翻译用的消息列表
 
         Args:
@@ -1118,87 +1102,73 @@ class MarkdownFlow:
         target_variable: str,
         context: list[dict[str, str]] | None = None,
     ) -> list[dict[str, str]]:
-        """Build validation messages."""
-        block = self.get_block(block_index)
-        config = self.get_interaction_validation_config(block_index)
-
-        # Truncate context to configured maximum length
-        truncated_context = self._truncate_context(context)
-
-        if config and config.validation_template:
-            # Use custom validation template
-            validation_prompt = config.validation_template
-            user_input_str = json.dumps(user_input, ensure_ascii=False)
-            validation_prompt = validation_prompt.replace("{sys_user_input}", user_input_str)
-            validation_prompt = validation_prompt.replace("{block_content}", block.content)
-            validation_prompt = validation_prompt.replace("{target_variable}", target_variable)
-            system_message = DEFAULT_VALIDATION_SYSTEM_MESSAGE
-        else:
-            # Use smart default validation template
-            from .parser import (
-                InteractionParser,
-                extract_interaction_question,
-                generate_smart_validation_template,
-            )
-
-            # Extract interaction question
-            interaction_question = extract_interaction_question(block.content)
-
-            # Parse interaction to extract button information
-            parser = InteractionParser()
-            parse_result = parser.parse(block.content)
-            buttons = parse_result.get("buttons") if "buttons" in parse_result else None
-
-            # Generate smart validation template with context and buttons
-            validation_template = generate_smart_validation_template(
-                target_variable,
-                context=truncated_context,
-                interaction_question=interaction_question,
-                buttons=buttons,
-            )
+        """
+        Build validation messages with new structure.
 
-            # Replace template variables
-            user_input_str = json.dumps(user_input, ensure_ascii=False)
-            validation_prompt = validation_template.replace("{sys_user_input}", user_input_str)
-            validation_prompt = validation_prompt.replace("{block_content}", block.content)
-            validation_prompt = validation_prompt.replace("{target_variable}", target_variable)
-            system_message = DEFAULT_VALIDATION_SYSTEM_MESSAGE
+        System message contains:
+        - VALIDATION_TASK_TEMPLATE (includes task description and output language rules)
+        - Question context (if exists)
+        - Button options context (if exists)
+        - VALIDATION_REQUIREMENTS_TEMPLATE
+        - document_prompt wrapped in <document_context> tags (if exists)
 
-        messages = []
+        User message contains:
+        - User input only
+        """
+        from .parser import InteractionParser, extract_interaction_question
 
-        messages.append({"role": "system", "content": system_message})
+        block = self.get_block(block_index)
 
-        # Add conversation history context if provided (only if not using custom template)
-        if truncated_context and not (config and config.validation_template):
-            messages.extend(truncated_context)
+        # Extract user input values for target variable
+        target_values = user_input.get(target_variable, [])
+        user_input_str = ", ".join(target_values) if target_values else ""
 
-        messages.append({"role": "user", "content": validation_prompt})
+        # Build System Message (contains all validation rules and context)
+        # VALIDATION_TASK_TEMPLATE already includes system message, directly replace variables
+        task_template = VALIDATION_TASK_TEMPLATE.replace("{target_variable}", target_variable)
+        system_parts = [task_template]
 
-        return messages
+        # Extract interaction question
+        interaction_question = extract_interaction_question(block.content)
 
-    def _build_validation_messages_with_options(
-        self,
-        user_input: dict[str, list[str]],
-        target_variable: str,
-        options: list[str],
-        question: str,
-    ) -> list[dict[str, str]]:
-        """Build validation messages with button options (third case)."""
-        # Use validation template from constants
-        user_input_str = json.dumps(user_input, ensure_ascii=False)
-        validation_prompt = BUTTONS_WITH_TEXT_VALIDATION_TEMPLATE.format(
-            question=question,
-            options=", ".join(options),
-            user_input=user_input_str,
-            target_variable=target_variable,
-        )
+        # Add question context (if exists)
+        if interaction_question:
+            question_context = CONTEXT_QUESTION_TEMPLATE.format(question=interaction_question)
+            system_parts.append("")
+            system_parts.append(question_context)
 
-        messages = []
+        # Parse interaction to extract button information
+        parser = InteractionParser()
+        parse_result = parser.parse(block.content)
+        buttons = parse_result.get("buttons") if "buttons" in parse_result else None
+
+        # Add button options context (if exists)
+        if buttons:
+            button_displays = [btn.get("display", "") for btn in buttons if btn.get("display")]
+            if button_displays:
+                button_options = "、".join(button_displays)
+                button_context = CONTEXT_BUTTON_OPTIONS_TEMPLATE.format(button_options=button_options)
+                system_parts.append("")
+                system_parts.append(button_context)
+
+        # Add extraction requirements (using template)
+        system_parts.append("")
+        system_parts.append(VALIDATION_REQUIREMENTS_TEMPLATE)
+
+        # Add document_prompt (if exists)
         if self._document_prompt:
-            messages.append({"role": "system", "content": self._document_prompt})
+            system_parts.append("")
+            system_parts.append("<document_context>")
+            system_parts.append(self._document_prompt)
+            system_parts.append("</document_context>")
 
-        messages.append({"role": "system", "content": DEFAULT_VALIDATION_SYSTEM_MESSAGE})
-        messages.append({"role": "user", "content": validation_prompt})
+        system_content = "\n".join(system_parts)
+
+        # Build message list
+        messages = [
+            {"role": "system", "content": system_content},
+            {"role": "user", "content": user_input_str},  # Only user input
+        ]
 
         return messages
 

{markdown_flow-0.2.28 → markdown_flow-0.2.30}/markdown_flow/models.py

@@ -26,22 +26,6 @@ class UserInput:
     is_multi_select: bool = False
 
 
-@dataclass
-class InteractionValidationConfig:
-    """
-    Simplified interaction validation configuration.
-
-    Attributes:
-        validation_template (Optional[str]): Validation prompt template
-        target_variable (Optional[str]): Target variable name
-        enable_custom_validation (bool): Enable custom validation, defaults to True
-    """
-
-    validation_template: str | None = None
-    target_variable: str | None = None
-    enable_custom_validation: bool = True
-
-
 @dataclass
 class Block:
     """

{markdown_flow-0.2.28 → markdown_flow-0.2.30}/markdown_flow/parser/validation.py

@@ -12,10 +12,10 @@ from ..constants import (
     CONTEXT_CONVERSATION_TEMPLATE,
     CONTEXT_QUESTION_MARKER,
     CONTEXT_QUESTION_TEMPLATE,
-    SMART_VALIDATION_TEMPLATE,
     VALIDATION_ILLEGAL_DEFAULT_REASON,
     VALIDATION_RESPONSE_ILLEGAL,
     VALIDATION_RESPONSE_OK,
+    VALIDATION_TASK_TEMPLATE,
 )
 from .json_parser import parse_json_response
 
@@ -29,6 +29,9 @@ def generate_smart_validation_template(
     """
     Generate smart validation template based on context and question.
 
+    DEPRECATED: This function is no longer used internally.
+    Use _build_validation_messages() in MarkdownFlow class instead.
+
     Args:
         target_variable: Target variable name
         context: Context message list with role and content fields
@@ -36,42 +39,13 @@ def generate_smart_validation_template(
         buttons: Button options list with display and value fields
 
     Returns:
-        Generated validation template
+        Generated validation template (for backward compatibility)
     """
-    # Build context information
-    context_info = ""
-    if interaction_question or context or buttons:
-        context_parts = []
-
-        # Add question information (most important, put first)
-        if interaction_question:
-            context_parts.append(CONTEXT_QUESTION_TEMPLATE.format(question=interaction_question))
-
-        # Add button options information
-        if buttons:
-            button_displays = [btn.get("display", "") for btn in buttons if btn.get("display")]
-            if button_displays:
-                button_options_str = ", ".join(button_displays)
-                button_info = CONTEXT_BUTTON_OPTIONS_TEMPLATE.format(button_options=button_options_str)
-                context_parts.append(button_info)
-
-        # Add conversation context
-        if context:
-            for msg in context:
-                if msg.get("role") == "assistant" and CONTEXT_QUESTION_MARKER not in msg.get("content", ""):
-                    # Other assistant messages as context (exclude extracted questions)
-                    context_parts.append(CONTEXT_CONVERSATION_TEMPLATE.format(content=msg.get("content", "")))
-
-        if context_parts:
-            context_info = "\n\n".join(context_parts)
-
-    # Use template from constants
-    # Note: {sys_user_input} will be replaced later in _build_validation_messages
-    return SMART_VALIDATION_TEMPLATE.format(
-        target_variable=target_variable,
-        context_info=context_info,
-        sys_user_input="{sys_user_input}",  # Keep placeholder for later replacement
-    ).strip()
+    # For backward compatibility, return a simple template
+    # This function is no longer used in the core validation flow
+    template = VALIDATION_TASK_TEMPLATE.replace("{target_variable}", target_variable)
+    template += "\n\n# 用户回答\n{sys_user_input}"
+    return template.strip()
 
 
 def parse_validation_response(llm_response: str, original_input: str, target_variable: str) -> dict[str, Any]:
@@ -101,6 +75,10 @@ def parse_validation_response(llm_response: str, original_input: str, target_var
                 if target_variable not in parse_vars:
                     parse_vars[target_variable] = original_input.strip()
 
+                # Ensure the variable value is in list format (user_input format)
+                if target_variable in parse_vars and not isinstance(parse_vars[target_variable], list):
+                    parse_vars[target_variable] = [parse_vars[target_variable]]
+
                 return {"content": "", "variables": parse_vars}
 
             if result == VALIDATION_RESPONSE_ILLEGAL:
@@ -117,5 +95,6 @@ def parse_validation_response(llm_response: str, original_input: str, target_var
 
     # Check against standard response format
     if "ok" in response_lower or "valid" in response_lower:
-        return {"content": "", "variables": {target_variable: original_input.strip()}}
+        # Return in list format to match user_input format
+        return {"content": "", "variables": {target_variable: [original_input.strip()]}}
     return {"content": llm_response, "variables": None}

{markdown_flow-0.2.28 → markdown_flow-0.2.30}/markdown_flow/providers/config.py

@@ -31,9 +31,7 @@ class ProviderConfig:
     debug: bool = field(default_factory=lambda: os.getenv("LLM_DEBUG", "false").lower() in ("true", "1", "yes"))
     """Enable debug mode (colorized console output). Default: LLM_DEBUG environment variable or False."""
 
-    timeout: float | None = field(
-        default_factory=lambda: float(os.getenv("LLM_TIMEOUT")) if os.getenv("LLM_TIMEOUT") else None
-    )
+    timeout: float | None = field(default_factory=lambda: float(os.getenv("LLM_TIMEOUT")) if os.getenv("LLM_TIMEOUT") else None)
     """Request timeout in seconds. None means no timeout. Default: LLM_TIMEOUT environment variable or None."""
 
     def __post_init__(self):

{markdown_flow-0.2.28 → markdown_flow-0.2.30}/markdown_flow/providers/openai.py

@@ -281,7 +281,7 @@ class OpenAIProvider(LLMProvider):
             role = message.get("role", "user")
             content = message.get("content", "")
             # Truncate long content for readability
-            display_content = content if len(content) <= 200 else content[:200] + "..."
+            display_content = content
             print(f"\033[30m\033[43m{role}\033[0m: {display_content}")
 
         print("\033[97m\033[44m[ ====== LLM Request End ====== ]\033[0m")

{markdown_flow-0.2.28 → markdown_flow-0.2.30}/markdown_flow.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: markdown-flow
-Version: 0.2.28
+Version: 0.2.30
 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