markdown-flow 0.2.85__tar.gz → 0.3.0__tar.gz

{markdown_flow-0.2.85 → markdown_flow-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: markdown-flow
-Version: 0.2.85
+Version: 0.3.0
 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
@@ -313,10 +313,40 @@ class InteractionType(NamedTuple):
 # BUTTONS_MULTI_WITH_TEXT: Multi-select with text fallback
 "?[%{{frameworks}} React||Vue||Angular||Please specify others...]"
 
-# NON_ASSIGNMENT_BUTTON: Display buttons without variable assignment
+# NON_ASSIGNMENT_BUTTON: No-variable interaction. Supports the same shapes as
+# variable interactions; the answer is not assigned to a variable but fed back
+# into the conversation context (see "Non-assignment interactions" below).
 "?[Continue | Cancel | Go Back]"
+"?[JavaScript||TypeScript||Python]"
+"?[...Anything to add?]"
+"?[Option A | Option B | ...Other, please specify]"
 ```
 
+### Non-assignment interactions
+
+Interactions without a `%{{variable}}` collect an answer that is not stored in
+any variable — it flows back into the conversation context instead:
+
+1. Clients submit the answer under the canonical key `input`
+   (`DEFAULT_NON_ASSIGNMENT_INPUT_KEY`); the library tolerantly merges values
+   from any other key.
+2. `process()` normalizes values matching a button (by display or value) to the
+   button value and accepts anything else as free text. The normalized answer
+   is returned in `result.metadata["answer"]` (`list[str]`).
+3. Callers persist that answer and attach it to the interaction's context
+   message via the `user_answer` extension field (`USER_ANSWER_CONTEXT_KEY`):
+
+   ```python
+   context = [
+       {"role": "assistant", "content": "?[Option A | Option B]", "user_answer": "Option A"},
+   ]
+   ```
+
+   When building LLM messages the library expands this into
+   `{user: "Option A"}` + `{assistant: "ok"}`. An empty `user_answer` skips the
+   turn entirely; omitting the field keeps the legacy `{user: "ok"}` behavior.
+   Extension fields are stripped before messages reach the LLM.
+
 ### Utility Functions
 
 #### Variable Operations

{markdown_flow-0.2.85 → markdown_flow-0.3.0}/README.md

@@ -295,10 +295,40 @@ class InteractionType(NamedTuple):
 # BUTTONS_MULTI_WITH_TEXT: Multi-select with text fallback
 "?[%{{frameworks}} React||Vue||Angular||Please specify others...]"
 
-# NON_ASSIGNMENT_BUTTON: Display buttons without variable assignment
+# NON_ASSIGNMENT_BUTTON: No-variable interaction. Supports the same shapes as
+# variable interactions; the answer is not assigned to a variable but fed back
+# into the conversation context (see "Non-assignment interactions" below).
 "?[Continue | Cancel | Go Back]"
+"?[JavaScript||TypeScript||Python]"
+"?[...Anything to add?]"
+"?[Option A | Option B | ...Other, please specify]"
 ```
 
+### Non-assignment interactions
+
+Interactions without a `%{{variable}}` collect an answer that is not stored in
+any variable — it flows back into the conversation context instead:
+
+1. Clients submit the answer under the canonical key `input`
+   (`DEFAULT_NON_ASSIGNMENT_INPUT_KEY`); the library tolerantly merges values
+   from any other key.
+2. `process()` normalizes values matching a button (by display or value) to the
+   button value and accepts anything else as free text. The normalized answer
+   is returned in `result.metadata["answer"]` (`list[str]`).
+3. Callers persist that answer and attach it to the interaction's context
+   message via the `user_answer` extension field (`USER_ANSWER_CONTEXT_KEY`):
+
+   ```python
+   context = [
+       {"role": "assistant", "content": "?[Option A | Option B]", "user_answer": "Option A"},
+   ]
+   ```
+
+   When building LLM messages the library expands this into
+   `{user: "Option A"}` + `{assistant: "ok"}`. An empty `user_answer` skips the
+   turn entirely; omitting the field keeps the legacy `{user: "ok"}` behavior.
+   Extension fields are stripped before messages reach the LLM.
+
 ### Utility Functions
 
 #### Variable Operations

{markdown_flow-0.2.85 → markdown_flow-0.3.0}/markdown_flow/__init__.py

@@ -17,7 +17,11 @@ Supported Interaction Types:
     - BUTTONS_WITH_TEXT: ?[%{{var}} A|B|...question] - Buttons + text input
     - BUTTONS_MULTI_SELECT: ?[%{{var}} A||B||C] - Multi-select buttons
     - BUTTONS_MULTI_WITH_TEXT: ?[%{{var}} A||B||...question] - Multi-select + text input
-    - NON_ASSIGNMENT_BUTTON: ?[Continue|Cancel] - Display buttons only
+    - NON_ASSIGNMENT_BUTTON: ?[Continue|Cancel] - No-variable interaction.
+      Supports the same shapes as variable interactions (?[A|B], ?[A||B],
+      ?[...question], ?[A|B|...question]); the answer is not assigned to a
+      variable but fed back into the conversation context via the
+      "user_answer" context message field.
 
 Basic Usage:
     from markdown_flow import MarkdownFlow, ProcessMode
@@ -49,6 +53,10 @@ Import Guide:
 """
 
 # Import core classes and enums
+from .constants import (
+    DEFAULT_NON_ASSIGNMENT_INPUT_KEY,
+    USER_ANSWER_CONTEXT_KEY,
+)
 from .core import MarkdownFlow
 from .enums import BlockType, InputType
 from .formatter import (
@@ -88,6 +96,9 @@ __all__ = [
     "StreamFormatter",
     "format_content",
     "strip_untagged_code_fences",
+    # Non-assignment interaction contract
+    "DEFAULT_NON_ASSIGNMENT_INPUT_KEY",
+    "USER_ANSWER_CONTEXT_KEY",
     # Main utility functions
     "generate_smart_validation_template",
     "extract_interaction_question",
@@ -95,4 +106,4 @@ __all__ = [
     "replace_variables_in_text",
 ]
 
-__version__ = "0.2.85"
+__version__ = "0.3.0"

{markdown_flow-0.2.85 → markdown_flow-0.3.0}/markdown_flow/constants.py

@@ -28,6 +28,15 @@ COMPILED_BRACE_VARIABLE_REGEX = re.compile(
 )
 COMPILED_SINGLE_PIPE_SPLIT_REGEX = re.compile(r"(?<!\|)\|(?!\|)")  # Split on single | but not ||
 
+# Canonical user_input key for non-assignment interactions (?[A|B] without a
+# variable). Clients should submit {DEFAULT_NON_ASSIGNMENT_INPUT_KEY: values};
+# the library also tolerantly merges values from any other key.
+DEFAULT_NON_ASSIGNMENT_INPUT_KEY = "input"
+
+# Context message extension field carrying the user's answer to a
+# non-assignment interaction. Stripped before messages reach the LLM.
+USER_ANSWER_CONTEXT_KEY = "user_answer"
+
 # Document parsing constants (using shared INTERACTION_PATTERN defined above)
 
 # Separators

{markdown_flow-0.2.85 → markdown_flow-0.3.0}/markdown_flow/constants_system_prompt.py

@@ -12,3 +12,4 @@ from pathlib import Path
 
 
 DEFAULT_MDF_SYSTEM_PROMPT = (Path(__file__).parent / "system_prompt.md").read_text(encoding="utf-8")
+HIGHER_PRIORITY_INSTRUCTIONS_PROMPT = (Path(__file__).parent / "higher_priority_prompt.md").read_text(encoding="utf-8").strip()

{markdown_flow-0.2.85 → markdown_flow-0.3.0}/markdown_flow/core.py

@@ -17,6 +17,7 @@ from .constants import (
     CONTEXT_QUESTION_TEMPLATE,
     DEFAULT_INTERACTION_ERROR_PROMPT,
     DEFAULT_INTERACTION_PROMPT,
+    DEFAULT_NON_ASSIGNMENT_INPUT_KEY,
     INPUT_EMPTY_ERROR,
     INTERACTION_ERROR_RENDER_INSTRUCTIONS,
     INTERACTION_PARSE_ERROR,
@@ -36,12 +37,13 @@ from .constants import (
     OUTPUT_LANGUAGE_INSTRUCTION_BOTTOM,
     OUTPUT_LANGUAGE_INSTRUCTION_TOP,
     UNSUPPORTED_PROMPT_TYPE_ERROR,
+    USER_ANSWER_CONTEXT_KEY,
     VALIDATION_REQUIREMENTS_TEMPLATE,
     VALIDATION_TASK_BASE,
     VALIDATION_TASK_TEMPLATE,
     VALIDATION_TASK_WITH_LANGUAGE,
 )
-from .constants_system_prompt import DEFAULT_MDF_SYSTEM_PROMPT
+from .constants_system_prompt import DEFAULT_MDF_SYSTEM_PROMPT, HIGHER_PRIORITY_INSTRUCTIONS_PROMPT
 from .enums import BlockType
 from .exceptions import BlockIndexError
 from .formatter import ElementType, StreamFormatter, format_content
@@ -363,10 +365,18 @@ class MarkdownFlow:
         Transform context messages containing interaction syntax into LLM-friendly format.
 
         For assistant messages containing ?[...] syntax:
-        - No variable (e.g. ?[Continue]): replace with {user: "ok"} + {assistant: "ok"}
+        - No variable + "user_answer" field present and non-empty: replace with
+          {user: answer} + {assistant: "ok"}
+        - No variable + "user_answer" field present but empty: skip the message
+          (the interaction was never answered; do not fabricate an "ok")
+        - No variable + no "user_answer" field: replace with {user: "ok"} +
+          {assistant: "ok"} (legacy behavior for callers unaware of the field)
         - Has variable + value found: replace with {user: value} + {assistant: "ok"}
         - Has variable + value not found: skip the message
 
+        Non-standard fields such as "user_answer" are stripped from the
+        returned messages; the output only ever contains {role, content}.
+
         Args:
             context: Context message list
             variables: Variable mappings
@@ -382,7 +392,9 @@ class MarkdownFlow:
 
         for msg in context:
             if msg.get("role") != "assistant" or not has_interaction(msg.get("content", "")):
-                result.append(msg)
+                # Whitelist {role, content}: callers may attach extension
+                # fields (e.g. user_answer) that must not reach the LLM.
+                result.append({"role": msg.get("role", ""), "content": msg.get("content", "")})
                 continue
 
             # Parse interaction syntax
@@ -395,8 +407,23 @@ class MarkdownFlow:
 
             variable_name = parse_result.get("variable")
 
-            # No variable interaction (e.g. ?[Continue])
+            # No variable interaction (e.g. ?[Continue] or ?[A | B])
             if not variable_name:
+                if USER_ANSWER_CONTEXT_KEY in msg:
+                    # Accept both a flattened string and a list of values
+                    # (callers may pass metadata["answer"] through directly,
+                    # beyond the declared str value type).
+                    raw_answer: Any = msg.get(USER_ANSWER_CONTEXT_KEY)
+                    if isinstance(raw_answer, list):
+                        user_answer = ", ".join(str(value) for value in raw_answer if value is not None).strip()
+                    else:
+                        user_answer = str(raw_answer or "").strip()
+                    if user_answer:
+                        result.append({"role": "user", "content": user_answer})
+                        result.append({"role": "assistant", "content": "ok"})
+                    # Empty answer: the interaction was never answered, skip it
+                    continue
+                # Legacy behavior for callers that do not supply user_answer
                 result.append({"role": "user", "content": "ok"})
                 result.append({"role": "assistant", "content": "ok"})
                 continue
@@ -806,16 +833,12 @@ class MarkdownFlow:
     ) -> 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"
 
         # Basic validation
         if not user_input or not any(values for values in user_input.values()):
             error_msg = INPUT_EMPTY_ERROR
             return self._render_error(error_msg, mode, context, variables)
 
-        # Get the target variable value from user_input
-        target_values = user_input.get(target_variable, [])
-
         # Apply variable replacement to interaction content
         processed_content = replace_variables_in_text(block.content, variables or {})
 
@@ -829,6 +852,20 @@ class MarkdownFlow:
 
         interaction_type = parse_result.get("type")
 
+        # Derive the target variable from the parsed interaction, not from
+        # block.variables: text interpolation (e.g. ?[{{userName}} Continue])
+        # must not be mistaken for the assignment target.
+        target_variable = parse_result.get("variable") or DEFAULT_NON_ASSIGNMENT_INPUT_KEY
+
+        # Get the target variable value from user_input
+        if interaction_type == InteractionType.NON_ASSIGNMENT_BUTTON:
+            # Non-assignment interactions have no variable name for clients to
+            # key on; accept the answer from any key ("", "input", legacy
+            # "user_input", ...) by merging all submitted values.
+            target_values = [value for values in user_input.values() for value in values]
+        else:
+            target_values = user_input.get(target_variable, [])
+
         # Process user input based on interaction type
         if interaction_type in [
             InteractionType.BUTTONS_WITH_TEXT,
@@ -954,14 +991,22 @@ class MarkdownFlow:
             )
 
         if interaction_type == InteractionType.NON_ASSIGNMENT_BUTTON:
-            # Non-assignment buttons: ?[Continue] or ?[Continue|Cancel]
-            # These buttons don't assign variables, any input completes the interaction
+            # Non-assignment interactions: ?[Continue], ?[A|B], ?[A||B],
+            # ?[...question], ?[A|B|...question]. The answer is not assigned
+            # to a variable; values matching a button (by display or value)
+            # are normalized to the button value, anything else is accepted
+            # as free text. Callers should persist metadata["answer"] and
+            # feed it back through the "user_answer" context field so the
+            # choice reaches the next LLM request.
+            buttons = parse_result.get("buttons", [])
+            matched_values, unmatched_values = self._match_button_values(buttons, target_values)
             result = LLMResult(
                 content="",  # Empty content indicates interaction complete
-                variables={},  # Non-assignment buttons don't set variables
+                variables={},  # Non-assignment interactions don't set variables
                 metadata={
                     "interaction_type": "non_assignment_button",
                     "user_input": user_input,
+                    "answer": matched_values + unmatched_values,
                 },
             )
             # Return generator for STREAM mode, direct result for COMPLETE mode
@@ -1247,8 +1292,7 @@ class MarkdownFlow:
         # Build message array
         messages = []
 
-        # Build system message with Markdown headings (no XML tags)
-        # Two parts: MDF internal prompt + Document prompt
+        # Build system message from the MDF prompt and optional higher-priority instructions.
         system_parts = []
 
         # Part 1: MDF internal prompt (content rules + visual rules)
@@ -1259,9 +1303,10 @@ class MarkdownFlow:
         if self._viewing_mode_prompt:
             system_parts.append(self._viewing_mode_prompt)
 
-        # Part 2: Document prompt
-        if self._document_prompt:
-            system_parts.append(f"# Document Prompt\n\n{self._document_prompt}")
+        # Part 2: Document prompt, wrapped as higher-priority instructions. This
+        # part remains last so every supplied Markdown heading stays in scope.
+        if self._document_prompt and self._document_prompt.strip():
+            system_parts.append(f"{HIGHER_PRIORITY_INSTRUCTIONS_PROMPT}\n\n{self._document_prompt}")
 
         # Combine all parts and add as system message
         if system_parts:
@@ -1327,7 +1372,12 @@ class MarkdownFlow:
         buttons = parse_result.get("buttons") or []
         option_displays = [button.get("display", "").strip() for button in buttons if button.get("display", "").strip()]
 
-        detail = self._format_next_interaction_detail(parse_result.get("type"), question, option_displays)
+        detail = self._format_next_interaction_detail(
+            parse_result.get("type"),
+            question,
+            option_displays,
+            parse_result.get("is_multi_select", False),
+        )
         if not detail:
             return ""
 
@@ -1338,17 +1388,29 @@ class MarkdownFlow:
         interaction_type: InteractionType | None,
         question: str,
         option_displays: list[str],
+        is_multi_select: bool = False,
     ) -> str:
         """Format the type-specific part of the next interaction prompt."""
         options = json.dumps(option_displays, ensure_ascii=False) if option_displays else ""
         question_text = json.dumps(question, ensure_ascii=False) if question else ""
 
+        # Non-assignment interactions share the same shapes as variable ones
+        # (buttons / multi-select / text input / buttons+text); map to the
+        # equivalent variable type so the prompt wording matches.
+        if interaction_type == InteractionType.NON_ASSIGNMENT_BUTTON:
+            if option_displays and question:
+                interaction_type = InteractionType.BUTTONS_MULTI_WITH_TEXT if is_multi_select else InteractionType.BUTTONS_WITH_TEXT
+            elif question:
+                interaction_type = InteractionType.TEXT_ONLY
+            else:
+                interaction_type = InteractionType.BUTTONS_MULTI_SELECT if is_multi_select else InteractionType.BUTTONS_ONLY
+
         if interaction_type == InteractionType.TEXT_ONLY:
             if not question:
                 return ""
             return NEXT_INTERACTION_TEXT_INPUT_TEMPLATE.format(question=question_text)
 
-        if interaction_type in [InteractionType.BUTTONS_ONLY, InteractionType.NON_ASSIGNMENT_BUTTON]:
+        if interaction_type == InteractionType.BUTTONS_ONLY:
             if not options:
                 return ""
             return NEXT_INTERACTION_SINGLE_CHOICE_TEMPLATE.format(options=options)

{markdown_flow-0.2.85 → markdown_flow-0.3.0}/markdown_flow/formatter/format.py

@@ -6,14 +6,20 @@ Mirrors Go formatter/format.go.
 """
 
 from .classifier import Classifier
+from .sanitize import strip_untagged_code_fences
 from .types import ClassifyResult, ElementType, FormattedElement, is_text_family
 
 
-def format_content(content: str) -> list[FormattedElement]:
+def format_content(content: str, *, strip_untagged_fences: bool = True) -> list[FormattedElement]:
     """Format complete content into structured elements.
 
     Args:
         content: The full content string to format.
+        strip_untagged_fences: When True (default), untagged (language-less)
+            code-fence markers are removed before classification, so HTML/SVG
+            an LLM wrapped in a bare ``` renders as its real type instead of a
+            code block. Language-tagged fences (``` ```html ```, ``` ```mermaid ```,
+            ...) are always preserved. Set False to keep raw CommonMark behaviour.
 
     Returns:
         A list of FormattedElement instances.
@@ -21,6 +27,11 @@ def format_content(content: str) -> list[FormattedElement]:
     if not content:
         return []
 
+    if strip_untagged_fences:
+        content = strip_untagged_code_fences(content)
+        if not content:
+            return []
+
     c = Classifier()
     elements: list[FormattedElement] = []
     current_number = 0

markdown_flow-0.3.0/markdown_flow/higher_priority_prompt.md

@@ -0,0 +1,5 @@
+The remainder of this system message contains higher-priority instructions.
+
+Treat everything after the marker below—including every Markdown heading and section—as one instruction block. Within this system message, instructions in that block take precedence over all instructions above it. If there is a conflict, follow the instruction in the block. If there is no conflict, follow all applicable instructions. Do not reproduce the marker.
+
+[BEGIN HIGHER-PRIORITY INSTRUCTIONS]

{markdown_flow-0.2.85 → markdown_flow-0.3.0}/markdown_flow/parser/interaction.py

@@ -209,7 +209,12 @@ class InteractionParser:
 
     def _layer3_parse_display_buttons(self, content: str) -> dict[str, Any]:
         """
-        Layer 3: Parse display buttons (non-variable assignment type).
+        Layer 3: Parse non-assignment interactions (no variable).
+
+        Mirrors the variable branch: supports button groups (single/multi
+        select) and the `...` text-input suffix. The collected answer is not
+        assigned to a variable; callers feed it back into the conversation
+        context instead.
 
         Args:
             content: Content to parse
@@ -224,13 +229,43 @@ class InteractionParser:
                 "buttons": [{"display": "", "value": ""}],
             }
 
