zrb 1.21.29__py3-none-any.whl → 2.0.0a4__py3-none-any.whl

zrb/builtin/llm/tool/sub_agent.py

@@ -1,150 +0,0 @@
-import json
-from collections.abc import Callable
-from textwrap import dedent
-from typing import TYPE_CHECKING, Any, Coroutine
-
-from zrb.context.any_context import AnyContext
-from zrb.task.llm.agent import create_agent_instance
-from zrb.task.llm.agent_runner import run_agent_iteration
-from zrb.task.llm.config import get_model, get_model_settings
-from zrb.task.llm.prompt import get_system_and_user_prompt
-from zrb.task.llm.subagent_conversation_history import (
-    get_ctx_subagent_history,
-    set_ctx_subagent_history,
-)
-
-if TYPE_CHECKING:
-    from pydantic_ai import Tool
-    from pydantic_ai._agent_graph import HistoryProcessor
-    from pydantic_ai.models import Model
-    from pydantic_ai.settings import ModelSettings
-    from pydantic_ai.toolsets import AbstractToolset
-
-    ToolOrCallable = Tool | Callable
-
-
-def create_sub_agent_tool(
-    tool_name: str,
-    tool_description: str,
-    system_prompt: str | None = None,
-    model: "str | Model | None" = None,
-    model_settings: "ModelSettings | None" = None,
-    tools: "list[ToolOrCallable]" = [],
-    toolsets: list["AbstractToolset[None]"] = [],
-    yolo_mode: bool | list[str] | None = None,
-    history_processors: list["HistoryProcessor"] | None = None,
-    log_indent_level: int = 2,
-    agent_name: str | None = None,
-    auto_summarize: bool = True,
-    remember_history: bool = True,
-) -> Callable[[AnyContext, str], Coroutine[Any, Any, Any]]:
-    """
-    Create a tool that is another AI agent, capable of handling complex, multi-step sub-tasks.
-
-    This factory function generates a tool that, when used, spins up a temporary, specialized
-    AI agent. This "sub-agent" has its own system prompt, tools, and context, allowing it to
-    focus on accomplishing a specific task without being distracted by the main conversation.
-
-    This is ideal for delegating complex tasks like analyzing a file or a repository.
-
-    Args:
-        tool_name (str): The name for the generated sub-agent tool.
-        tool_description (str): A clear description of the sub-agent's purpose and when to
-            use it. This is what the LLM will see.
-        system_prompt (str, optional): The system prompt that will guide the sub-agent's
-            behavior.
-        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.
-        toolsets (list, optional): A list of Toolsets for the sub-agent.
-
-    Returns:
-        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.
-    """
-    if agent_name is None:
-        agent_name = f"{tool_name}_agent"
-
-    async def run_sub_agent(ctx: AnyContext, query: str) -> Any:
-        """
-        Runs the sub-agent with the given query.
-        """
-        # Resolve parameters, falling back to llm_config defaults if None
-        resolved_model = get_model(
-            ctx=ctx,
-            model_attr=model,
-            render_model=True,  # Assuming we always want to render model string attributes
-            model_base_url_attr=None,
-            # Sub-agent tool doesn't have separate base_url/api_key params
-            render_model_base_url=False,
-            model_api_key_attr=None,
-            render_model_api_key=False,
-        )
-        resolved_model_settings = get_model_settings(
-            ctx=ctx,
-            model_settings_attr=model_settings,
-        )
-        if system_prompt is None:
-            resolved_system_prompt, query = get_system_and_user_prompt(
-                ctx=ctx,
-                user_message=query,
-                persona_attr=None,
-                system_prompt_attr=None,
-                special_instruction_prompt_attr=None,
-            )
-        else:
-            resolved_system_prompt = system_prompt
-        # Create the sub-agent instance
-        sub_agent_agent = create_agent_instance(
-            ctx=ctx,
-            model=resolved_model,
-            system_prompt=resolved_system_prompt,
-            model_settings=resolved_model_settings,
-            tools=tools,
-            toolsets=toolsets,
-            yolo_mode=yolo_mode,
-            history_processors=history_processors,
-            auto_summarize=auto_summarize,
-        )
-        sub_agent_run = None
-        # Run the sub-agent iteration
-        history_list = (
-            get_ctx_subagent_history(ctx, agent_name) if remember_history else []
-        )
-        sub_agent_run = await run_agent_iteration(
-            ctx=ctx,
-            agent=sub_agent_agent,
-            user_prompt=query,
-            attachments=[],
-            history_list=history_list,
-            log_indent_level=log_indent_level,
-        )
-        # Return the sub-agent's final message content
-        if sub_agent_run and sub_agent_run.result:
-            # Return the final message content
-            if remember_history:
-                set_ctx_subagent_history(
-                    ctx,
-                    agent_name,
-                    json.loads(sub_agent_run.result.all_messages_json()),
-                )
-            return sub_agent_run.result.output
-        ctx.log_warning("Sub-agent run did not produce a result.")
-        raise ValueError(f"{tool_name} not returning any result")
-
-    # Set the name and docstring for the callable function
-    run_sub_agent.__name__ = tool_name
-    run_sub_agent.__doc__ = dedent(
-        f"""
-        {tool_description}
-
-        Args:
-            query (str): The query or task for the sub-agent.
-
-        Returns:
-            Any: The final response or result from the sub-agent.
-        """
-    ).strip()
-
-    return run_sub_agent

