zrb 1.12.0__py3-none-any.whl → 1.13.0__py3-none-any.whl

zrb/builtin/llm/tool/sub_agent.py

@@ -9,10 +9,10 @@ from zrb.task.llm.config import get_model, get_model_settings
 from zrb.task.llm.prompt import get_system_and_user_prompt
 
 if TYPE_CHECKING:
-    from pydantic_ai import Tool
-    from pydantic_ai.mcp import MCPServer
+    from pydantic_ai import Agent, Tool
     from pydantic_ai.models import Model
     from pydantic_ai.settings import ModelSettings
+    from pydantic_ai.toolsets import AbstractToolset
 
     ToolOrCallable = Tool | Callable
 else:
@@ -26,7 +26,7 @@ def create_sub_agent_tool(
     model: "str | Model | None" = None,
     model_settings: "ModelSettings | None" = None,
     tools: list[ToolOrCallable] = [],
-    mcp_servers: list["MCPServer"] = [],
+    toolsets: list["AbstractToolset[Agent]"] = [],
 ) -> Callable[[AnyContext, str], Coroutine[Any, Any, str]]:
     """
     Creates a "tool that is another AI agent," capable of handling complex, multi-step sub-tasks.
@@ -42,7 +42,7 @@ def create_sub_agent_tool(
         model (str | Model, optional): The language model the sub-agent will use.
         model_settings (ModelSettings, optional): Specific settings for the sub-agent's model.
         tools (list, optional): A list of tools that will be exclusively available to the sub-agent.
-        mcp_servers (list, optional): A list of MCP servers for the sub-agent.
+        toolsets (list, optional): A list of Toolset for the sub-agent.
 
     Returns:
         Callable: An asynchronous function that serves as the sub-agent tool. When called, it runs the sub-agent with a given query and returns its final result.
@@ -85,7 +85,7 @@ def create_sub_agent_tool(
             system_prompt=resolved_system_prompt,
             model_settings=resolved_model_settings,
             tools=tools,
-            mcp_servers=mcp_servers,
+            toolsets=toolsets,
         )
 
         sub_agent_run = None

zrb/config/default_prompt/interactive_system_prompt.md

@@ -21,10 +21,14 @@ You are an expert AI agent in a CLI. You MUST follow this workflow for this inte
     *   **CRITICAL:** Immediately after execution, you MUST use a tool to verify the outcome (e.g., after `write_file`, use `read_file`; after `rm`, use `ls` to confirm absence).
 
 4.  **Handle Errors (The Debugging Loop):**
-    *   If a tool call fails, you MUST NOT give up. You MUST enter a persistent debugging loop until the error is resolved.
-        1.  **Analyze:** Scrutinize the complete error message (`stdout` and `stderr`).
-        2.  **Hypothesize:** State a clear, specific hypothesis about the root cause.
-        3.  **Act:** Propose and execute a concrete, single next step to fix the issue.
+    *   If an action fails, you MUST NOT give up. You MUST enter a persistent debugging loop until the error is resolved.
+        1.  **Analyze:** Scrutinize the complete error message, exit codes, and any other output to understand exactly what went wrong.
+        2.  **Hypothesize:** State a clear, specific hypothesis about the root cause. For example, "The operation failed because the file path was incorrect," "The command failed because a required argument was missing," or "The test failed because the code has a logical error."
+        3.  **Strategize and Correct:** Formulate a new action that directly addresses the hypothesis. Do not simply repeat the failed action. Your correction strategy MUST be logical and informed by the analysis. For example:
+            *   If a path is wrong, take action to discover the correct path.
+            *   If a command is malformed, correct its syntax or arguments.
+            *   If an operation failed due to invalid state (e.g., unexpected file content, a logical bug in code), take action to inspect the current state and then formulate a targeted fix.
+        4.  **Execute** the corrected action.
     *   **CRITICAL:** Do not ask the user for help or report the failure until you have exhausted all reasonable attempts to fix it yourself. If the user provides a vague follow-up like "try again," you MUST use the context of the previous failure to inform your next action, not just repeat the failed command.
 
 5.  **Report Results:**

zrb/config/default_prompt/summarization_prompt.md

@@ -1,42 +1,16 @@
-You are a silent AI tool. Your ONLY job is to call tools to update the conversation memory based on the `Recent Conversation (JSON)`. Your response MUST be only tool calls.
-
----
-
-### **1. Factual Notes**
-
-**Goal:** Extract permanent facts. Do NOT log activities.
-*   **Good Fact:** `User prefers Python.`
-*   **Bad Activity:** `User ran tests.`
-*   **Action:** Use `add_long_term_info` for global facts and `add_contextual_info` for project facts. **Only add *new* facts from the `Recent Conversation` that are not already present in the `Factual Notes`.**
-
----
-
-### **2. Transcript**
-
-**Goal:** Create a verbatim log of the last ~4 turns.
-*   **Format:** `[YYYY-MM-DD HH:MM:SS UTC+Z] Role: Message` or `[YYYY-MM-DD UTC+Z] Role: (calling ToolName)`
-*   **Example:**
-    ```
-    [2025-07-19 10:00:01 UTC+7] User: Please create a file named todo.py.
-    [2025-07-19 10:00:15 UTC+7] Assistant: (calling `write_to_file`)
-    [2025-07-19 10:01:13 UTC+7] Assistant: Okay, I have created the file.
-    ```
-*   **Action:** Use `write_past_conversation_transcript`.
-*   **CRITICAL:** You MUST remove all headers (e.g., `# User Message`, `# Context`).
-*   **CRITICAL:** DO NOT truncate or alter user/assistant respond for whatever reason.
----
-
-### **3. Narrative Summary**
-
-**Goal:** Combine the condensed past summary with a new summary of the recent conversation.
-*   **Logic:** Timestamps MUST become less granular over time.
-*   **Format & Examples:**
-    *   **For today:** Summarize recent key events by the hour.
-        `[2025-07-20 14:00 UTC+7] Continued work on the 'Todo' app, fixing unit tests.`
-    *   **For previous days:** Condense the entire day's activity into a single entry.
-        `[2025-07-19] Started project 'Bluebird' and set up the initial file structure.`
-    *   **For previous months:** Condense the entire month's activity.
-        `[2025-06] Worked on performance optimizations for the main API.`
-*   **Action:** Use `write_past_conversation_summary` to save the new, combined summary.
-*   **CRITICAL:** Condense past conversation summary before combining with the more recent conversation summary.
-
+You are a silent memory management AI. Your ONLY output is tool calls.
+
+**Primary Directive:** Update the conversation memory based on the `Recent Conversation`.
+
+**Actions:**
+1.  **Update Conversation:**
+    - Call `write_past_conversation_summary` ONCE. The summary must be a narrative condensing the old summary and recent conversation.
+    - Call `write_past_conversation_transcript` ONCE. The transcript MUST contain at most the last 4 (four) conversation turns. The content of these turns must not be altered or truncated, furthermore the timezone has to be included. Use the format: `[YYYY-MM-DD HH:MM:SS UTC+Z] Role: Message/Tool name being called`.
+2.  **Update Factual Notes:**
+    - Read existing notes first.
+    - Call `write_long_term_note` AT MOST ONCE with new or updated global facts (e.g., user preferences).
+    - Call `write_contextual_note` AT MOST ONCE with new or updated project-specific facts.
+    - **CRITICAL - Path Specificity:** Project-specific facts are tied to the directory where they were established. You MUST analyze the `Recent Conversation` to determine the correct `context_path` for the facts you are writing. For example, if a user sets a project name while the working directory is `/tmp/a`, the `context_path` for that fact MUST be `/tmp/a`.
+    - **CRITICAL - Note Content:** Note content MUST be raw, unformatted text. Do NOT include markdown headers. Notes must be timeless facts about the current state, not a chronological log. Only write if the content has changed.
+
+**Final Step:** After all tool calls, you MUST output the word "DONE" on a new line. Do not output anything else.

zrb/config/default_prompt/system_prompt.md

@@ -18,10 +18,14 @@ You are an expert AI agent fulfilling a single request. You must provide a compl
     *   **CRITICAL:** After each step, you MUST use a tool to verify the outcome (e.g., check command exit codes, read back file contents, list files).
 
 4.  **Handle Errors (The Debugging Loop):**
-    *   If a tool call fails, you MUST NOT give up. You MUST enter a persistent debugging loop until the error is resolved.
-        1.  **Analyze:** Scrutinize the complete error message (`stdout` and `stderr`).
-        2.  **Hypothesize:** State a clear, specific hypothesis about the root cause.
-        3.  **Act:** Propose and execute a concrete, single next step to fix the issue.
+    *   If an action fails, you MUST NOT give up. You MUST enter a persistent debugging loop until the error is resolved.
+        1.  **Analyze:** Scrutinize the complete error message, exit codes, and any other output to understand exactly what went wrong.
+        2.  **Hypothesize:** State a clear, specific hypothesis about the root cause. For example, "The operation failed because the file path was incorrect," "The command failed because a required argument was missing," or "The test failed because the code has a logical error."
+        3.  **Strategize and Correct:** Formulate a new action that directly addresses the hypothesis. Do not simply repeat the failed action. Your correction strategy MUST be logical and informed by the analysis. For example:
+            *   If a path is wrong, take action to discover the correct path.
+            *   If a command is malformed, correct its syntax or arguments.
+            *   If an operation failed due to invalid state (e.g., unexpected file content, a logical bug in code), take action to inspect the current state and then formulate a targeted fix.
+        4.  **Execute** the corrected action.
     *   **CRITICAL:** You must exhaust all reasonable attempts to fix the issue yourself before reporting failure.
 
 5.  **Report Final Outcome:**

zrb/config/llm_context/config.py

@@ -1,74 +1,129 @@
 import os
 
 from zrb.config.config import CFG
-from zrb.config.llm_context.config_handler import LLMContextConfigHandler
-
-
-def cascading_path_filter(section_path: str, base_path: str) -> bool:
-    """
-    Returns True if the section path is an ancestor of, the same as the base path,
-    or if the section path is an absolute path.
-    """
-    return os.path.isabs(section_path) or base_path.startswith(section_path)
+from zrb.config.llm_context.config_parser import markdown_to_dict
+from zrb.util.llm.prompt import demote_markdown_headers
 
 
 class LLMContextConfig:
     """High-level API for interacting with cascaded configurations."""
 
-    @property
-    def _context_handler(self):
-        return LLMContextConfigHandler(
-            "Context",
-            config_file_name=CFG.LLM_CONTEXT_FILE,
-            filter_section_func=cascading_path_filter,
-            resolve_section_path=True,
-        )
-
-    @property
-    def _workflow_handler(self):
-        return LLMContextConfigHandler(
-            "Workflow",
-            config_file_name=CFG.LLM_CONTEXT_FILE,
-            resolve_section_path=False,
-        )
+    def _find_config_files(self, cwd: str) -> list[str]:
+        configs = []
+        current_dir = cwd
+        home_dir = os.path.expanduser("~")
+        while True:
+            config_path = os.path.join(current_dir, CFG.LLM_CONTEXT_FILE)
+            if os.path.exists(config_path):
+                configs.append(config_path)
+            if current_dir == home_dir or current_dir == "/":
+                break
+            current_dir = os.path.dirname(current_dir)
+        return configs
+
+    def _parse_config(self, file_path: str) -> dict[str, str]:
+        with open(file_path, "r") as f:
+            content = f.read()
+        return markdown_to_dict(content)
+
+    def _get_all_sections(self, cwd: str) -> list[tuple[str, dict[str, str]]]:
+        config_files = self._find_config_files(cwd)
+        all_sections = []
+        for config_file in config_files:
+            config_dir = os.path.dirname(config_file)
+            sections = self._parse_config(config_file)
+            all_sections.append((config_dir, sections))
+        return all_sections
 
     def get_contexts(self, cwd: str | None = None) -> dict[str, str]:
         """Gathers all relevant contexts for a given path."""
         if cwd is None:
             cwd = os.getcwd()
-        return self._context_handler.get_section(cwd)
+        all_sections = self._get_all_sections(cwd)
+        contexts: dict[str, str] = {}
+        for config_dir, sections in reversed(all_sections):
+            for key, value in sections.items():
+                if key.startswith("Context:"):
+                    context_path = key.replace("Context:", "").strip()
+                    if context_path == ".":
+                        context_path = config_dir
+                    elif not os.path.isabs(context_path):
+                        context_path = os.path.abspath(
+                            os.path.join(config_dir, context_path)
+                        )
+                    if os.path.isabs(context_path) or cwd.startswith(context_path):
+                        contexts[context_path] = value
+        return contexts
 
     def get_workflows(self, cwd: str | None = None) -> dict[str, str]:
         """Gathers all relevant workflows for a given path."""
         if cwd is None:
             cwd = os.getcwd()
-        return self._workflow_handler.get_section(cwd)
+        all_sections = self._get_all_sections(cwd)
+        workflows: dict[str, str] = {}
+        for _, sections in reversed(all_sections):
+            for key, value in sections.items():
+                if key.startswith("Workflow:"):
+                    workflow_name = key.replace("Workflow:", "").strip()
+                    if workflow_name not in workflows:
+                        workflows[workflow_name] = value
+        return workflows
 
-    def add_to_context(
+    def write_context(
         self, content: str, context_path: str | None = None, cwd: str | None = None
     ):
-        """Adds content to a context block in the nearest configuration file."""
+        """Writes content to a context block in the nearest configuration file."""
         if cwd is None:
             cwd = os.getcwd()
         if context_path is None:
             context_path = cwd
-        abs_path = os.path.abspath(context_path)
-        home_dir = os.path.expanduser("~")
-        search_dir = cwd
-        if not abs_path.startswith(home_dir):
-            search_dir = home_dir
-        self._context_handler.add_to_section(content, abs_path, cwd=search_dir)
 
-    def remove_from_context(
-        self, content: str, context_path: str | None = None, cwd: str | None = None
-    ) -> bool:
-        """Removes content from a context block in all relevant config files."""
-        if cwd is None:
-            cwd = os.getcwd()
-        if context_path is None:
-            context_path = cwd
-        abs_path = os.path.abspath(context_path)
-        return self._context_handler.remove_from_section(content, abs_path, cwd=cwd)
+        config_files = self._find_config_files(cwd)
+        if config_files:
+            config_file = config_files[0]  # Closest config file
+        else:
+            config_file = os.path.join(cwd, CFG.LLM_CONTEXT_FILE)
+
+        sections = {}
+        if os.path.exists(config_file):
+            sections = self._parse_config(config_file)
+
+        # Determine the section key
+        section_key_path = context_path
+        if not os.path.isabs(context_path):
+            config_dir = os.path.dirname(config_file)
+            section_key_path = os.path.abspath(os.path.join(config_dir, context_path))
+
+        # Find existing key
+        found_key = ""
+        for key in sections.keys():
+            if not key.startswith("Context:"):
+                continue
+            key_path = key.replace("Context:", "").strip()
+            if key_path == ".":
+                key_path = os.path.dirname(config_file)
+            elif not os.path.isabs(key_path):
+                key_path = os.path.abspath(
+                    os.path.join(os.path.dirname(config_file), key_path)
+                )
+            if key_path == section_key_path:
+                found_key = key
+                break
+
+        if found_key != "":
+            sections[found_key] = content
+        else:
+            # Add new entry
+            new_key = f"Context: {context_path}"
+            sections[new_key] = content
+
+        # Serialize back to markdown
+        new_file_content = ""
+        for key, value in sections.items():
+            new_file_content += f"# {key}\n{demote_markdown_headers(value)}\n\n"
+
+        with open(config_file, "w") as f:
+            f.write(new_file_content)
 
 
 llm_context_config = LLMContextConfig()

zrb/config/llm_context/config_parser.py

@@ -0,0 +1,46 @@
+import re
+
+from zrb.util.llm.prompt import promote_markdown_headers
+
+
+def markdown_to_dict(markdown: str) -> dict[str, str]:
+    sections: dict[str, str] = {}
+    current_title = ""
+    current_content: list[str] = []
+    fence_stack: list[str] = []
+
+    fence_pattern = re.compile(r"^([`~]{3,})(.*)$")
+    h1_pattern = re.compile(r"^# (.+)$")
+
+    for line in markdown.splitlines():
+        # Detect code fence open/close
+        fence_match = fence_pattern.match(line.strip())
+
+        if fence_match:
+            fence = fence_match.group(1)
+            if fence_stack and fence_stack[-1] == fence:
+                fence_stack.pop()  # close current fence
+            else:
+                fence_stack.append(fence)  # open new fence
+
+        # Only parse H1 when not inside a code fence
+        if not fence_stack:
+            h1_match = h1_pattern.match(line)
+            if h1_match:
+                # Save previous section
+                if current_title:
+                    sections[current_title] = "\n".join(current_content).strip()
+                # Start new section
+                current_title = h1_match.group(1).strip()
+                current_content = []
+                continue
+
+        current_content.append(line)
+
+    # Save final section
+    if current_title:
+        sections[current_title] = "\n".join(current_content).strip()
+    return {
+        header: promote_markdown_headers(content)
+        for header, content in sections.items()
+    }

zrb/context/shared_context.py

@@ -50,7 +50,10 @@ class SharedContext(AnySharedContext):
 
     @property
     def is_tty(self) -> bool:
-        return sys.stdin.isatty()
+        try:
+            return sys.stdin.isatty()
+        except Exception:
+            return False
 
     @property
     def input(self) -> DotDict:

zrb/task/llm/agent.py

@@ -7,15 +7,15 @@ from zrb.context.any_context import AnyContext
 from zrb.context.any_shared_context import AnySharedContext
 from zrb.task.llm.error import extract_api_error_details
 from zrb.task.llm.print_node import print_node
-from zrb.task.llm.tool_wrapper import wrap_tool
+from zrb.task.llm.tool_wrapper import wrap_func, wrap_tool
 from zrb.task.llm.typing import ListOfDict
 
 if TYPE_CHECKING:
     from pydantic_ai import Agent, Tool
     from pydantic_ai.agent import AgentRun
-    from pydantic_ai.mcp import MCPServer
     from pydantic_ai.models import Model
     from pydantic_ai.settings import ModelSettings
+    from pydantic_ai.toolsets import AbstractToolset
 
     ToolOrCallable = Tool | Callable
 else:
@@ -28,26 +28,43 @@ def create_agent_instance(
     system_prompt: str = "",
     model_settings: "ModelSettings | None" = None,
     tools: list[ToolOrCallable] = [],
-    mcp_servers: list["MCPServer"] = [],
+    toolsets: list["AbstractToolset[Agent]"] = [],
     retries: int = 3,
 ) -> "Agent":
     """Creates a new Agent instance with configured tools and servers."""
     from pydantic_ai import Agent, Tool
+    from pydantic_ai.tools import GenerateToolJsonSchema
 
     # Normalize tools
     tool_list = []
     for tool_or_callable in tools:
         if isinstance(tool_or_callable, Tool):
             tool_list.append(tool_or_callable)
+            # Update tool's function
+            tool = tool_or_callable
+            tool_list.append(
+                Tool(
+                    function=wrap_func(tool.function),
+                    takes_ctx=tool.takes_ctx,
+                    max_retries=tool.max_retries,
+                    name=tool.name,
+                    description=tool.description,
+                    prepare=tool.prepare,
+                    docstring_format=tool.docstring_format,
+                    require_parameter_descriptions=tool.require_parameter_descriptions,
+                    schema_generator=GenerateToolJsonSchema,
+                    strict=tool.strict,
+                )
+            )
         else:
-            # Pass ctx to wrap_tool
+            # Turn function into tool
             tool_list.append(wrap_tool(tool_or_callable, ctx))
     # Return Agent
     return Agent(
         model=model,
         system_prompt=system_prompt,
         tools=tool_list,
-        toolsets=mcp_servers,
+        toolsets=toolsets,
         model_settings=model_settings,
         retries=retries,
     )
@@ -63,8 +80,8 @@ def get_agent(
         list[ToolOrCallable] | Callable[[AnySharedContext], list[ToolOrCallable]]
     ),
     additional_tools: list[ToolOrCallable],
-    mcp_servers_attr: "list[MCPServer] | Callable[[AnySharedContext], list[MCPServer]]",
-    additional_mcp_servers: "list[MCPServer]",
+    toolsets_attr: "list[AbstractToolset[Agent]] | Callable[[AnySharedContext], list[AbstractToolset[Agent]]]",  # noqa
+    additional_toolsets: "list[AbstractToolset[Agent]]",
     retries: int = 3,
 ) -> "Agent":
     """Retrieves the configured Agent instance or creates one if necessary."""
@@ -85,18 +102,16 @@ def get_agent(
     # Get tools for agent
     tools = list(tools_attr(ctx) if callable(tools_attr) else tools_attr)
     tools.extend(additional_tools)
-    # Get MCP Servers for agent
-    mcp_servers = list(
-        mcp_servers_attr(ctx) if callable(mcp_servers_attr) else mcp_servers_attr
-    )
-    mcp_servers.extend(additional_mcp_servers)
+    # Get Toolsets for agent
+    tool_sets = list(toolsets_attr(ctx) if callable(toolsets_attr) else toolsets_attr)
+    tool_sets.extend(additional_toolsets)
     # If no agent provided, create one using the configuration
     return create_agent_instance(
         ctx=ctx,
         model=model,
         system_prompt=system_prompt,
         tools=tools,
-        mcp_servers=mcp_servers,
+        toolsets=tool_sets,
         model_settings=model_settings,
         retries=retries,
     )

zrb/task/llm/conversation_history_model.py

@@ -176,46 +176,23 @@ class ConversationHistory:
         """
         return json.dumps({"content": self._fetch_long_term_note()})
 
