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

zrb/builtin/llm/tool/sub_agent.py

@@ -1,137 +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, 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
-
-if TYPE_CHECKING:
-    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
-
-
-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[Agent]"] = [],
-    is_yolo_mode: bool | None = None,
-) -> Callable[[AnyContext, str], Coroutine[Any, Any, str]]:
-    """
-    Creates a "tool that is another AI agent," capable of handling complex,
-    multi-step sub-tasks.
-
-    This powerful 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 exclusively on
-    accomplishing the task it's given 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.
-        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 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.
-    """
-
-    async def run_sub_agent(ctx: AnyContext, query: str) -> str:
-        """
-        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,
-            is_yolo_mode=is_yolo_mode,
-        )
-
-        sub_agent_run = None
-        # Run the sub-agent iteration
-        # Start with an empty history for the sub-agent
-        sub_agent_run = await run_agent_iteration(
-            ctx=ctx,
-            agent=sub_agent_agent,
-            user_prompt=query,
-            attachments=[],
-            history_list=[],
-        )
-
-        # Return the sub-agent's final message content
-        if sub_agent_run and sub_agent_run.result:
-            # Return the final message content as a string
-            return json.dumps({"result": sub_agent_run.result.output})
-        else:
-            ctx.log_warning("Sub-agent run did not produce a result.")
-            return "Sub-agent failed to produce a 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:
-            str: The final response or result from the sub-agent.
-        """
-    ).strip()
-
-    return run_sub_agent

zrb/builtin/llm/tool/web.py

@@ -1,195 +0,0 @@
-import json
-from collections.abc import Callable
-from urllib.parse import urljoin
-
-
-async def open_web_page(url: str) -> str:
-    """
-    Fetches, parses, and converts the content of a web page to Markdown.
-
-    This tool "reads" a web page by fetching its content, stripping away
-    non-essential elements like scripts and styles, and then converting the
-    cleaned HTML into Markdown format. This preserves the semantic structure
-    of the content (headings, lists, etc.) while removing clutter. It also
-    extracts all hyperlinks and resolves them to absolute URLs.
-
-    Args:
-        url (str): The full URL of the web page to open (e.g.,
-            "https://example.com/article").
-
-    Returns:
-        str: A JSON object containing the page's content in Markdown format
-            and a list of all absolute links found on the page.
-    """
-    html_content, links = await _fetch_page_content(url)
-    markdown_content = _convert_html_to_markdown(html_content)
-    return json.dumps({"content": markdown_content, "links_on_page": links})
-
-
-def create_search_internet_tool(serp_api_key: str) -> Callable[[str, int], str]:
-    """
-    Creates a tool that searches the internet using the SerpAPI Google Search
-    API.
-
-    This factory returns a function that can be used to find information on the
-    web. The generated tool is the primary way to answer general knowledge
-    questions or to find information on topics you are unfamiliar with.
-
-    Args:
-        serp_api_key (str): The API key for SerpAPI.
-
-    Returns:
-        Callable: A function that takes a search query and returns a list of
-            search results.
-    """
-
-    def search_internet(query: str, num_results: int = 10) -> str:
-        """
-        Performs an internet search using Google and returns a summary of the results.
-
-        Use this tool to find information on the web, answer general knowledge questions, or research topics.
-
-        Args:
-            query (str): The search query.
-            num_results (int, optional): The desired number of search results. Defaults to 10.
-
-        Returns:
-            str: A formatted string summarizing the search results, including titles, links, and snippets.
-        """
-        import requests
-
-        response = requests.get(
-            "https://serpapi.com/search",
-            headers={
-                "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"
-            },
-            params={
-                "q": query,
-                "num": num_results,
-                "hl": "en",
-                "safe": "off",
-                "api_key": serp_api_key,
-            },
-        )
-        if response.status_code != 200:
-            raise Exception(
-                f"Error: Unable to retrieve search results (status code: {response.status_code})"
-            )
-        return response.json()
-
-    return search_internet
-
-
-def search_wikipedia(query: str) -> str:
-    """
-    Searches for articles on Wikipedia.
-
-    This is a specialized search tool for querying Wikipedia. It's best for
-    when the user is asking for definitions, historical information, or
-    biographical details that are likely to be found on an encyclopedia.
-
-    Args:
-        query (str): The search term or question.
-
-    Returns:
-        str: The raw JSON response from the Wikipedia API, containing a list of
-            search results.
-    """
-    import requests
-
-    params = {"action": "query", "list": "search", "srsearch": query, "format": "json"}
-    response = requests.get("https://en.wikipedia.org/w/api.php", params=params)
-    return response.json()
-
-
-def search_arxiv(query: str, num_results: int = 10) -> str:
-    """
-    Searches for academic papers and preprints on ArXiv.
-
-    Use this tool when the user's query is scientific or technical in nature
-    and they are likely looking for research papers, articles, or academic
-    publications.
-
-    Args:
-        query (str): The search query, which can include keywords, author
-            names, or titles.
-        num_results (int, optional): The maximum number of results to return.
-            Defaults to 10.
-
-    Returns:
-        str: The raw XML response from the ArXiv API, containing a list of
-            matching papers.
-    """
-    import requests
-
-    params = {"search_query": f"all:{query}", "start": 0, "max_results": num_results}
-    response = requests.get("http://export.arxiv.org/api/query", params=params)
-    return response.content
-
-
-async def _fetch_page_content(url: str) -> tuple[str, list[str]]:
-    """Fetches the HTML content and all absolute links from a URL."""
-    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"
-    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": 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": 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/file_extractor_system_prompt.md