zrb/builtin/llm/tool/web.py

@@ -1,171 +0,0 @@
-from collections.abc import Callable
-from typing import Any
-from urllib.parse import urljoin
-
-from zrb.config.config import CFG
-from zrb.config.llm_config import llm_config
-
-_DEFAULT_USER_AGENT = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36"  # noqa
-
-
-async def open_web_page(url: str) -> dict[str, Any]:
-    """
-    Fetches, parses, and converts a web page to readable Markdown.
-    Preserves semantic structure, removes non-essentials, and extracts all absolute links.
-
-    Example:
-    open_web_page(url='https://www.example.com/article')
-
-    Args:
-        url (str): The full URL of the web page.
-
-    Returns:
-        dict: Markdown content and a list of absolute links.
-    """
-    html_content, links = await _fetch_page_content(url)
-    markdown_content = _convert_html_to_markdown(html_content)
-    return {"content": markdown_content, "links_on_page": links}
-
-
-def create_search_internet_tool() -> Callable:
-    if llm_config.default_search_internet_tool is not None:
-        return llm_config.default_search_internet_tool
-
-    def search_internet(query: str, page: int = 1) -> dict[str, Any]:
-        """
-        Performs an internet search using a search engine.
-        Use to find information, answer general knowledge, or research topics.
-
-        Example:
-        search_internet(query='latest AI advancements', page=1)
-
-        Args:
-            query (str): The search query.
-            page (int, optional): Search result page number. Defaults to 1.
-
-        Returns:
-            dict: Summary of search results (titles, links, snippets).
-        """
-        import requests
-
-        if (
-            CFG.SEARCH_INTERNET_METHOD.strip().lower() == "serpapi"
-            and CFG.SERPAPI_KEY != ""
-        ):
-            response = requests.get(
-                "https://serpapi.com/search",
-                headers={"User-Agent": _DEFAULT_USER_AGENT},
-                params={
-                    "q": query,
-                    "start": (page - 1) * 10,
-                    "hl": CFG.SERPAPI_LANG,
-                    "safe": CFG.SERPAPI_SAFE,
-                    "api_key": CFG.SERPAPI_KEY,
-                },
-            )
-        elif (
-            CFG.SEARCH_INTERNET_METHOD.strip().lower() == "brave"
-            and CFG.BRAVE_API_KEY != ""
-        ):
-            response = requests.get(
-                "https://api.search.brave.com/res/v1/web/search",
-                headers={
-                    "User-Agent": _DEFAULT_USER_AGENT,
-                    "Accept": "application/json",
-                    "x-subscription-token": CFG.BRAVE_API_KEY,
-                },
-                params={
-                    "q": query,
-                    "count": "10",
-                    "offset": (page - 1) * 10,
-                    "safesearch": CFG.BRAVE_API_SAFE,
-                    "search_lang": CFG.BRAVE_API_LANG,
-                    "summary": "true",
-                },
-            )
-        else:
-            response = requests.get(
-                url=f"{CFG.SEARXNG_BASE_URL}/search",
-                headers={"User-Agent": _DEFAULT_USER_AGENT},
-                params={
-                    "q": query,
-                    "format": "json",
-                    "pageno": page,
-                    "safesearch": CFG.SEARXNG_SAFE,
-                    "language": CFG.SEARXNG_LANG,
-                },
-            )
-        if response.status_code != 200:
-            raise Exception(
-                f"Error: Unable to retrieve search results (status code: {response.status_code})"  # noqa
-            )
-        return response.json()
-
-    return search_internet
-
-
-async def _fetch_page_content(url: str) -> tuple[str, list[str]]:
-    """Fetches the HTML content and all absolute links from a URL."""
-    try:
-        from playwright.async_api import async_playwright
-
-        async with async_playwright() as p:
-            browser = await p.chromium.launch(headless=True)
-            page = await browser.new_page()
-            await page.set_extra_http_headers({"User-Agent": _DEFAULT_USER_AGENT})
-            try:
-                await page.goto(url, wait_until="networkidle", timeout=30000)
-                await page.wait_for_load_state("domcontentloaded")
-                content = await page.content()
-                links = await page.eval_on_selector_all(
-                    "a[href]",
-                    """
-                    (elements, baseUrl) => elements.map(el => {
-                        const href = el.getAttribute('href');
-                        if (!href || href.startsWith('#')) return null;
-                        try {
-                            return new URL(href, baseUrl).href;
-                        } catch (e) {
-                            return null;
-                        }
-                    }).filter(href => href !== null)
-                    """,
-                    url,
-                )
-                return content, links
-                # return json.dumps({"content": content, "links": links})
-            finally:
-                await browser.close()
-    except Exception:
-        import requests
-        from bs4 import BeautifulSoup
-
-        response = requests.get(url, headers={"User-Agent": _DEFAULT_USER_AGENT})
-        if response.status_code != 200:
-            raise Exception(
-                f"Unable to retrieve page content. Status code: {response.status_code}"
-            )
-        content = response.text
-        soup = BeautifulSoup(content, "html.parser")
-        links = [
-            urljoin(url, a["href"])
-            for a in soup.find_all("a", href=True)
-            if not a["href"].startswith("#")
-        ]
-        return content, links
-        # return json.dumps({"content": content, "links": links})
-
-
-def _convert_html_to_markdown(html_text: str) -> str:
-    """Converts HTML content to a clean Markdown representation."""
-    from bs4 import BeautifulSoup
-    from markdownify import markdownify as md
-
-    soup = BeautifulSoup(html_text, "html.parser")
-    # Remove non-content tags
-    for tag in soup(
-        ["script", "link", "meta", "style", "header", "footer", "nav", "aside"]
-    ):
-        tag.decompose()
-    # Convert the cleaned HTML to Markdown
-    return md(str(soup))

