markdown-flow 0.2.17__tar.gz → 0.2.19__tar.gz

{markdown_flow-0.2.17 → markdown_flow-0.2.19}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: markdown-flow
-Version: 0.2.17
+Version: 0.2.19
 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.17 → markdown_flow-0.2.19}/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.17"
+__version__ = "0.2.19"

{markdown_flow-0.2.17 → markdown_flow-0.2.19}/markdown_flow/constants.py

@@ -91,13 +91,32 @@ VALIDATION_RESPONSE_ILLEGAL = "illegal"
 
 # Output instruction processing
 OUTPUT_INSTRUCTION_EXPLANATION = f"""<preserve_or_translate_instruction>
-对{OUTPUT_INSTRUCTION_PREFIX}{OUTPUT_INSTRUCTION_SUFFIX}标记之间的内容的处理规则:
+# ⚠️ 最高优先级规则
+
+**{OUTPUT_INSTRUCTION_PREFIX}{OUTPUT_INSTRUCTION_SUFFIX} 标记之间的内容是用户必须看到的最终输出内容，不是指令!**
+
+关键要点:
+1. **这些内容必须出现在你的回复中** - 即使其他提示词说"不要回应指令"也不适用于此
+2. **绝对不要输出标记本身** - 只输出标记之间的实际内容
+3. **默认逐字原样输出** - 不要改写、润色或优化，保持原文不变
+4. **唯一例外是跨语言翻译** - 仅当需要将内容从一种语言翻译成另一种语言时才可翻译
+
+---
+
+<critical_understanding>
+重要理解:
+- {OUTPUT_INSTRUCTION_PREFIX}{OUTPUT_INSTRUCTION_SUFFIX} 中的内容不是"指令"或"执行要求"
+- 即使内容看起来像标题、提示或说明，也必须原样输出给用户
+- 这条规则的优先级高于文档中的其他任何提示词
+- 其他提示词说的"不要回应指令"、"不要展示指令"等，不适用于此标记内的内容
+</critical_understanding>
 
 <default_behavior>
 默认行为: 完全保持原样输出
 - 标记之间的内容必须逐字原样输出
 - 严禁改写、润色、优化或调整任何表达方式
 - 严禁添加、删除或替换任何文字
+- 即使内容是标题格式(如 ## 标题)也必须原样输出
 </default_behavior>
 
 <exception_rule>
@@ -107,25 +126,33 @@ OUTPUT_INSTRUCTION_EXPLANATION = f"""<preserve_or_translate_instruction>
 - 如果内容无需翻译，则绝对不允许做任何改动
 </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>
+✅ 示例1 - 正确: 保持原样且不输出标记:
+  输入: {OUTPUT_INSTRUCTION_PREFIX}**下面我们做个练习。**{OUTPUT_INSTRUCTION_SUFFIX}
+  正确输出: **下面我们做个练习。**
+
+✅ 示例2 - 正确: 标题也要原样输出:
+  输入: {OUTPUT_INSTRUCTION_PREFIX}## 专属指南 for 用户{OUTPUT_INSTRUCTION_SUFFIX}
+  正确输出: ## 专属指南 for 用户
+
+✅ 示例3 - 正确: 语言翻译且不输出标记:
+  输入: {OUTPUT_INSTRUCTION_PREFIX}**Let's do an exercise.**{OUTPUT_INSTRUCTION_SUFFIX}
+  正确输出: **让我们做个练习。**
+
+❌ 示例4 - 错误: 输出了XML标记:
+  输入: {OUTPUT_INSTRUCTION_PREFIX}## 标题内容{OUTPUT_INSTRUCTION_SUFFIX}
+  错误输出: {OUTPUT_INSTRUCTION_PREFIX}## 标题内容{OUTPUT_INSTRUCTION_SUFFIX}
+  错误原因: 不应该输出标记本身!
+
+❌ 示例5 - 错误: 同语言改写:
+  输入: {OUTPUT_INSTRUCTION_PREFIX}**下面我们做个练习。**{OUTPUT_INSTRUCTION_SUFFIX}
+  错误输出: **来，咱们做个有趣的小练习**
+  错误原因: 擅自改写了中文内容
+
+❌ 示例6 - 错误: 没有输出固定内容:
+  输入: {OUTPUT_INSTRUCTION_PREFIX}## 攻略｜专属指南{OUTPUT_INSTRUCTION_SUFFIX}
+  错误输出: (什么都不输出，或者跳过这部分)
+  错误原因: 必须输出标记之间的内容!
 </examples>
 </preserve_or_translate_instruction>
 