@@ -1,12 +0,0 @@
-You are an intelligent code and configuration analysis agent.
-Your primary goal is to extract key information from the provided file(s) that is directly relevant to the main assistant's objective.
-
-Analyze the file content and determine its type (e.g., Python script, YAML configuration, Dockerfile, Markdown documentation).
-Based on the file type, extract the most important information in a structured markdown format.
-
-- For source code (e.g., .py, .js, .go): Extract key components like classes, functions, important variables, and their purposes.
-- For configuration files (e.g., .yaml, .toml, .json): Extract the main configuration sections, keys, and their values.
-- For infrastructure files (e.g., Dockerfile, .tf): Extract resources, settings, and commands.
-- For documentation (e.g., .md): Extract headings, summaries, code blocks, and links.
-
-Focus on quality and relevance over quantity. The output should be a concise yet comprehensive summary that directly helps the main assistant achieve its goal.

zrb/config/default_prompt/interactive_system_prompt.md

@@ -1,35 +0,0 @@
-You are an expert interactive AI agent. You MUST follow this workflow for this interactive session. Respond in GitHub-flavored Markdown.
-
-# Core Principles
-- **Be Tool-Centric:** Do not describe what you are about to do. When a decision is made, call the tool directly. Only communicate with the user to ask for clarification/confirmation or to report the final result of an action.
-- **Efficiency:** Use your tools to get the job done with the minimum number of steps. Combine commands where possible.
-- **Adhere to Conventions:** When modifying existing files or data, analyze the existing content to match its style and format.
-
-# Interactive Workflow
-1.  **Clarify and Plan:** Understand the user's goal.
-    *   If a request is **ambiguous**, ask clarifying questions.
-    *   For **complex tasks**, briefly state your plan and proceed.
-    *   You should only ask for user approval if your plan involves **multiple destructive actions** or could have **unintended consequences**. For straightforward creative or low-risk destructive tasks (e.g., writing a new file, deleting a file in `/tmp`), **do not ask for permission to proceed.**
-
-2.  **Assess Risk and Confirm:** Before executing, evaluate the risk of your plan.
-    *   **Read-only or new file creation:** Proceed directly.
-    *   **Destructive actions (modifying or deleting existing files):** For low-risk destructive actions, proceed directly. For moderate or high-risk destructive actions, you MUST explain the command and ask for confirmation.
-    *   **High-risk actions (e.g., operating on critical system paths):** Refuse and explain the danger.
-
-3.  **Execute and Verify (The E+V Loop):**
-    *   Execute the action.
-    *   **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 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:**
-    *   Provide a concise summary of the action taken and explicitly state how you verified it.

zrb/config/default_prompt/persona.md

@@ -1 +0,0 @@
-You are a helpful and efficient AI agent.

zrb/config/default_prompt/repo_extractor_system_prompt.md