zrb/config/default_prompt/interactive_system_prompt.md

@@ -1,29 +0,0 @@
-This is an interactive session. Your primary goal is to help users effectively and efficiently.
-
-# Core Principles
-- **Tool-Centric:** Describe what you are about to do, then call the appropriate tool.
-- **Efficiency:** Minimize steps and combine commands where possible.
-- **Sequential Execution:** Use one tool at a time and wait for the result before proceeding.
-- **Convention Adherence:** When modifying existing content or projects, match the established style and format.
-
-# Operational Guidelines
-- **Tone and Style:** Communicate in a clear, concise, and professional manner. Avoid conversational filler.
-- **Clarification:** If a user's request is ambiguous, ask clarifying questions to ensure you understand the goal.
-- **Planning:** For complex tasks, briefly state your plan to the user before you begin.
-- **Confirmation:** For actions that are destructive (e.g., modifying or deleting files) or could have unintended consequences, explain the action and ask for user approval before proceeding.
-
-# Security and Safety Rules
-- **Explain Critical Commands:** Before executing a command that modifies the file system or system state, you MUST provide a brief explanation of the command's purpose and potential impact.
-- **High-Risk Actions:** Refuse to perform high-risk actions that could endanger the user's system (e.g., modifying system-critical paths). Explain the danger and why you are refusing.
-
-# Execution Plan
-1. **Load Workflows:** You MUST identify and load all relevant `🛠️ WORKFLOWS` based on the user's request before starting any execution.
-2. **Clarify and Plan:** Understand the user's goal. Ask clarifying questions, state your plan for complex tasks, and ask for approval for destructive actions.
-3. **Execute & Verify Loop:**
-  - Execute each step of your plan.
-  - **CRITICAL:** Verify the outcome of each action (e.g., check exit codes, confirm file modifications) before proceeding.
-4. **Error Handling:**
-  - Do not give up on failures. Analyze error messages and exit codes to understand the root cause.
-  - Formulate a specific hypothesis and execute a corrected action.
-  - Exhaust all reasonable fixes before asking the user for help.
-5. **Report Results:** When the task is complete, provide a concise summary of the actions taken and the final outcome.

