markdown-flow 0.2.7__tar.gz → 0.2.9__tar.gz

{markdown_flow-0.2.7 → markdown_flow-0.2.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: markdown-flow
-Version: 0.2.7
+Version: 0.2.9
 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.7 → markdown_flow-0.2.9}/markdown_flow/__init__.py

@@ -83,4 +83,4 @@ __all__ = [
     "replace_variables_in_text",
 ]
 
-__version__ = "0.2.7"
+__version__ = "0.2.9"

{markdown_flow-0.2.7 → markdown_flow-0.2.9}/markdown_flow/core.py

@@ -492,7 +492,7 @@ class MarkdownFlow:
 
             if not matched:
                 if allow_text_input:
-                    # Allow custom text in buttons+text mode
+                    # Allow custom text in buttons+text mode - same as normal interactions
                     valid_values.append(value)
                 else:
                     invalid_values.append(value)
@@ -1066,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
-        _ = mode  # 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
+        # Extract variable name and interaction type
+        variable_name = parse_result.get("variable")
+        interaction_type = parse_result.get("type")
 
-        var_match = re.search(r"%\{\{([^}]+)\}\}", interaction_format)
-        if not var_match:
-            raise ValueError(f"No variable found in interaction format: {interaction_format}")
+        if not variable_name:
+            error_msg = f"No variable found in interaction format: {interaction_format}"
+            return self._render_error(error_msg, mode)
 
-        variable_name = var_match.group(1)
+        # Get user input for the target variable
+        target_values = user_input.get(variable_name, [])
 
-        # 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}")
+        # 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,
+            ]
 
-        # Process the validation result
-        updated_variables = dict(variables or {})
+            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)
 
-        # Handle single vs multiple values
-        if len(user_values) == 1:
-            updated_variables[variable_name] = user_values[0]
-        else:
-            updated_variables[variable_name] = 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,
+            )
 
-        # 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},
-        )
+            # 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
+
+        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-0.2.7 → markdown_flow-0.2.9}/markdown_flow.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: markdown-flow
-Version: 0.2.7
+Version: 0.2.9
 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.7 → markdown_flow-0.2.9}/tests/test_dynamic_interaction.py

@@ -49,20 +49,66 @@ def test_chinese_restaurant_scenario():
         print(f"生成的交互格式: {result1.content}")
 
         if result1.transformed_to_interaction:
-            # 第二步：用户选择菜品
-            print("\n--- 用户选择菜品 ---")
+            # 验证交互格式正确性
+            print("\n--- 验证交互格式 ---")
+            assert "?[" in result1.content, "交互格式应该包含 ?["
+            assert "%{{菜品选择}}" in result1.content, "应该包含变量名"
+            print("✅ 交互格式验证通过")
+
+            # 验证是否为多选格式
+            is_multi_select = "||" in result1.content
+            print(f"多选格式: {is_multi_select}")
+            if is_multi_select:
+                print("✅ 正确识别为多选场景")
+
+            # 第二步：测试有效选择
+            print("\n--- 测试有效选择 ---")
             user_choices = ["宫保鸡丁", "麻婆豆腐"]  # 模拟用户多选
-
             result2 = mf.process(
                 block_index=0,
                 mode=ProcessMode.COMPLETE,
                 user_input={"菜品选择": user_choices},
                 dynamic_interaction_format=result1.content
             )
-
             print(f"用户选择: {user_choices}")
             print(f"验证后的变量: {result2.variables}")
-            print("✅ 中文餐厅场景测试完成")
+            assert result2.variables.get("菜品选择") == user_choices, "变量应该正确存储用户选择"
+            print("✅ 有效选择验证通过")
+
+            # 第三步：测试无效选择
+            print("\n--- 测试无效选择 ---")
+            try:
+                invalid_choices = ["意大利面", "汉堡包"]  # 不在选项中的选择
+                result3 = mf.process(
+                    block_index=0,
+                    mode=ProcessMode.COMPLETE,
+                    user_input={"菜品选择": invalid_choices},
+                    dynamic_interaction_format=result1.content
+                )
+                if hasattr(result3, 'content') and result3.content and "Invalid" in result3.content:
+                    print("✅ 正确处理无效选择")
+                else:
+                    print("⚠️ 可能允许了无效选择")
+            except Exception as e:
+                print(f"✅ 正确拒绝无效选择: {str(e)[:50]}...")
+
+            # 第四步：测试空输入
+            print("\n--- 测试空输入 ---")
+            try:
+                result4 = mf.process(
+                    block_index=0,
+                    mode=ProcessMode.COMPLETE,
+                    user_input={"菜品选择": []},
+                    dynamic_interaction_format=result1.content
+                )
+                if hasattr(result4, 'content') and result4.content:
+                    print("⚠️ 空输入可能被接受（取决于交互类型）")
+                else:
+                    print("✅ 正确处理空输入")
+            except Exception as e:
+                print(f"✅ 正确处理空输入错误: {str(e)[:50]}...")
+
+            print("✅ 中文餐厅场景完整验证通过")
 
     except Exception as e:
         print(f"❌ 测试失败: {e}")