{markdown_flow-0.2.17 → markdown_flow-0.2.19}/markdown_flow/core.py

@@ -6,7 +6,7 @@ Refactored MarkdownFlow class with built-in LLM processing capabilities and unif
 
 import json
 import re
-from collections.abc import AsyncGenerator
+from collections.abc import Generator
 from copy import copy
 from typing import Any
 
@@ -177,14 +177,14 @@ class MarkdownFlow:
 
     # Core unified interface
 
-    async def process(
+    def process(
         self,
         block_index: int,
         mode: ProcessMode = ProcessMode.COMPLETE,
         context: list[dict[str, str]] | None = None,
         variables: dict[str, str | list[str]] | None = None,
         user_input: dict[str, list[str]] | None = None,
-    ) -> LLMResult | AsyncGenerator[LLMResult, None]:
+    ):
         """
         Unified block processing interface.
 
@@ -196,7 +196,7 @@ class MarkdownFlow:
             user_input: User input (for interaction blocks)
 
         Returns:
-            LLMResult or AsyncGenerator[LLMResult, None]
+            LLMResult or Generator[LLMResult, None, None]
         """
         # Process document_prompt variable replacement
         if self._document_prompt:
@@ -205,31 +205,31 @@ class MarkdownFlow:
         block = self.get_block(block_index)
 
         if block.block_type == BlockType.CONTENT:
-            return await self._process_content(block_index, mode, context, variables)
+            return self._process_content(block_index, mode, context, variables)
 
         if block.block_type == BlockType.INTERACTION:
             if user_input is None:
                 # Render interaction content
-                return await self._process_interaction_render(block_index, mode, variables)
+                return self._process_interaction_render(block_index, mode, variables)
             # Process user input
-            return await self._process_interaction_input(block_index, user_input, mode, context, variables)
+            return self._process_interaction_input(block_index, user_input, mode, context, variables)
 
         if block.block_type == BlockType.PRESERVED_CONTENT:
             # Preserved content output as-is, no LLM call
-            return await self._process_preserved_content(block_index, variables)
+            return self._process_preserved_content(block_index, variables)
 
         # Handle other types as content
-        return await self._process_content(block_index, mode, context, variables)
+        return self._process_content(block_index, mode, context, variables)
 
     # Internal processing methods
 
-    async def _process_content(
+    def _process_content(
         self,
         block_index: int,
         mode: ProcessMode,
         context: list[dict[str, str]] | None,
         variables: dict[str, str | list[str]] | None,
-    ) -> LLMResult | AsyncGenerator[LLMResult, None]:
+    ):
         """Process content block."""
         # Build messages
         messages = self._build_content_messages(block_index, variables)
@@ -241,20 +241,20 @@ class MarkdownFlow:
             if not self._llm_provider:
                 raise ValueError(LLM_PROVIDER_REQUIRED_ERROR)
 
-            content = await self._llm_provider.complete(messages)
+            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)
 
-            async def stream_generator():
-                async for chunk in self._llm_provider.stream(messages):  # type: ignore[attr-defined]
+            def stream_generator():
+                for chunk in self._llm_provider.stream(messages):  # type: ignore[attr-defined]
                     yield LLMResult(content=chunk, prompt=messages[-1]["content"])
 
             return stream_generator()
 