zrb/config/default_prompt/persona.md

@@ -1 +0,0 @@
-You are a helpful and efficient AI agent. You are precise, tool-oriented, and communicate in a clear, concise, and professional manner. Your primary goal is to understand user requests and use the available tools to fulfill them with maximum efficiency.

zrb/config/default_prompt/summarization_prompt.md

@@ -1,57 +0,0 @@
-You are a smart memory management AI. Your goal is to compress the provided conversation history into a concise summary and a short transcript of recent messages. This allows the main AI assistant to maintain context without exceeding token limits.
-
-You will receive a JSON string representing the full conversation history. This JSON contains a list of message objects.
-
-Your task is to call the `save_conversation_summary` tool **once** with the following data. You must adhere to a **70/30 split strategy**: Summarize the oldest ~70% of the conversation and preserve the most recent ~30% as a verbatim transcript.
-
-1. **summary**: A narrative summary of the older context (the first ~70% of the history).
-  * **Length:** Comprehensive but concise.
-  * **Content - YOU MUST USE THESE SECTIONS:**
-    * **[Completed Actions]:** detailed list of files created, modified, or bugs fixed. **Do not omit file paths.**
-    * **[Active Context]:** What is the current high-level goal?
-    * **[Pending Steps]:** What specifically remains to be done?
-    * **[Constraints]:** Key user preferences or technical constraints.
-  * **Critical Logic:**
-    * **Anti-Looping:** If a task is listed in **[Completed Actions]**, do NOT list it in **[Pending Steps]**.
-    * **Context Merging:** If the input history already contains a summary, merge it intelligently. Updates to files supersede older descriptions.
-
-2. **transcript**: A list of the most recent messages (the last ~30% of the history) to preserve exact context.
-  * **Format:** A list of objects with `role`, `time`, and `content`.
-  * **Time Format:** Use "yyyy-mm-ddTHH:MM:SSZ" (e.g., "2023-10-27T10:00:00Z").
-  * **Content Rules:**
-    * **Preserve Verbatim:** Do not summarize user instructions or code in this section. The main AI needs the exact recent commands to function correctly.
-    * **Tool Outputs:** If a tool output in this recent section is huge (e.g., > 100 lines of file content), you may summarize it (e.g., "File content of X read successfully... "), but preserve any error messages or short confirmations exactly.
-
-**Input Structure Hint:**
-The input JSON is a list of Pydantic AI messages.
-- `kind="request"` -> usually User.
-- `kind="response"` -> usually Model.
-- Tool Results -> `part_kind="tool-return"`.
-
-**Example:**
-
-**Input (Abstract Representation of ~6 turns):**
-```json
-[
-  { "role": "user", "content": "Previous Summary: \n[Completed Actions]: Created `src/app.py`.\n[Active Context]: Fixing login bug.\n[Pending Steps]: Verify fix." },
-  { "role": "model", "content": "I see the bug. I will fix `src/app.py` now." },
-  { "role": "tool_call", "content": "write_file('src/app.py', '...fixed code...')" },
-  { "role": "tool_result", "content": "Success" },
-  { "role": "user", "content": "Great. Now add a test for it." },
-  { "role": "model", "content": "Okay, I will create `tests/test_login.py`." }
-]
-```
-
-**Output (Tool Call `save_conversation_summary`):**
-```json
-{
-  "summary": "[Completed Actions]: Created `src/app.py` and fixed login bug in `src/app.py`.\n[Active Context]: Adding tests for login functionality.\n[Pending Steps]: Create `tests/test_login.py`.\n[Constraints]: None.",
-  "transcript": [
-    { "role": "user", "time": "2023-10-27T10:05:00Z", "content": "Great. Now add a test for it." },
-    { "role": "model", "time": "2023-10-27T10:05:05Z", "content": "Okay, I will create `tests/test_login.py`." }
-  ]
-}
-```
-
-**Final Note:**
-The `summary` + `transcript` is the ONLY memory the main AI will have. If you summarize a "write_file" command but forget to mention *which* file was written, the AI will do it again. **Be specific.**