@@ -101,19 +147,61 @@ Format: Provide specific educational options"""
         print(f"Generated interaction format: {result1.content}")
 
         if result1.transformed_to_interaction:
-            # 第二步：用户选择学习选项
-            print("\n--- User Makes Selection ---")
-            user_choices = ["Computer Science", "Online"]  # 模拟用户选择
+            # 验证交互格式正确性
+            print("\n--- Validate Interaction Format ---")
+            assert "?[" in result1.content, "Should contain ?["
+            assert "%{{learning_choice}}" in result1.content, "Should contain variable name"
+            print("✅ Interaction format validated")
+
+            # 验证英文选项内容
+            has_english_content = any(word in result1.content for word in ["Computer", "Science", "Online", "Business"])
+            if has_english_content:
+                print("✅ Generated English content as requested")
+            else:
+                print("⚠️ May not contain expected English content")
 
+            # 第二步：测试有效选择
+            print("\n--- Test Valid Selection ---")
+            user_choices = ["Computer Science", "Online"]  # 模拟用户选择
             result2 = mf.process(
                 block_index=0,
                 mode=ProcessMode.COMPLETE,
                 user_input={"learning_choice": user_choices},
                 dynamic_interaction_format=result1.content
             )
-
             print(f"User choices: {user_choices}")
             print(f"Validated variables: {result2.variables}")
+            assert result2.variables.get("learning_choice") == user_choices, "Variables should store user selection"
+            print("✅ Valid selection validated")
+
+            # 第三步：测试部分匹配选择
+            print("\n--- Test Partial Match ---")
+            try:
+                partial_choices = ["Computer"]  # 只选择一个词
+                result3 = mf.process(
+                    block_index=0,
+                    mode=ProcessMode.COMPLETE,
+                    user_input={"learning_choice": partial_choices},
+                    dynamic_interaction_format=result1.content
+                )
+                print(f"Partial selection: {partial_choices}")
+                print(f"Result: {result3.variables}")
+            except Exception as e:
+                print(f"Partial selection handling: {str(e)[:50]}...")
+
+            # 第四步：测试单个选择
+            print("\n--- Test Single Selection ---")
+            single_choice = ["Business"]
+            result4 = mf.process(
+                block_index=0,
+                mode=ProcessMode.COMPLETE,
+                user_input={"learning_choice": single_choice},
+                dynamic_interaction_format=result1.content
+            )
+            expected_value = single_choice[0] if len(single_choice) == 1 else single_choice
+            actual_value = result4.variables.get("learning_choice")
+            print(f"Single choice: {single_choice}")
+            print(f"Stored as: {actual_value}")
             print("✅ English education scenario completed")
 
     except Exception as e:
@@ -153,6 +241,14 @@ def test_japanese_fitness_scenario():
         print(f"生成されたインタラクション形式: {result1.content}")
 
         if result1.transformed_to_interaction:
+            # 验证日文内容
+            japanese_exercises = ["ランニング", "水泳", "ヨガ", "ウェイト"]
+            has_japanese_content = any(exercise in result1.content for exercise in japanese_exercises)
+            if has_japanese_content:
+                print("✅ 生成了日文运动选项")
+            else:
+                print("⚠️ 可能未生成预期的日文内容")
+
             # 第二步：用户选择运动
             print("\n--- ユーザー選択 ---")
             user_choices = ["ランニング", "ヨガ"]  # 模拟用户选择
@@ -166,6 +262,7 @@ def test_japanese_fitness_scenario():
 
             print(f"ユーザー選択: {user_choices}")
             print(f"検証後の変数: {result2.variables}")
+            assert result2.variables.get("運動選択") == user_choices, "变量应该正确存储"
             print("✅ 日本語フィットネスシナリオ完了")
 
     except Exception as e:
@@ -205,6 +302,14 @@ def test_korean_travel_scenario():
         print(f"생성된 인터랙션 형식: {result1.content}")
 
         if result1.transformed_to_interaction:
+            # 验证韩文内容
+            korean_travel = ["휴양", "문화탐방", "호텔", "펜션"]
+            has_korean_content = any(option in result1.content for option in korean_travel)
+            if has_korean_content:
+                print("✅ 생성된 한국어 여행 옵션")
+            else:
+                print("⚠️ 예상된 한국어 콘텐츠가 생성되지 않았을 수 있음")
+
             # 第二步：用户选择旅游选项
             print("\n--- 사용자 선택 ---")
             user_choices = ["문화탐방", "호텔"]  # 模拟用户选择
@@ -218,6 +323,7 @@ def test_korean_travel_scenario():
 
             print(f"사용자 선택: {user_choices}")
             print(f"검증된 변수: {result2.variables}")
+            assert result2.variables.get("여행선택") == user_choices, "변수가 올바르게 저장되어야 함"
             print("✅ 한국어 여행 시나리오 완료")
 
     except Exception as e:
@@ -279,6 +385,15 @@ def test_complex_job_consultation_scenario():
         print(f"职位选项: {result2.content}")
 
         if result2.transformed_to_interaction:
+            # 验证职位选项是否基于行业生成
+            print("\n--- 验证职位选项上下文相关性 ---")
+            tech_jobs = ["软件工程师", "数据科学家", "产品经理", "工程师"]
+            has_tech_jobs = any(job in result2.content for job in tech_jobs)
+            if has_tech_jobs:
+                print("✅ 正确基于'科技'行业生成了相关职位")
+            else:
+                print("⚠️ 可能未正确基于行业上下文生成职位")
+
             # 第三步：用户选择职位
             print("\n--- 步骤3: 用户选择职位 ---")
             job_choices = ["软件工程师", "数据科学家"]
@@ -292,6 +407,28 @@ def test_complex_job_consultation_scenario():
             print(f"用户选择职位: {job_choices}")
             print(f"第二步变量: {result3.variables}")
 
+            # 验证职位选择验证
+            assert result3.variables.get("职位选择") == job_choices, "职位变量应该正确存储"
+            assert result3.variables.get("行业") == ["科技"], "行业变量应该保持不变"
+            print("✅ 职位选择验证通过")
+
+            # 测试无效职位选择
+            print("\n--- 测试无效职位选择 ---")
+            try:
+                invalid_job = ["厨师", "司机"]  # 不属于科技行业的职位
+                result_invalid = mf.process(
+                    block_index=1,
+                    mode=ProcessMode.COMPLETE,
+                    variables=result1.variables,
+                    user_input={"职位选择": invalid_job},
+                    dynamic_interaction_format=result2.content
+                )
+                print("⚠️ 无效职位选择可能被接受")
+                # 避免未使用变量警告
+                _ = result_invalid
+            except Exception as e:
+                print(f"✅ 正确拒绝无效职位选择: {str(e)[:50]}...")
+
             # 第四步：生成薪资选项
             print("\n--- 步骤4: 生成薪资选项 ---")
             result4 = mf.process(
@@ -303,6 +440,17 @@ def test_complex_job_consultation_scenario():
             print(f"薪资选项: {result4.content}")
 
             if result4.transformed_to_interaction:
+                # 验证薪资选项格式
+                salary_ranges = ["5-10万", "10-20万", "20-30万", "30万"]
+                has_salary_ranges = any(salary in result4.content for salary in salary_ranges)
+                if has_salary_ranges:
+                    print("✅ 生成了预期的薪资范围选项")
+
+                # 验证是否为单选（薪资期望通常是单选）
+                is_single_select = "||" not in result4.content and "|" in result4.content
+                if is_single_select:
+                    print("✅ 正确识别薪资选择为单选模式")
+
                 # 第五步：用户选择薪资期望
                 print("\n--- 步骤5: 用户选择薪资期望 ---")
                 salary_choice = ["20-30万"]
@@ -315,7 +463,15 @@ def test_complex_job_consultation_scenario():
                 )
                 print(f"用户选择薪资: {salary_choice}")
                 print(f"最终变量: {result5.variables}")
-                print("✅ 复杂职业咨询场景完成")
+
+                # 验证最终变量完整性
+                expected_vars = ["行业", "职位选择", "薪资期望"]
+                for var in expected_vars:
+                    assert var in result5.variables, f"最终结果应该包含变量: {var}"
+
+                # 避免未使用变量警告
+                _ = result5
+                print("✅ 复杂职业咨询场景完整验证通过")
 
     except Exception as e:
         print(f"❌ 测试失败: {e}")
@@ -353,8 +509,22 @@ def test_text_input_scenario():
         print(f"生成的选项: {result1.content}")
 
         if result1.transformed_to_interaction:
+            # 验证混合输入格式（按钮+文本）
+            print("\n--- 验证混合输入格式 ---")
+            has_buttons = "|" in result1.content
+            has_text_input = "..." in result1.content
+            print(f"包含按钮: {has_buttons}")
+            print(f"包含文本输入: {has_text_input}")
+
+            if has_buttons and has_text_input:
+                print("✅ 正确生成混合输入格式（按钮+文本）")
+            elif has_buttons:
+                print("⚠️ 只有按钮选项，没有文本输入选项")
+            else:
+                print("⚠️ 格式可能不符合预期")
+
             # 测试预设选项选择
-            print("\n--- 用户选择预设选项 ---")
+            print("\n--- 测试预设按钮选择 ---")
             preset_choices = ["定制颜色", "个性化logo"]
             result2 = mf.process(
                 block_index=0,
@@ -364,9 +534,11 @@ def test_text_input_scenario():
             )
             print(f"预设选项: {preset_choices}")
             print(f"验证后的变量: {result2.variables}")
+            assert result2.variables.get("自定义需求") == preset_choices, "应该正确存储预设选项"
+            print("✅ 预设选项验证通过")
 
-            # 测试文本输入
-            print("\n--- 用户自定义文本输入 ---")
+            # 测试自定义文本输入
+            print("\n--- 测试自定义文本输入 ---")
             custom_input = ["需要特殊的防水涂层处理"]
             result3 = mf.process(
                 block_index=0,
@@ -376,7 +548,37 @@ def test_text_input_scenario():
             )
             print(f"自定义输入: {custom_input}")
             print(f"验证后的变量: {result3.variables}")
-            print("✅ 文本输入场景测试完成")
+            assert result3.variables.get("自定义需求") == custom_input, "应该正确存储自定义文本"
+            print("✅ 自定义文本验证通过")
+
+            # 测试混合选择（按钮+自定义）
+            print("\n--- 测试混合选择 ---")
+            mixed_input = ["定制颜色", "需要增加夜光效果"]  # 一个按钮选项+一个自定义
+            result4 = mf.process(
+                block_index=0,
+                mode=ProcessMode.COMPLETE,
+                user_input={"自定义需求": mixed_input},
+                dynamic_interaction_format=result1.content
+            )
+            print(f"混合输入: {mixed_input}")
+            print(f"验证后的变量: {result4.variables}")
+            assert result4.variables.get("自定义需求") == mixed_input, "应该正确存储混合输入"
+            print("✅ 混合选择验证通过")
+
+            # 测试空输入（对于支持文本输入的交互，可能允许空输入）
+            print("\n--- 测试空输入处理 ---")
+            try:
+                result5 = mf.process(
+                    block_index=0,
+                    mode=ProcessMode.COMPLETE,
+                    user_input={"自定义需求": []},
+                    dynamic_interaction_format=result1.content
+                )
+                print("✅ 空输入被接受（支持文本输入的交互可能允许空输入）")
+            except Exception as e:
+                print(f"空输入被拒绝: {str(e)[:50]}...")
+
+            print("✅ 文本输入场景完整验证通过")
 
     except Exception as e:
         print(f"❌ 测试失败: {e}")
@@ -433,6 +635,7 @@ def test_variable_context_cuisine_scenario():
 
         # 验证是否生成了川菜相关的选项
         if result2.transformed_to_interaction:
+            print("\n--- 验证上下文相关性 ---")
             sichuan_dishes = ['宫保鸡丁', '麻婆豆腐', '水煮鱼', '回锅肉']
             has_sichuan_dishes = any(dish in result2.content for dish in sichuan_dishes)
 
@@ -442,24 +645,78 @@ def test_variable_context_cuisine_scenario():
                 print("⚠️ 可能未正确基于菜系上下文生成选项")
 
             # 验证是否使用了多选格式
-            if "||" in result2.content:
-                print("✅ 正确识别为多选场景（用户可以点多个菜品）")
+            is_multi_select = "||" in result2.content
+            if is_multi_select:
+                print("✅ 正确识别为多选场景（用户可以选多个菜品）")
             else:
                 print("⚠️ 可能未正确识别为多选场景")
 
+            # 验证变量名正确性
+            assert "%{{菜品}}" in result2.content, "应该包含正确的变量名"
+            print("✅ 变量名验证通过")
+
             # 第三步：用户选择菜品
             print("\n--- 步骤3: 用户选择菜品 ---")
+            dish_choices = ["宫保鸡丁", "麻婆豆腐"]
             result3 = mf.process(
                 block_index=1,
                 mode=ProcessMode.COMPLETE,
                 variables=result1.variables,
-                user_input={"菜品": ["宫保鸡丁", "麻婆豆腐"]},
+                user_input={"菜品": dish_choices},
                 dynamic_interaction_format=result2.content
             )
 
-            print(f"用户选择菜品: ['宫保鸡丁', '麻婆豆腐']")
+            print(f"用户选择菜品: {dish_choices}")
             print(f"最终变量: {result3.variables}")
-            print("✅ 变量上下文场景测试完成")
+
+            # 验证变量存储正确性
+            cuisine_var = result3.variables.get("菜系")
+            dish_var = result3.variables.get("菜品")
+
+            print(f"菜系变量: {cuisine_var}")
+            print(f"菜品变量: {dish_var}")
+
+            # 更宽松的验证 - 菜系可能是字符串或列表
+            if cuisine_var == ["川菜"] or cuisine_var == "川菜":
+                print("✅ 菜系变量正确保留")
+            else:
+                print(f"⚠️ 菜系变量格式不符合预期: {cuisine_var}")
+
+            assert dish_var == dish_choices, "菜品变量应该正确存储"
+            assert "菜系" in result3.variables, "应该包含菜系变量"
+            assert "菜品" in result3.variables, "应该包含菜品变量"
+            print("✅ 变量存储验证通过")
+
+            # 测试单个菜品选择
+            print("\n--- 测试单个菜品选择 ---")
+            single_dish = ["宫保鸡丁"]
+            result4 = mf.process(
+                block_index=1,
+                mode=ProcessMode.COMPLETE,
+                variables=result1.variables,
+                user_input={"菜品": single_dish},
+                dynamic_interaction_format=result2.content
+            )
+            print(f"单个选择结果: {result4.variables.get('菜品')}")
+
+            # 测试无效菜品选择
+            print("\n--- 测试无效菜品选择 ---")
+            try:
+                invalid_dishes = ["北京烤鸭", "小笼包"]  # 非川菜选项
+                result_invalid = mf.process(
+                    block_index=1,
+                    mode=ProcessMode.COMPLETE,
+                    variables=result1.variables,
+                    user_input={"菜品": invalid_dishes},
+                    dynamic_interaction_format=result2.content
+                )
+                print("⚠️ 无效菜品选择可能被接受")
+                # 避免未使用变量警告
+                _ = result_invalid
+            except Exception as e:
+                print(f"✅ 正确拒绝无效菜品选择: {str(e)[:50]}...")
+
+            print("✅ 变量上下文场景完整验证通过")
 
     except Exception as e:
         print(f"❌ 测试失败: {e}")
@@ -515,6 +772,7 @@ Format: Provide specific project options based on the selected programming langu
 
         if result2.transformed_to_interaction:
             # 验证是否生成了Python相关的项目
+            print("\n--- Validate Context-Based Project Options ---")
             python_projects = ['scraping', 'analysis', 'learning', 'Django']
             has_python_projects = any(project.lower() in result2.content.lower() for project in python_projects)
 
@@ -523,24 +781,133 @@ Format: Provide specific project options based on the selected programming langu
             else:
                 print("⚠️ May not have correctly generated context-based options")
 
+            # 验证多选格式（项目通常可以多选）
+            is_multi_select = "||" in result2.content
+            if is_multi_select:
+                print("✅ Correctly identified as multi-select scenario")
+
             # 第三步：用户选择项目
             print("\n--- Step 3: User selects projects ---")
+            project_choices = ["Data analysis", "Machine learning"]
             result3 = mf.process(
                 block_index=1,
                 mode=ProcessMode.COMPLETE,
                 variables=result1.variables,
-                user_input={"project_type": ["Data analysis", "Machine learning"]},
+                user_input={"project_type": project_choices},
                 dynamic_interaction_format=result2.content
             )
 
-            print(f"User project selection: ['Data analysis', 'Machine learning']")
+            print(f"User project selection: {project_choices}")
             print(f"Final variables: {result3.variables}")
-            print("✅ Skill-project scenario completed")
+
+            # 验证变量存储
+            assert result3.variables.get("skill") == ["Python"], "Skill should remain unchanged"
+            assert result3.variables.get("project_type") == project_choices, "Projects should be stored correctly"
+            print("✅ Variable storage validated")
+
+            # 测试单个项目选择
+            print("\n--- Test Single Project Selection ---")
+            single_project = ["Web scraping"]
+            result4 = mf.process(
+                block_index=1,
+                mode=ProcessMode.COMPLETE,
+                variables=result1.variables,
+                user_input={"project_type": single_project},
+                dynamic_interaction_format=result2.content
+            )
+            print(f"Single project result: {result4.variables.get('project_type')}")
+
+            print("✅ Skill-project scenario validation completed")
 
     except Exception as e:
         print(f"❌ Test failed: {e}")
 
 
+def test_user_question_text_input():
+    """测试用户疑问式文本输入场景"""
+    print("\n=== 用户疑问文本输入测试 ===")
+
+    document = """询问用户的故事风格偏好，并记录到变量{{风格选择}}"""
+
+    document_prompt = """你是故事创作助手。为用户提供故事风格选项：
+- 常见风格：幽默、搞笑、悬疑、浪漫、文言文
+- 同时允许用户输入其他风格偏好
+
+语言：中文
+格式：提供常见风格选项 + 允许自定义文本输入（使用...前缀）"""
+
+    try:
+        llm_provider = create_llm_provider()
+        mf = MarkdownFlow(
+            document=document,
+            llm_provider=llm_provider,
+            document_prompt=document_prompt
+        )
+
+        # 生成动态交互
+        print("--- 生成故事风格选项 ---")
+        result1 = mf.process(
+            block_index=0,
+            mode=ProcessMode.COMPLETE
+        )
+
+        print(f"转换为交互块: {result1.transformed_to_interaction}")
+        print(f"生成的交互: {result1.content}")
+
+        if result1.transformed_to_interaction:
+            # 验证是否包含文本输入选项
+            has_text_input = "..." in result1.content
+            if has_text_input:
+                print("✅ 包含文本输入选项")
+
+            # 测试用户疑问式输入
+            print("\n--- 测试疑问式文本输入 ---")
+            question_input = ["这里必须要选择么?"]
+
+            result2 = mf.process(
+                block_index=0,
+                mode=ProcessMode.COMPLETE,
+                user_input={"风格选择": question_input},
+                dynamic_interaction_format=result1.content
+            )
+
+            print(f"用户疑问输入: {question_input}")
+            print(f"验证结果: {result2.variables}")
+
+            # 验证疑问输入的处理
+            result_value = result2.variables.get("风格选择")
+            if result_value == question_input or result_value == question_input[0]:
+                print("✅ 疑问式文本输入被接受（后续需LLM处理语义）")
+                print("📝 注意：语义验证应由LLM负责，固定代码只做格式验证")
+            else:
+                print(f"⚠️ 输入处理结果不符合预期: {result_value}")
+
+            # 测试其他类型的自定义输入
+            print("\n--- 测试其他自定义输入 ---")
+            custom_inputs = [
+                ["我想要科幻加悬疑的混合风格"],
+                ["可以不选择吗"],
+                ["这些选项都不适合我"]
+            ]
+
+            for custom_input in custom_inputs:
+                try:
+                    result_custom = mf.process(
+                        block_index=0,
+                        mode=ProcessMode.COMPLETE,
+                        user_input={"风格选择": custom_input},
+                        dynamic_interaction_format=result1.content
+                    )
+                    print(f"自定义输入 '{custom_input[0]}' - 结果: {result_custom.variables.get('风格选择')}")
+                except Exception as e:
+                    print(f"自定义输入 '{custom_input[0]}' - 错误: {str(e)[:50]}...")
+
+            print("✅ 用户疑问文本输入场景测试完成")
+
+    except Exception as e:
+        print(f"❌ 测试失败: {e}")
+
+
 def run_all_tests():
     """运行所有 document_prompt 测试"""
     print("🧪 开始 document_prompt 动态交互测试")