-    async def _process_preserved_content(self, block_index: int, variables: dict[str, str | list[str]] | None) -> LLMResult:
+    def _process_preserved_content(self, block_index: int, variables: dict[str, str | list[str]] | None) -> LLMResult:
         """Process preserved content block, output as-is without LLM call."""
         block = self.get_block(block_index)
 
@@ -266,7 +266,7 @@ class MarkdownFlow:
 
         return LLMResult(content=content)
 
-    async def _process_interaction_render(self, block_index: int, mode: ProcessMode, variables: dict[str, str | list[str]] | None = None) -> LLMResult | AsyncGenerator[LLMResult, None]:
+    def _process_interaction_render(self, block_index: int, mode: ProcessMode, variables: dict[str, str | list[str]] | None = None):
         """Process interaction content rendering."""
         block = self.get_block(block_index)
 
@@ -299,7 +299,7 @@ class MarkdownFlow:
             if not self._llm_provider:
                 return LLMResult(content=processed_block.content)  # Fallback processing
 
-            rendered_question = await self._llm_provider.complete(messages)
+            rendered_question = self._llm_provider.complete(messages)
             rendered_content = self._reconstruct_interaction_content(processed_block.content, rendered_question)
 
             return LLMResult(
@@ -316,7 +316,7 @@ class MarkdownFlow:
                 # For interaction blocks, return reconstructed content (one-time output)
                 rendered_content = self._reconstruct_interaction_content(processed_block.content, question_text or "")
 
-                async def stream_generator():
+                def stream_generator():
                     yield LLMResult(
                         content=rendered_content,
                         prompt=messages[-1]["content"],
@@ -325,9 +325,9 @@ class MarkdownFlow:
                 return stream_generator()
 
             # With LLM provider, collect full response then return once
-            async def stream_generator():
+            def stream_generator():
                 full_response = ""
-                async for chunk in self._llm_provider.stream(messages):  # type: ignore[attr-defined]
+                for chunk in self._llm_provider.stream(messages):  # type: ignore[attr-defined]
                     full_response += chunk
 
                 # Reconstruct final interaction content
@@ -341,14 +341,14 @@ class MarkdownFlow:
 
             return stream_generator()
 
-    async def _process_interaction_input(
+    def _process_interaction_input(
         self,
         block_index: int,
         user_input: dict[str, list[str]],
         mode: ProcessMode,
         context: list[dict[str, str]] | None,
         variables: dict[str, str | list[str]] | None = None,
-    ) -> LLMResult | AsyncGenerator[LLMResult, None]:
+    ) -> LLMResult | Generator[LLMResult, None, None]:
         """Process interaction user input."""
         block = self.get_block(block_index)
         target_variable = block.variables[0] if block.variables else "user_input"
@@ -356,7 +356,7 @@ class MarkdownFlow:
         # Basic validation
         if not user_input or not any(values for values in user_input.values()):
             error_msg = INPUT_EMPTY_ERROR
-            return await self._render_error(error_msg, mode)
+            return self._render_error(error_msg, mode)
 
         # Get the target variable value from user_input
         target_values = user_input.get(target_variable, [])
@@ -370,7 +370,7 @@ class MarkdownFlow:
 
         if "error" in parse_result:
             error_msg = INTERACTION_PARSE_ERROR.format(error=parse_result["error"])
-            return await self._render_error(error_msg, mode)
+            return self._render_error(error_msg, mode)
 
         interaction_type = parse_result.get("type")
 
@@ -382,7 +382,7 @@ class MarkdownFlow:
             InteractionType.BUTTONS_MULTI_WITH_TEXT,
         ]:
             # All button types: validate user input against available buttons
-            return await self._process_button_validation(
+            return self._process_button_validation(
                 parse_result,
                 target_values,
                 target_variable,
@@ -415,16 +415,16 @@ class MarkdownFlow:
                 },
             )
         error_msg = f"No input provided for variable '{target_variable}'"
-        return await self._render_error(error_msg, mode)
+        return self._render_error(error_msg, mode)
 
-    async def _process_button_validation(
+    def _process_button_validation(
         self,
         parse_result: dict[str, Any],
         target_values: list[str],
         target_variable: str,
         mode: ProcessMode,
         interaction_type: InteractionType,
-    ) -> LLMResult | AsyncGenerator[LLMResult, None]:
+    ) -> LLMResult | Generator[LLMResult, None, None]:
         """
         Simplified button validation with new input format.
 
@@ -459,7 +459,7 @@ class MarkdownFlow:
             # Pure button mode requires input
             button_displays = [btn["display"] for btn in buttons]
             error_msg = f"Please select from: {', '.join(button_displays)}"
-            return await self._render_error(error_msg, mode)
+            return self._render_error(error_msg, mode)
 
         # Validate input values against available buttons
         valid_values = []
@@ -484,7 +484,7 @@ class MarkdownFlow:
         if invalid_values and not allow_text_input:
             button_displays = [btn["display"] for btn in buttons]
             error_msg = f"Invalid options: {', '.join(invalid_values)}. Please select from: {', '.join(button_displays)}"
-            return await self._render_error(error_msg, mode)
+            return self._render_error(error_msg, mode)
 
         # Success: return validated values
         return LLMResult(
@@ -499,13 +499,13 @@ class MarkdownFlow:
             },
         )
 
-    async def _process_llm_validation(
+    def _process_llm_validation(
         self,
         block_index: int,
         user_input: dict[str, list[str]],
         target_variable: str,
         mode: ProcessMode,
-    ) -> LLMResult | AsyncGenerator[LLMResult, None]:
+    ) -> LLMResult | Generator[LLMResult, None, None]:
         """Process LLM validation."""
         # Build validation messages
         messages = self._build_validation_messages(block_index, user_input, target_variable)
@@ -524,7 +524,7 @@ class MarkdownFlow:
                 # Fallback processing, return variables directly
                 return LLMResult(content="", variables=user_input)  # type: ignore[arg-type]
 
-            llm_response = await self._llm_provider.complete(messages)
+            llm_response = self._llm_provider.complete(messages)
 
             # Parse validation response and convert to LLMResult
             # Use joined target values for fallback; avoids JSON string injection
@@ -536,9 +536,9 @@ class MarkdownFlow:
             if not self._llm_provider:
                 return LLMResult(content="", variables=user_input)  # type: ignore[arg-type]
 
-            async def stream_generator():
+            def stream_generator():
                 full_response = ""
-                async for chunk in self._llm_provider.stream(messages):  # type: ignore[attr-defined]
+                for chunk in self._llm_provider.stream(messages):  # type: ignore[attr-defined]
                     full_response += chunk
 
                 # Parse complete response and convert to LLMResult
@@ -552,7 +552,7 @@ class MarkdownFlow:
 
             return stream_generator()
 
-    async def _process_llm_validation_with_options(
+    def _process_llm_validation_with_options(
         self,
         block_index: int,
         user_input: dict[str, list[str]],
@@ -560,7 +560,7 @@ class MarkdownFlow:
         options: list[str],
         question: str,
         mode: ProcessMode,
-    ) -> LLMResult | AsyncGenerator[LLMResult, None]:
+    ) -> LLMResult | Generator[LLMResult, None, None]:
         """Process LLM validation with button options (third case)."""
         # Build special validation messages containing button option information
         messages = self._build_validation_messages_with_options(user_input, target_variable, options, question)
@@ -581,7 +581,7 @@ class MarkdownFlow:
                 # Fallback processing, return variables directly
                 return LLMResult(content="", variables=user_input)  # type: ignore[arg-type]
 
-            llm_response = await self._llm_provider.complete(messages)
+            llm_response = self._llm_provider.complete(messages)
 
             # Parse validation response and convert to LLMResult
             # Use joined target values for fallback; avoids JSON string injection
@@ -593,9 +593,9 @@ class MarkdownFlow:
             if not self._llm_provider:
                 return LLMResult(content="", variables=user_input)  # type: ignore[arg-type]
 
-            async def stream_generator():
+            def stream_generator():
                 full_response = ""
-                async for chunk in self._llm_provider.stream(messages):  # type: ignore[attr-defined]
+                for chunk in self._llm_provider.stream(messages):  # type: ignore[attr-defined]
                     full_response += chunk
                     # For validation scenario, don't output chunks in real-time, only final result
 
@@ -612,7 +612,7 @@ class MarkdownFlow:
 
             return stream_generator()
 
-    async def _render_error(self, error_message: str, mode: ProcessMode) -> LLMResult | AsyncGenerator[LLMResult, None]:
+    def _render_error(self, error_message: str, mode: ProcessMode) -> LLMResult | Generator[LLMResult, None, None]:
         """Render user-friendly error message."""
         messages = self._build_error_render_messages(error_message)
 
@@ -626,15 +626,15 @@ class MarkdownFlow:
             if not self._llm_provider:
                 return LLMResult(content=error_message)  # Fallback processing
 
-            friendly_error = await self._llm_provider.complete(messages)
+            friendly_error = self._llm_provider.complete(messages)
             return LLMResult(content=friendly_error, prompt=messages[-1]["content"])
 
         if mode == ProcessMode.STREAM:
             if not self._llm_provider:
                 return LLMResult(content=error_message)
 
-            async def stream_generator():
-                async for chunk in self._llm_provider.stream(messages):  # type: ignore[attr-defined]
+            def stream_generator():
+                for chunk in self._llm_provider.stream(messages):  # type: ignore[attr-defined]
                     yield LLMResult(content=chunk, prompt=messages[-1]["content"])
 
             return stream_generator()

{markdown_flow-0.2.17 → markdown_flow-0.2.19}/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 AsyncGenerator
 from dataclasses import dataclass
 from enum import Enum
 from typing import Any
@@ -39,7 +38,7 @@ class LLMProvider(ABC):
     """Abstract LLM provider interface."""
 
     @abstractmethod
-    async def complete(self, messages: list[dict[str, str]]) -> str:
+    def complete(self, messages: list[dict[str, str]]) -> str:
         """
         Non-streaming LLM call.
 
@@ -54,7 +53,7 @@ class LLMProvider(ABC):
         """
 
     @abstractmethod
-    async def stream(self, messages: list[dict[str, str]]) -> AsyncGenerator[str, None]:
+    def stream(self, messages: list[dict[str, str]]):
         """
         Streaming LLM call.
 
@@ -72,8 +71,8 @@ class LLMProvider(ABC):
 class NoLLMProvider(LLMProvider):
     """Empty LLM provider for prompt-only scenarios."""
 
-    async def complete(self, messages: list[dict[str, str]]) -> str:
+    def complete(self, messages: list[dict[str, str]]) -> str:
         raise NotImplementedError(NO_LLM_PROVIDER_ERROR)
 
-    async def stream(self, messages: list[dict[str, str]]) -> AsyncGenerator[str, None]:
+    def stream(self, messages: list[dict[str, str]]):
         raise NotImplementedError(NO_LLM_PROVIDER_ERROR)

{markdown_flow-0.2.17 → markdown_flow-0.2.19}/markdown_flow.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: markdown-flow
-Version: 0.2.17
+Version: 0.2.19
 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.17 → markdown_flow-0.2.19}/tests/test_preserved_simple.py