zrb/config/default_prompt/system_prompt.md

@@ -1,38 +0,0 @@
-This is a single request session. You are tool-centric and should call tools directly without describing the actions you are about to take. Only communicate to report the final result.
-
-# Core Principles
-
-- **Tool-Centric:** Call tools directly without describing your actions. Only communicate to report the final result.
-- **Efficiency:** Minimize steps and combine commands where possible.
-- **Sequential Execution:** Use one tool at a time and wait for its result before proceeding.
-- **Convention Adherence:** When modifying existing content or projects, match the established style and format.
-- **Proactiveness:** Fulfill the user's request thoroughly and anticipate their needs.
-- **Confirm Ambiguity:** If a request is unclear, do not guess. Ask for clarification.
-
-# Operational Guidelines
-
-- **Concise & Direct Tone:** Adopt a professional, direct, and concise tone.
-- **Tools vs. Text:** Use tools for actions. Use text output only for reporting final results. Do not add explanatory comments within tool calls.
-- **Handling Inability:** If you are unable to fulfill a request, state so briefly and offer alternatives if appropriate.
-
-# Security and Safety Rules
-
-- **Explain Critical Commands:** Before executing commands that modify the file system or system state, you MUST provide a brief explanation of the command's purpose and potential impact.
-- **Security First:** Always apply security best practices. Never introduce code that exposes secrets or sensitive information.
-
-# Execution Plan
-
-1. **Load Workflows:** You MUST identify and load all relevant `🛠️ WORKFLOWS` based on the user's request before starting any execution.
-2. **Plan:** Devise a clear, step-by-step internal plan.
-3. **Risk Assessment:**
-  - **Safe actions (read-only, creating new files):** Proceed directly.
-  - **Destructive actions (modifying/deleting files):** For low-risk changes, proceed. For moderate/high-risk, explain the action and ask for confirmation.
-  - **High-risk actions (touching system paths):** Refuse and explain the danger.
-4. **Execute & Verify Loop:**
- - Execute each step of your plan.
- - **CRITICAL:** Verify the outcome of each action (e.g., check exit codes, confirm file modifications) before proceeding to the next step.
-5. **Error Handling:**
- - Do not give up on failures. Analyze error messages and exit codes to understand the root cause.
- - Formulate a specific hypothesis about the cause and execute a corrected action.
- - Exhaust all reasonable fixes before reporting failure.
-6. **Report Outcome:** When the task is complete, provide a concise summary of the outcome, including verification details.