-    def add_long_term_info(self, new_info: str) -> str:
+    def write_long_term_note(self, content: str) -> str:
         """
-        Add new info for long-term reference.
+        Write the entire content of the long-term references.
+        This will overwrite any existing long-term notes.
 
         Args:
-            new_info (str): New info to be added into long-term references.
+            content (str): The full content of the long-term notes.
 
         Returns:
-            str: JSON with new content of the notes.
-
-        Raises:
-            Exception: If the note cannot be read.
-        """
-        llm_context_config.add_to_context(new_info, cwd="/")
-        return json.dumps({"success": True, "content": self._fetch_long_term_note()})
-
-    def remove_long_term_info(self, irrelevant_info: str) -> str:
+            str: JSON indicating success.
         """
-        Remove irrelevant info from long-term reference.
-
-        Args:
-            irrelevant_info (str): Irrelevant info to be removed from long-term references.
-
-        Returns:
-            str: JSON with new content of the notes and deletion status.
-
-        Raises:
-            Exception: If the note cannot be read.
-        """
-        was_removed = llm_context_config.remove_from_context(irrelevant_info, cwd="/")
-        return json.dumps(
-            {
-                "success": was_removed,
-                "content": self._fetch_long_term_note(),
-            }
-        )
+        llm_context_config.write_context(content, context_path="/")
+        return json.dumps({"success": True})
 
     def read_contextual_note(self) -> str:
         """
-        Read the content of the contextual references.
+        Read the content of the contextual references for the current project.
 
         This tool helps you retrieve knowledge or notes stored for contextual reference.
         If the note does not exist, you may want to create it using the write tool.
@@ -228,52 +205,25 @@ class ConversationHistory:
         """
         return json.dumps({"content": self._fetch_contextual_note()})
 