@@ -14,7 +14,6 @@
 - 检查 LLM 输出是否不包含 XML 标记
 """
 
-import asyncio
 import os
 import sys
 
@@ -29,7 +28,7 @@ from markdown_flow import MarkdownFlow, ProcessMode  # noqa: E402
 from markdown_flow.llm import LLMResult  # noqa: E402
 
 
-async def test_preserved_output():
+def test_preserved_output():
     """测试固定输出功能"""
     print("\n" + "=" * 60)
     print("🔖 固定输出测试")
@@ -38,43 +37,41 @@ async def test_preserved_output():
     # ========== 配置区域 - 修改这里 ==========
     # 你的 MarkdownFlow 文档
     document = """
-=== **下面我们做个练习，输入一个变量代表风格。** ===
+===# 💖七夕约会全阶段攻略 ===
+
+=== 选择你的 MBTI 类型 ===
+?[%{{mbti}}ENFJ|ENFP|ENTJ|ENTP|ESFJ|ESFP|ESTJ|ESTP|INFJ|INFP|INTJ|INTP|ISFJ|ISFP|ISTJ|ISTP]
+
+===你现在最关心哪个阶段？ ===
+?[%{{攻略}}脱单|热恋|相守]
+
+给{{mbti}}一句有关{{攻略}}的七夕祝福，带七夕节明显的意境。
+
+!===
+## {{攻略}}｜专属恋爱指南 for {{mbti}}
+!===
 