-        if "|" in content:
-            # Multiple buttons
-            buttons, _ = self._parse_buttons(content)  # Display buttons don't use multi-select
-            return {"type": InteractionType.NON_ASSIGNMENT_BUTTON, "buttons": buttons}
+        ellipsis_match = COMPILED_LAYER3_ELLIPSIS_REGEX.match(content)
+        if ellipsis_match:
+            before_ellipsis = ellipsis_match.group(1).strip()
+            question = ellipsis_match.group(2).strip()
+
+            if before_ellipsis:
+                # Buttons + text input: ?[A | B | ...question]
+                buttons, is_multi_select = self._parse_buttons(before_ellipsis)
+                return {
+                    "type": InteractionType.NON_ASSIGNMENT_BUTTON,
+                    "buttons": buttons,
+                    "question": question,
+                    "is_multi_select": is_multi_select,
+                }
+            # Pure text input: ?[...question]
+            return {
+                "type": InteractionType.NON_ASSIGNMENT_BUTTON,
+                "buttons": [],
+                "question": question,
+                "is_multi_select": False,
+            }
+
+        if "|" in content:  # type: ignore[unreachable]
+            # Button group: ?[A | B] or ?[A || B]
+            buttons, is_multi_select = self._parse_buttons(content)
+            return {
+                "type": InteractionType.NON_ASSIGNMENT_BUTTON,
+                "buttons": buttons,
+                "is_multi_select": is_multi_select,
+            }
         # Single button
         button = self._parse_single_button(content)