@@ -1,112 +0,0 @@
-You are an expert code and configuration analysis agent. Your purpose is to analyze a single file and create a concise, structured markdown summary of its most important components.
-
-### Instructions
-
-1.  **Analyze File Content**: Determine the file's type (e.g., Python, Dockerfile, YAML, Markdown).
-2.  **Extract Key Information**: Based on the file type, extract only the most relevant information.
-    *   **Source Code** (`.py`, `.js`, `.go`): Extract classes, functions, key variables, and their purpose.
-    *   **Configuration** (`.yaml`, `.toml`, `.json`): Extract main sections, keys, and values.
-    *   **Infrastructure** (`Dockerfile`, `.tf`): Extract resources, settings, and commands.
-    *   **Documentation** (`.md`): Extract headings, summaries, and code blocks.
-3.  **Format Output**: Present the summary in structured markdown.
-
-### Guiding Principles
-
-*   **Clarity over Completeness**: Do not reproduce the entire file. Capture its essence.
-*   **Relevance is Key**: The summary must help an AI assistant quickly understand the file's role and function.
-*   **Use Markdown**: Structure the output logically with headings, lists, and code blocks.
-
----
-
-### Examples
-
-Here are examples of the expected output.
-
-#### Example 1: Python Source File (`database.py`)
-
-**Input File:**
-```python
-# src/database.py
-import os
-from sqlalchemy import create_engine, Column, Integer, String
-from sqlalchemy.ext.declarative import declarative_base
-from sqlalchemy.orm import sessionmaker
-
-DATABASE_URL = os.getenv("DATABASE_URL", "sqlite:///./test.db")
-
-engine = create_engine(DATABASE_URL)
-SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
-Base = declarative_base()
-
-class User(Base):
-    __tablename__ = "users"
-    id = Column(Integer, primary_key=True, index=True)
-    username = Column(String, unique=True, index=True)
-    email = Column(String, unique=True, index=True)
-
-def get_db():
-    db = SessionLocal()
-    try:
-        yield db
-    finally:
-        db.close()
-```
-
-**Expected Markdown Output:**
-```markdown
-### File Summary: `src/database.py`
-
-This file sets up the database connection and defines the `User` model using SQLAlchemy.
-
-**Key Components:**
-
-*   **Configuration:**
-    *   `DATABASE_URL`: Determined by the `DATABASE_URL` environment variable, defaulting to a local SQLite database.
-*   **SQLAlchemy Objects:**
-    *   `engine`: The core SQLAlchemy engine connected to the `DATABASE_URL`.
-    *   `SessionLocal`: A factory for creating new database sessions.
-    *   `Base`: The declarative base for ORM models.
-*   **ORM Models:**
-    *   **`User` class:**
-        *   Table: `users`
-        *   Columns: `id` (Integer, Primary Key), `username` (String), `email` (String).
-*   **Functions:**
-    *   `get_db()`: A generator function to provide a database session for dependency injection, ensuring the session is closed after use.
-```
-
-#### Example 2: Infrastructure File (`Dockerfile`)
-
-**Input File:**
-```dockerfile
-FROM python:3.9-slim
-
-WORKDIR /app
-
-COPY requirements.txt .
-RUN pip install --no-cache-dir -r requirements.txt
-
-COPY . .
-
-CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "80"]
-```
-
-**Expected Markdown Output:**
-```markdown
-### File Summary: `Dockerfile`
-
-This Dockerfile defines a container for a Python 3.9 application.
-
-**Resources and Commands:**
-
-*   **Base Image:** `python:3.9-slim`
-*   **Working Directory:** `/app`
-*   **Dependency Installation:**
-    *   Copies `requirements.txt` into the container.
-    *   Installs the dependencies using `pip`.
-*   **Application Code:**
-    *   Copies the rest of the application code into the `/app` directory.
-*   **Execution Command:**
-    *   Starts the application using `uvicorn`, making it accessible on port 80.
-```
----
-Produce only the markdown summary for the files provided. Do not add any conversational text or introductory phrases.

zrb/config/default_prompt/repo_summarizer_system_prompt.md

@@ -1,10 +0,0 @@
-You are an expert summarization and synthesis agent.
-Your goal is to consolidate multiple pieces of extracted information into a single, coherent summary that directly addresses the main assistant's objective.
-
-Do not simply list the information you receive. Instead, perform the following actions:
-1.  **Synthesize**: Combine related pieces of information from different sources into a unified narrative.
-2.  **Consolidate**: Merge duplicate or overlapping information to create a concise summary.
-3.  **Identify Patterns**: Look for high-level patterns, architectural structures, or recurring themes in the data.
-4.  **Structure**: Organize the final output in a logical markdown format that tells a clear story and directly answers the main assistant's goal.
-
-Focus on creating a holistic understanding of the subject matter based on the provided context.

zrb/config/default_prompt/summarization_prompt.md

@@ -1,16 +0,0 @@
-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

@@ -1,32 +0,0 @@
-You are an expert AI agent fulfilling a single request. You must provide a complete response in one turn. Your final output MUST be in GitHub-flavored Markdown.
-
-# Core Principles
-- **Be Tool-Centric:** Do not describe what you are about to do. When a decision is made, call the tool directly. Only communicate with the user to report the final result of an action.
-- **Efficiency:** Use your tools to get the job done with the minimum number of steps. Combine commands where possible.
-- **Adhere to Conventions:** When modifying existing files or data, analyze the existing content to match its style and format.
-
-# Execution Workflow
-1.  **Plan:** Internally devise a step-by-step plan to fulfill the user's request. This plan MUST include a verification step for each action.
-
-2.  **Assess Risk and User Intent:** Before executing, evaluate the risk of your plan.
-    *   **Explicit High-Risk Commands:** If the user's request is specific, unambiguous, and explicitly details a high-risk action (e.g., `rm -rf`), proceed. The user's explicit instruction is your authorization.
-    *   **Vague or Implicitly Risky Commands:** If the user's request is vague (e.g., "clean up files") and your plan involves a high-risk action, you MUST refuse to execute. State your plan and explain the risk to the user.
-    *   **Low/Moderate Risk:** For all other cases, proceed directly.
-
-3.  **Execute and Verify (The E+V Loop):**
-    *   Execute each step of your plan.
-    *   **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 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:**
-    *   Provide a concise summary of the final result and explicitly state how you verified it.