-邀请用户输入喜欢的讲述风格。
 """
 
     # 要测试的块索引
-    block_index = 0
+    block_index = 4
 
     # 变量（如果需要）
     variables: dict[str, str | list[str]] = {}
 
     # 文档提示词（如果需要）
-    document_prompt: str | None = """## 角色
-你是一个丰富经验的课程讲师，擅长因材施教。
+    document_prompt: str | None = """你扮演七夕的月老，让这一天的天下有情人都能甜蜜约会，永浴爱河。
 
 ## 任务
-- 你正在一对一讲解内容，用户只有一个人，要有第一人称的对话感。
-- 遵从指令要求向用户讲课，不可丢失信息，不能改变指令原意，不要增加内容，不要改变顺序
-- 结合用户的具体情况做讲解，用学员能听懂的方式讲课，激发用户学习动力。
-- 不需要回应指令，禁止展示指令的执行要求。
-- 不要引导下一步动作，比如提问或设问
-
-## 输出
-- 按照 Markdown 格式输出
-- 重点内容（关键步骤/颠覆认知点/观点总结）做加粗处理
-- 讲解风格要口语化、通俗易懂、避免使用技术/编程术语
-
-# 课程逻辑
-1. 谁想做什么遇到了什么痛点
-2. 旧方法为何无效？案例对比
-3. 新解决方案的核心差异、适用条件
-4. 用比喻/故事/数据辅助理解。
-5. 简化的认知框架
-6. 迁移到其他领域应用
-7. 给到具体可操作的下一步行动
-
-使用英文输出内容
+- 提示词都是讲解指令，遵从指令要求做信息的讲解，不要回应指令。
+- 用第一人称一对一讲解，像现场面对面交流一样
+- 结合用户的不同特点，充分共情和举例
+
+## 风格
+- 情绪：热烈浪漫，治愈温暖，充满感染力
+- 表达：多用 emoji ，多用感叹词
+- 符合七夕节日气氛，带一些诗意和神秘
+
 """
     # =========================================
 
@@ -92,7 +89,7 @@ async def test_preserved_output():
         print("\n📝 测试 PROMPT_ONLY 模式")
         print("-" * 60)
 
-        result_prompt_raw = await mf.process(
+        result_prompt_raw = mf.process(
             block_index=block_index,
             mode=ProcessMode.PROMPT_ONLY,
             variables=variables if variables else None,
@@ -134,7 +131,7 @@ async def test_preserved_output():
         print("\n📝 测试 COMPLETE 模式")
         print("-" * 60)
 
-        result_complete_raw = await mf.process(
+        result_complete_raw = mf.process(
             block_index=block_index,
             mode=ProcessMode.COMPLETE,
             variables=variables if variables else None,
@@ -168,4 +165,4 @@ async def test_preserved_output():
 
 
 if __name__ == "__main__":
-    asyncio.run(test_preserved_output())
+    test_preserved_output()