zrb 1.12.0__tar.gz → 1.13.1__tar.gz

{zrb-1.12.0 → zrb-1.13.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: zrb
-Version: 1.12.0
+Version: 1.13.1
 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 → zrb-1.13.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "zrb"
-version = "1.12.0"
+version = "1.13.1"
 description = "Your Automation Powerhouse"
 authors = ["Go Frendi Gunawan <gofrendiasgard@gmail.com>"]
 license = "AGPL-3.0-or-later"
@@ -46,10 +46,10 @@ libcst = "^1.7.0"
 chromadb = {version = "^0.6.3", optional = true}
 pdfplumber = {version = "^0.11.6", optional = true}
 beautifulsoup4 = "^4.13.3"
-fastapi = {extras = ["standard"], version = "^0.115.14"}
+fastapi = {extras = ["standard"], version = "^0.116.1"}
 python-jose = {extras = ["cryptography"], version = "^3.4.0"}
 ulid-py = "^1.1.0"
-pydantic-ai = "^0.4.4"
+pydantic-ai = "^0.4.5"
 tiktoken = "^0.8.0"
 openai = {version = "^1.86.0", optional = true}
 playwright = {version = "^1.53.0", optional = true}

{zrb-1.12.0 → zrb-1.13.1}/src/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-1.12.0 → zrb-1.13.1}/src/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-1.13.1/src/zrb/config/default_prompt/summarization_prompt.md

@@ -0,0 +1,16 @@
+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-1.12.0 → zrb-1.13.1}/src/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-1.13.1/src/zrb/config/llm_context/config.py

@@ -0,0 +1,129 @@
+import os
+
+from zrb.config.config import CFG
+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."""
+
+    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()
+        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()
+        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 write_context(
+        self, content: str, context_path: str | None = None, cwd: str | None = None
+    ):
+        """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
+
+        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-1.13.1/src/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-1.12.0 → zrb-1.13.1}/src/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-1.12.0 → zrb-1.13.1}/src/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-1.12.0 → zrb-1.13.1}/src/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-1.12.0 → zrb-1.13.1}/src/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-1.12.0 → zrb-1.13.1}/src/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-1.12.0 → zrb-1.13.1}/src/zrb/task/llm/prompt.py

@@ -75,6 +75,8 @@ def get_modes(
         modes_attr,
         auto_render=render_modes,
     )
+    if raw_modes is None:
+        raw_modes = []
     modes = [mode.strip() for mode in raw_modes if mode.strip() != ""]
     if len(modes) > 0:
         return modes

{zrb-1.12.0 → zrb-1.13.1}/src/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}")