-    def add_contextual_info(self, new_info: str, context_path: str | None) -> str:
-        """
-        Add new info for contextual reference.
-
-        Args:
-            new_info (str): New info to be added into contextual references.
-            context_path (str, optional): contextual directory path for new info
-
-        Returns:
-            str: JSON with new content of the notes.
-
-        Raises:
-            Exception: If the note cannot be read.
-        """
-        if context_path is None:
-            context_path = self.project_path
-        llm_context_config.add_to_context(new_info, context_path=context_path)
-        return json.dumps({"success": True, "content": self._fetch_contextual_note()})
-
-    def remove_contextual_info(
-        self, irrelevant_info: str, context_path: str | None
+    def write_contextual_note(
+        self, content: str, context_path: str | None = None
     ) -> str:
         """
-        Remove irrelevant info from contextual reference.
+        Write the entire content of the contextual references for a specific path.
+        This will overwrite any existing contextual notes for that path.
 
         Args:
-            irrelevant_info (str): Irrelevant info to be removed from contextual references.
-            context_path (str, optional): contextual directory path of the irrelevant info
+            content (str): The full content of the contextual notes.
+            context_path (str, optional): The directory path for the context.
+                                        Defaults to the current project path.
 
         Returns:
-            str: JSON with new content of the notes and deletion status.
-
-        Raises:
-            Exception: If the note cannot be read.
+            str: JSON indicating success.
         """
         if context_path is None:
             context_path = self.project_path
-        was_removed = llm_context_config.remove_from_context(
-            irrelevant_info, context_path=context_path
-        )
-        return json.dumps(
-            {
-                "success": was_removed,
-                "content": self._fetch_contextual_note(),
-            }
-        )
+        llm_context_config.write_context(content, context_path=context_path)
+        return json.dumps({"success": True})
 
     def _fetch_long_term_note(self):
         contexts = llm_context_config.get_contexts(cwd=self.project_path)

zrb/task/llm/history_summarization.py

@@ -146,11 +146,9 @@ async def summarize_history(
             conversation_history.write_past_conversation_summary,
             conversation_history.write_past_conversation_transcript,
             conversation_history.read_long_term_note,
-            conversation_history.add_long_term_info,
-            conversation_history.remove_long_term_info,
+            conversation_history.write_long_term_note,
             conversation_history.read_contextual_note,
-            conversation_history.add_contextual_info,
-            conversation_history.remove_contextual_info,
+            conversation_history.write_contextual_note,
         ],
     )
     try:

zrb/task/llm/print_node.py

@@ -14,6 +14,7 @@ async def print_node(print_func: Callable, agent_run: Any, node: Any):
         PartDeltaEvent,
         PartStartEvent,
         TextPartDelta,
+        ThinkingPartDelta,
         ToolCallPartDelta,
     )
 
@@ -33,7 +34,9 @@ async def print_node(print_func: Callable, agent_run: Any, node: Any):
                     )
                     is_streaming = False
                 elif isinstance(event, PartDeltaEvent):
-                    if isinstance(event.delta, TextPartDelta):
+                    if isinstance(event.delta, TextPartDelta) or isinstance(
+                        event.delta, ThinkingPartDelta
+                    ):
                         print_func(
                             stylize_faint(f"{event.delta.content_delta}"),
                             end="",

zrb/task/llm/tool_wrapper.py

@@ -21,16 +21,19 @@ def wrap_tool(func: Callable, ctx: AnyContext) -> "Tool":
     from pydantic_ai import RunContext, Tool
 
     original_sig = inspect.signature(func)
-    # Use helper function for clarity
     needs_run_context_for_pydantic = _has_context_parameter(original_sig, RunContext)
+    wrapper = wrap_func(func, ctx)
+    return Tool(wrapper, takes_ctx=needs_run_context_for_pydantic)
+
+
+def wrap_func(func: Callable, ctx: AnyContext) -> Callable:
+    original_sig = inspect.signature(func)
     needs_any_context_for_injection = _has_context_parameter(original_sig, AnyContext)
     takes_no_args = len(original_sig.parameters) == 0
     # Pass individual flags to the wrapper creator
     wrapper = _create_wrapper(func, original_sig, ctx, needs_any_context_for_injection)
-    # Adjust signature - _adjust_signature determines exclusions based on type
     _adjust_signature(wrapper, original_sig, takes_no_args)
-    # takes_ctx in pydantic-ai Tool is specifically for RunContext
-    return Tool(wrapper, takes_ctx=needs_run_context_for_pydantic)
+    return wrapper
 
 
 def _has_context_parameter(original_sig: inspect.Signature, context_type: type) -> bool:
@@ -98,9 +101,12 @@ def _create_wrapper(
                 func_name = get_callable_name(func)
                 ctx.print(f"✅ >> Allow to run tool: {func_name} (Y/n)", plain=True)
                 user_confirmation_str = await _read_line()
-                user_confirmation = to_boolean(user_confirmation_str)
+                try:
+                    user_confirmation = to_boolean(user_confirmation_str)
+                except Exception:
+                    user_confirmation = False
                 if not user_confirmation:
-                    ctx.print("❌ >> Why?", plain=True)
+                    ctx.print(f"❌ >> Rejecting {func_name} call. Why?", plain=True)
                     reason = await _read_line()
                     ctx.print("", plain=True)
                     raise ValueError(f"User disapproval: {reason}")

zrb/task/llm_task.py

@@ -31,9 +31,9 @@ from zrb.xcom.xcom import Xcom
 
 if TYPE_CHECKING:
     from pydantic_ai import Agent, Tool
-    from pydantic_ai.mcp import MCPServer
     from pydantic_ai.models import Model
     from pydantic_ai.settings import ModelSettings
+    from pydantic_ai.toolsets import AbstractToolset
 
     ToolOrCallable = Tool | Callable
 else:
@@ -76,8 +76,8 @@ class LLMTask(BaseTask):
             list["ToolOrCallable"]
             | Callable[[AnySharedContext], list["ToolOrCallable"]]
         ) = [],
-        mcp_servers: (
-            list["MCPServer"] | Callable[[AnySharedContext], list["MCPServer"]]
+        toolsets: (
+            list["AbstractToolset[Agent]"] | Callable[[AnySharedContext], list["Tool"]]
         ) = [],
         conversation_history: (
             ConversationHistory
@@ -162,8 +162,8 @@ class LLMTask(BaseTask):
         self._tools = tools
         self._rate_limitter = rate_limitter
         self._additional_tools: list["ToolOrCallable"] = []
-        self._mcp_servers = mcp_servers
-        self._additional_mcp_servers: list["MCPServer"] = []
+        self._toolsets = toolsets
+        self._additional_toolsets: list["AbstractToolset[Agent]"] = []
         self._conversation_history = conversation_history
         self._conversation_history_reader = conversation_history_reader
         self._conversation_history_writer = conversation_history_writer
@@ -187,12 +187,12 @@ class LLMTask(BaseTask):
         for single_tool in tool:
             self._additional_tools.append(single_tool)
 
-    def add_mcp_server(self, *mcp_server: "MCPServer"):
-        self.append_mcp_server(*mcp_server)
+    def add_toolset(self, *toolset: "AbstractToolset[Agent]"):
+        self.append_toolset(*toolset)
 
-    def append_mcp_server(self, *mcp_server: "MCPServer"):
-        for single_mcp_server in mcp_server:
-            self._additional_mcp_servers.append(single_mcp_server)
+    def append_toolset(self, *toolset: "AbstractToolset[Agent]"):
+        for single_toolset in toolset:
+            self._additional_toolsets.append(single_toolset)
 
     def set_should_summarize_history(self, summarize_history: bool):
         self._should_summarize_history = summarize_history
@@ -252,8 +252,8 @@ class LLMTask(BaseTask):
             model_settings=model_settings,
             tools_attr=self._tools,
             additional_tools=self._additional_tools,
-            mcp_servers_attr=self._mcp_servers,
-            additional_mcp_servers=self._additional_mcp_servers,
+            toolsets_attr=self._toolsets,
+            additional_toolsets=self._additional_toolsets,
         )
         # 4. Run the agent iteration and save the results/history
         result = await self._execute_agent(

zrb/util/llm/prompt.py

@@ -1,7 +1,7 @@
 import re
 
 
-def _demote_markdown_headers(md: str) -> str:
+def _adjust_markdown_headers(md: str, level_change: int) -> str:
     lines = md.split("\n")
     new_lines = []
     fence_stack = []
@@ -11,7 +11,6 @@ def _demote_markdown_headers(md: str) -> str:
 
         if fence_match:
             current_fence = fence_match.group(1)
-            # If stack is not empty and we found a closing fence
             if (
                 fence_stack
                 and fence_stack[-1][0] == current_fence[0]
@@ -21,18 +20,28 @@ def _demote_markdown_headers(md: str) -> str:
             else:
                 fence_stack.append(current_fence)
             new_lines.append(line)
+        elif fence_stack:
+            new_lines.append(line)
         else:
-            if fence_stack:  # If we are inside a code block
-                new_lines.append(line)
+            match = re.match(r"^(#{1,6})(\s)", line)
+            if match:
+                current_level = len(match.group(1))
+                new_level = max(1, current_level + level_change)
+                new_header = "#" * new_level + line[current_level:]
+                new_lines.append(new_header)
             else:
-                match = re.match(r"^(#{1,6})(\s)", line)
-                if match:
-                    new_lines.append("#" + line)
-                else:
-                    new_lines.append(line)
+                new_lines.append(line)
     return "\n".join(new_lines)
 
 
+def demote_markdown_headers(md: str) -> str:
+    return _adjust_markdown_headers(md, level_change=1)
+
+
+def promote_markdown_headers(md: str) -> str:
+    return _adjust_markdown_headers(md, level_change=-1)
+
+
 def make_prompt_section(header: str, content: str, as_code: bool = False) -> str:
     if content.strip() == "":
         return ""
@@ -51,4 +60,4 @@ def make_prompt_section(header: str, content: str, as_code: bool = False) -> str
             fence_len = longest_backtick_sequence + 1
         fence = "`" * fence_len
         return f"# {header}\n{fence}\n{content.strip()}\n{fence}\n"
-    return f"# {header}\n{_demote_markdown_headers(content.strip())}\n"
+    return f"# {header}\n{demote_markdown_headers(content.strip())}\n"

{zrb-1.12.0.dist-info → zrb-1.13.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: zrb
-Version: 1.12.0
+Version: 1.13.0
 Summary: Your Automation Powerhouse
 Home-page: https://github.com/state-alchemists/zrb
 License: AGPL-3.0-or-later
@@ -19,7 +19,7 @@ Provides-Extra: rag
 Requires-Dist: beautifulsoup4 (>=4.13.3,<5.0.0)
 Requires-Dist: black (>=25.1.0,<25.2.0)
 Requires-Dist: chromadb (>=0.6.3,<0.7.0) ; extra == "rag" or extra == "all"
-Requires-Dist: fastapi[standard] (>=0.115.14,<0.116.0)
+Requires-Dist: fastapi[standard] (>=0.116.1,<0.117.0)
 Requires-Dist: isort (>=6.0.1,<6.1.0)
 Requires-Dist: libcst (>=1.7.0,<2.0.0)
 Requires-Dist: openai (>=1.86.0,<2.0.0) ; extra == "rag" or extra == "all"
@@ -27,7 +27,7 @@ Requires-Dist: pdfplumber (>=0.11.6,<0.12.0) ; extra == "rag" or extra == "all"
 Requires-Dist: playwright (>=1.53.0,<2.0.0) ; extra == "playwright" or extra == "all"
 Requires-Dist: prompt-toolkit (>=3.0.51,<4.0.0)
 Requires-Dist: psutil (>=7.0.0,<8.0.0)
-Requires-Dist: pydantic-ai (>=0.4.4,<0.5.0)
+Requires-Dist: pydantic-ai (>=0.4.5,<0.5.0)
 Requires-Dist: pyjwt (>=2.10.1,<3.0.0)
 Requires-Dist: python-dotenv (>=1.1.1,<2.0.0)
 Requires-Dist: python-jose[cryptography] (>=3.4.0,<4.0.0)

{zrb-1.12.0.dist-info → zrb-1.13.0.dist-info}/RECORD

@@ -20,7 +20,7 @@ zrb/builtin/llm/tool/cli.py,sha256=dUWZrW2X5J_lONuzR__6-SbewSdi28E3RRuksjd4mWo,1
 zrb/builtin/llm/tool/code.py,sha256=GRP_IZAkeL6RIlUm407BQRF992ES57pdzPaQdC5UsJU,8218
 zrb/builtin/llm/tool/file.py,sha256=XfTuoQOHmgiAYkfi_1ew2voxOwad5vWTe_3Ww8IeVQY,22274
 zrb/builtin/llm/tool/rag.py,sha256=wB74JV7bxs0ec77b_09Z2lPjoR1WzPUvZbuXOdb9Q9g,9675
-zrb/builtin/llm/tool/sub_agent.py,sha256=UWBLiuCK6FT8Ku0yPfSxd_k67h_Pme1K7d2VSABacjQ,4855
+zrb/builtin/llm/tool/sub_agent.py,sha256=9Su64FpNTVeE6O2qgNzo-eo4pcmv8qi_sd_QWLQBXYw,4870
 zrb/builtin/llm/tool/web.py,sha256=gQlUsmYCJOFJtNjwpjK-xk13LMvrMSpSaFHXUTnIayQ,7090
 zrb/builtin/md5.py,sha256=690RV2LbW7wQeTFxY-lmmqTSVEEZv3XZbjEUW1Q3XpE,1480
 zrb/builtin/project/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -219,15 +219,15 @@ zrb/cmd/cmd_result.py,sha256=L8bQJzWCpcYexIxHBNsXj2pT3BtLmWex0iJSMkvimOA,597
 zrb/cmd/cmd_val.py,sha256=7Doowyg6BK3ISSGBLt-PmlhzaEkBjWWm51cED6fAUOQ,1014
 zrb/config/config.py,sha256=d_F-hdPLADjeVRHtnpOxtOkfUBu5huSLclyD53uxO4U,12306
 zrb/config/default_prompt/file_extractor_system_prompt.md,sha256=tmeZMPzF9MGExsZZw7M2PZN6V0oFVRp1nIjiqUPvQ9M,1013
-zrb/config/default_prompt/interactive_system_prompt.md,sha256=NlG5cQ4imEGF9CIRwqH03UZ5XRtqLu1gIin3nBDtQlI,2795
+zrb/config/default_prompt/interactive_system_prompt.md,sha256=ZFPeDEV2vlcksHiVG2o-TCehmqkFolDjtH0_Fzo1gGI,3566
 zrb/config/default_prompt/persona.md,sha256=WU4JKp-p7qJePDA6NZ_CYdBggo2B3PEq8IEnNVblIHU,41
 zrb/config/default_prompt/repo_extractor_system_prompt.md,sha256=EGZ-zj78RlMEg2jduRBs8WzO4VJTkXHR96IpBepZMsY,3881
 zrb/config/default_prompt/repo_summarizer_system_prompt.md,sha256=fpG5B416OK3oE41bWPrh1M6pdH5SSadCPte_NJ_79z0,858
-zrb/config/default_prompt/summarization_prompt.md,sha256=3-swyZ2m9DQFkaN68kn-AxnFHTcQYqrPSzV3qwT-vw4,2122
-zrb/config/default_prompt/system_prompt.md,sha256=uRRiVSTs_4s2DYBO-1cPuOGPVkaelA_UuGClLawfw3o,2283
+zrb/config/default_prompt/summarization_prompt.md,sha256=hRXH5E78TugSze_Hgp-KTbIhCeyrMcJg-pSXvXH3C9E,1629
+zrb/config/default_prompt/system_prompt.md,sha256=Jkne5n9HJcBCgfeENwxvqH-kbDO2CaiUzqR4VoWMRHY,3054
 zrb/config/llm_config.py,sha256=bNLxorctwtVW1F9hA-hEYpDBe7FLSZHC25Nx8NlR4-M,8597
-zrb/config/llm_context/config.py,sha256=swc3hUaEIoL2MjKtbati13iP0MxveNG_y_6K3nszRAw,2571
-zrb/config/llm_context/config_handler.py,sha256=oQesfigIM0qMw_A3jUCN0UDJujRjuJ3jr5mXHBiLgB0,8866
+zrb/config/llm_context/config.py,sha256=zeqSVOKK5yyApvqTbcO3ayGxtyoag22qlWWaXp1nINs,4950
+zrb/config/llm_context/config_parser.py,sha256=h95FbOjvVobhrsfGtG_BY3hxS-OLzQj-9F5vGZuehkY,1473
 zrb/config/llm_rate_limitter.py,sha256=P4vR7qxwiGwjlKx2kHcfdIxwGbJB98vdN-UQEH-Q2WU,4894
 zrb/config/web_auth_config.py,sha256=_PXatQTYh2mX9H3HSYSQKp13zm1RlLyVIoeIr6KYMQ8,6279
 zrb/content_transformer/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -237,7 +237,7 @@ zrb/context/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 zrb/context/any_context.py,sha256=2hgVKbbDwmwrEl1h1L1FaTUjuUYaDd_b7YRGkaorW6Q,6362
 zrb/context/any_shared_context.py,sha256=wJawL1jGgApcKPRcpw3js7W4-MhJRA3GMbR5zTsJmt0,1929
 zrb/context/context.py,sha256=ErGhXJgjgNaAqi6iPMejWxFZ3YvWnysC6mHEU-wodKk,6884
-zrb/context/shared_context.py,sha256=Pn0LHEYikiB3LLGnfpJVzOFgxyosQ_NYvFtKFMK_X8w,3008
+zrb/context/shared_context.py,sha256=Jaa7AYCeCksOiEAwOnY3xD6Y2Yy2wJAkpehAkbKQ-Wc,3076
 zrb/dot_dict/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 zrb/dot_dict/dot_dict.py,sha256=ubw_x8I7AOJ59xxtFVJ00VGmq_IYdZP3mUhNlO4nEK0,556
 zrb/env/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -346,20 +346,20 @@ zrb/task/base_trigger.py,sha256=WSGcmBcGAZw8EzUXfmCjqJQkz8GEmi1RzogpF6A1V4s,6902
 zrb/task/cmd_task.py,sha256=myM8WZm6NrUD-Wv0Vb5sTOrutrAVZLt5LVsSBKwX6SM,10860
 zrb/task/http_check.py,sha256=Gf5rOB2Se2EdizuN9rp65HpGmfZkGc-clIAlHmPVehs,2565
 zrb/task/llm/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-zrb/task/llm/agent.py,sha256=A5UoHY-l8WqyptKrf42eHVW_VhMhuYsygs2Z8XNnCzk,6681
+zrb/task/llm/agent.py,sha256=aZvtcL5HmZQvD3c79R9sDIOMawO0rUMcRiq2wZ1FNas,7457
 zrb/task/llm/config.py,sha256=TlyH925_fboIlK2Ixf34tynmenqs9s9rfsnPs4jff78,3490
 zrb/task/llm/conversation_history.py,sha256=B_PDWYL_q66s0xwWBzMSomqPN6u3gkXlIeXBD5A0Apg,4416
-zrb/task/llm/conversation_history_model.py,sha256=AU5-M4Ky3X4wII1PMT75VU5OUEG0FjqdHrrpCSl-u6M,10771
+zrb/task/llm/conversation_history_model.py,sha256=DJ0KDBB0BriQuE5ugC_q0aSHhjNIBcfjUk1f0S_3I9U,9245
 zrb/task/llm/default_workflow/coding.md,sha256=2uythvPsnBpYfIhiIH1cCinQXX0i0yUqsL474Zpemw0,2484
 zrb/task/llm/default_workflow/copywriting.md,sha256=xSO7GeDolwGxiuz6kXsK2GKGpwp8UgtG0yRqTmill_s,1999
 zrb/task/llm/default_workflow/researching.md,sha256=KD-aYHFHir6Ti-4FsBBtGwiI0seSVgleYbKJZi_POXA,2139
 zrb/task/llm/error.py,sha256=QR-nIohS6pBpC_16cWR-fw7Mevo1sNYAiXMBsh_CJDE,4157
-zrb/task/llm/history_summarization.py,sha256=BUwBOS51Jzp4psliD_h1jWq-5oHezNbjF1fkn7vbh7o,8109
-zrb/task/llm/print_node.py,sha256=zocTKi9gZDxl2I6KNu095TmMc13Yip6SNuWYnswS680,4060
+zrb/task/llm/history_summarization.py,sha256=_0RmzIeJdJA3KvtdTdKnd2Ga7_7x8C1J2PM0oSn-IYw,8000
+zrb/task/llm/print_node.py,sha256=mwdqsO2IVf5rDz-jdH9HXz6MFGCWrZ4Pv2xbUBtoNgc,4179
 zrb/task/llm/prompt.py,sha256=sMipP-NJmq4ZmCtQYEG2mcHWUD79yJRwH7nH-iw-7Z4,9661
-zrb/task/llm/tool_wrapper.py,sha256=N6IuWJXFDcGUJyMJnnWmpJLsqas1QNCEj0MNL3T2nXI,6647
+zrb/task/llm/tool_wrapper.py,sha256=jfKMAtTzm--HnF6TppOrbkDVsuTOIFRpowQqgwqd-7s,6756
 zrb/task/llm/typing.py,sha256=c8VAuPBw_4A3DxfYdydkgedaP-LU61W9_wj3m3CAX1E,58
-zrb/task/llm_task.py,sha256=Zxmp7c7XOz5_jAX1kzwwNfD9GJ1Tok-C4e_MfqhliNk,13532
+zrb/task/llm_task.py,sha256=jVuVeN2ylcPkycUiaTpavkkd1tBLbvcVsjMNN5FMHnk,13536
 zrb/task/make_task.py,sha256=PD3b_aYazthS8LHeJsLAhwKDEgdurQZpymJDKeN60u0,2265
 zrb/task/rsync_task.py,sha256=WfqNSaicJgYWpunNU34eYxXDqHDHOftuDHyWJKjqwg0,6365
 zrb/task/scaffolder.py,sha256=rME18w1HJUHXgi9eTYXx_T2G4JdqDYzBoNOkdOOo5-o,6806
@@ -395,7 +395,7 @@ zrb/util/git_subtree.py,sha256=AyQWCWEi2EIzEpYXRnYN55157KMUql0WHj70QNw5PHU,4612
 zrb/util/git_subtree_model.py,sha256=P_gJ0zhOAc3gFM6sYcjc0Ack9dFBt75TI5fXdE0q320,871
 zrb/util/group.py,sha256=T82yr3qg9I5k10VPXkMyrIRIqyfzadSH813bqzwKEPI,4718
 zrb/util/init_path.py,sha256=9eN7CkWNGhDBpjTQs2j9YHVMzui7Y8DEb1WP4aTPzeo,659
-zrb/util/llm/prompt.py,sha256=AqDcBi2IkPISCVNZ_Ccz9Q2zFHjowPMReGHZtNndD_k,1921
+zrb/util/llm/prompt.py,sha256=HMpKby27DE8lJWpytYKylp7Iw9ENwsYQI0nMMKCCi54,2190
 zrb/util/load.py,sha256=DK0KYSlu48HCoGPqnW1IxnE3pHrZSPCstfz8Fjyqqv8,2140
 zrb/util/run.py,sha256=vu-mcSWDP_WuuvIKqM_--Gk3WkABO1oTXiHmBRTvVQk,546
 zrb/util/string/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -406,7 +406,7 @@ zrb/util/todo.py,sha256=r9_KYF2-hLKMNjsp6AFK9zivykMrywd-kJ4bCwfdafI,19323
 zrb/util/todo_model.py,sha256=hhzAX-uFl5rsg7iVX1ULlJOfBtblwQ_ieNUxBWfc-Os,1670
 zrb/xcom/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 zrb/xcom/xcom.py,sha256=o79rxR9wphnShrcIushA0Qt71d_p3ZTxjNf7x9hJB78,1571
-zrb-1.12.0.dist-info/METADATA,sha256=ZegE-xKhBfEIGj-PXDaNKUmoQsJgWYR6_4E0V4-2Awk,9778
-zrb-1.12.0.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-zrb-1.12.0.dist-info/entry_points.txt,sha256=-Pg3ElWPfnaSM-XvXqCxEAa-wfVI6BEgcs386s8C8v8,46
-zrb-1.12.0.dist-info/RECORD,,
+zrb-1.13.0.dist-info/METADATA,sha256=L9X70AkHGlYTjK0tdgjlwA_Sj4U0Ao9FtPuk-g0UmJ0,9777
+zrb-1.13.0.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+zrb-1.13.0.dist-info/entry_points.txt,sha256=-Pg3ElWPfnaSM-XvXqCxEAa-wfVI6BEgcs386s8C8v8,46
+zrb-1.13.0.dist-info/RECORD,,

zrb/config/llm_context/config_handler.py

@@ -1,238 +0,0 @@
-import os
-import re
-from typing import Callable, Generator, NamedTuple
-
-
-class Section(NamedTuple):
-    name: str
-    key: str
-    content: str
-    config_file: str
-
-
-def _parse_config_file(
-    config_file: str, lines: list[str]
-) -> Generator[Section, None, None]:
-    """
-    Parses a config file's lines, yielding sections.
-    It correctly handles markdown code fences.
-    """
-    any_header_pattern = re.compile(r"^# (\w+):\s*(.*)")
-    fence_pattern = re.compile(r"^([`~]{3,})")
-    fence_stack = []
-    active_section_name = None
-    active_section_key = None
-    active_section_content = []
-
-    for line in lines:
-        stripped_line = line.strip()
-        fence_match = fence_pattern.match(stripped_line)
-
-        if fence_match:
-            current_fence = fence_match.group(1)
-            if (
-                fence_stack
-                and fence_stack[-1][0] == current_fence[0]
-                and len(current_fence) >= len(fence_stack[-1])
-            ):
-                fence_stack.pop()
-            else:
-                fence_stack.append(current_fence)
-
-        if fence_stack:
-            if active_section_key is not None:
-                active_section_content.append(line)
-            continue
-
-        match = any_header_pattern.match(line)
-        if match:
-            if active_section_key is not None:
-                content = "".join(active_section_content).strip()
-                if content:
-                    yield Section(
-                        name=active_section_name,
-                        key=active_section_key,
-                        content=content,
-                        config_file=config_file,
-                    )
-
-            active_section_name = match.group(1)
-            active_section_key = match.group(2).strip()
-            active_section_content = []
-        elif active_section_key is not None:
-            active_section_content.append(line)
-
-    if active_section_key is not None:
-        content = "".join(active_section_content).strip()
-        if content:
-            yield Section(
-                name=active_section_name,
-                key=active_section_key,
-                content=content,
-                config_file=config_file,
-            )
-
-
-def _get_config_file_hierarchy(path: str, config_file_name: str) -> list[str]:
-    """Finds all config files from a given path up to the home directory."""
-    config_files = []
-    home_dir = os.path.expanduser("~")
-    current_path = os.path.abspath(path)
-    while True:
-        config_path = os.path.join(current_path, config_file_name)
-        if os.path.exists(config_path):
-            config_files.append(config_path)
-        if current_path == home_dir:
-            break
-        parent = os.path.dirname(current_path)
-        if parent == current_path:  # Reached root
-            break
-        current_path = parent
-    return config_files
-
-
-class LLMContextConfigHandler:
-    """Handles the logic for a specific section of the config."""
-
-    def __init__(
-        self,
-        section_name: str,
-        config_file_name: str = "ZRB.md",
-        filter_section_func: Callable[[str, str], bool] | None = None,
-        resolve_section_path: bool = True,
-    ):
-        self._section_name = section_name
-        self._config_file_name = config_file_name
-        self._filter_func = filter_section_func
-        self._resolve_section_path = resolve_section_path
-
-    def _include_section(self, section_path: str, base_path: str) -> bool:
-        if self._filter_func:
-            return self._filter_func(section_path, base_path)
-        return True
-
-    def get_section(self, cwd: str) -> dict[str, str]:
-        """Gathers all relevant sections for a given path."""
-        abs_path = os.path.abspath(cwd)
-        all_sections = {}
-        config_files = _get_config_file_hierarchy(abs_path, self._config_file_name)
-
-        for config_file in reversed(config_files):
-            if not os.path.exists(config_file):
-                continue
-            with open(config_file, "r") as f:
-                lines = f.readlines()
-
-            for section in _parse_config_file(config_file, lines):
-                if section.name != self._section_name:
-                    continue
-
-                config_dir = os.path.dirname(section.config_file)
-                key = (
-                    os.path.abspath(os.path.join(config_dir, section.key))
-                    if self._resolve_section_path
-                    else section.key
-                )
-
-                if self._include_section(key, abs_path):
-                    if key in all_sections:
-                        all_sections[key] = f"{all_sections[key]}\n{section.content}"
-                    else:
-                        all_sections[key] = section.content
-
-        return all_sections
-
-    def add_to_section(self, content: str, key: str, cwd: str):
-        """Adds content to a section block in the nearest configuration file."""
-        abs_search_path = os.path.abspath(cwd)
-        config_files = _get_config_file_hierarchy(
-            abs_search_path, self._config_file_name
-        )
-        closest_config_file = (
-            config_files[0]
-            if config_files
-            else os.path.join(os.path.expanduser("~"), self._config_file_name)
-        )
-
-        config_dir = os.path.dirname(closest_config_file)
-        header_key = key
-        if self._resolve_section_path and os.path.isabs(key):
-            if key == config_dir:
-                header_key = "."
-            elif key.startswith(config_dir):
-                header_key = f"./{os.path.relpath(key, config_dir)}"
-        header = f"# {self._section_name}: {header_key}"
-        new_content = content.strip()
-        lines = []
-        if os.path.exists(closest_config_file):
-            with open(closest_config_file, "r") as f:
-                lines = f.readlines()
-        header_index = next(
-            (i for i, line in enumerate(lines) if line.strip() == header), -1
-        )
-        if header_index != -1:
-            insert_index = len(lines)
-            for i in range(header_index + 1, len(lines)):
-                if re.match(r"^# \w+:", lines[i].strip()):
-                    insert_index = i
-                    break
-            if insert_index > 0 and lines[insert_index - 1].strip():
-                lines.insert(insert_index, f"\n{new_content}\n")
-            else:
-                lines.insert(insert_index, f"{new_content}\n")
-        else:
-            if lines and lines[-1].strip():
-                lines.append("\n\n")
-            lines.append(f"{header}\n")
-            lines.append(f"{new_content}\n")
-        with open(closest_config_file, "w") as f:
-            f.writelines(lines)
-
-    def remove_from_section(self, content: str, key: str, cwd: str) -> bool:
-        """Removes content from a section block in all relevant config files."""
-        abs_search_path = os.path.abspath(cwd)
-        config_files = _get_config_file_hierarchy(
-            abs_search_path, self._config_file_name
-        )
-        content_to_remove = content.strip()
-        was_removed = False
-        for config_file_path in config_files:
-            if not os.path.exists(config_file_path):
-                continue
-            with open(config_file_path, "r") as f:
-                file_content = f.read()
-            config_dir = os.path.dirname(config_file_path)
-            header_key = key
-            if self._resolve_section_path and os.path.isabs(key):
-                if key == config_dir:
-                    header_key = "."
-                elif key.startswith(config_dir):
-                    header_key = f"./{os.path.relpath(key, config_dir)}"
-            header = f"# {self._section_name}: {header_key}"
-            # Use regex to find the section content
-            section_pattern = re.compile(
-                rf"^{re.escape(header)}\n(.*?)(?=\n# \w+:|\Z)",
-                re.DOTALL | re.MULTILINE,
-            )
-            match = section_pattern.search(file_content)
-            if not match:
-                continue
-
-            section_content = match.group(1)
-            # Remove the target content and handle surrounding newlines
-            new_section_content = section_content.replace(content_to_remove, "")
-            new_section_content = "\n".join(
-                line for line in new_section_content.splitlines() if line.strip()
-            )
-
-            if new_section_content != section_content.strip():
-                was_removed = True
-                # Reconstruct the file content
-                start = match.start(1)
-                end = match.end(1)
-                new_file_content = (
-                    file_content[:start] + new_section_content + file_content[end:]
-                )
-                with open(config_file_path, "w") as f:
-                    f.write(new_file_content)
-        return was_removed