-        return {"type": InteractionType.NON_ASSIGNMENT_BUTTON, "buttons": [button]}
+        return {
+            "type": InteractionType.NON_ASSIGNMENT_BUTTON,
+            "buttons": [button],
+            "is_multi_select": False,
+        }
 
     def _parse_buttons(self, content: str) -> tuple[list[dict[str, str]], bool]:
         """

{markdown_flow-0.2.85 → markdown_flow-0.3.0}/markdown_flow.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: markdown-flow
-Version: 0.2.85
+Version: 0.3.0
 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
@@ -313,10 +313,40 @@ class InteractionType(NamedTuple):
 # BUTTONS_MULTI_WITH_TEXT: Multi-select with text fallback
 "?[%{{frameworks}} React||Vue||Angular||Please specify others...]"
 
-# NON_ASSIGNMENT_BUTTON: Display buttons without variable assignment
+# NON_ASSIGNMENT_BUTTON: No-variable interaction. Supports the same shapes as
+# variable interactions; the answer is not assigned to a variable but fed back
+# into the conversation context (see "Non-assignment interactions" below).
 "?[Continue | Cancel | Go Back]"
+"?[JavaScript||TypeScript||Python]"
+"?[...Anything to add?]"
+"?[Option A | Option B | ...Other, please specify]"
 ```
 
+### Non-assignment interactions
+
+Interactions without a `%{{variable}}` collect an answer that is not stored in
+any variable — it flows back into the conversation context instead:
+
+1. Clients submit the answer under the canonical key `input`
+   (`DEFAULT_NON_ASSIGNMENT_INPUT_KEY`); the library tolerantly merges values
+   from any other key.
+2. `process()` normalizes values matching a button (by display or value) to the
+   button value and accepts anything else as free text. The normalized answer
+   is returned in `result.metadata["answer"]` (`list[str]`).
+3. Callers persist that answer and attach it to the interaction's context
+   message via the `user_answer` extension field (`USER_ANSWER_CONTEXT_KEY`):
+
+   ```python
+   context = [
+       {"role": "assistant", "content": "?[Option A | Option B]", "user_answer": "Option A"},
+   ]
+   ```
+
+   When building LLM messages the library expands this into
+   `{user: "Option A"}` + `{assistant: "ok"}`. An empty `user_answer` skips the
+   turn entirely; omitting the field keeps the legacy `{user: "ok"}` behavior.
+   Extension fields are stripped before messages reach the LLM.
+
 ### Utility Functions
 
 #### Variable Operations

{markdown_flow-0.2.85 → markdown_flow-0.3.0}/markdown_flow.egg-info/SOURCES.txt

@@ -7,11 +7,11 @@ markdown_flow/constants_system_prompt.py
 markdown_flow/core.py
 markdown_flow/enums.py
 markdown_flow/exceptions.py
+markdown_flow/higher_priority_prompt.md
 markdown_flow/llm.py
 markdown_flow/models.py
 markdown_flow/system_prompt.md
 markdown_flow/tag_filter.py
-markdown_flow/utils.py
 markdown_flow.egg-info/PKG-INFO
 markdown_flow.egg-info/SOURCES.txt
 markdown_flow.egg-info/dependency_links.txt