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

zrb/builtin/llm/llm_ask.py

@@ -1,269 +0,0 @@
-import os
-from collections.abc import Callable
-from typing import TYPE_CHECKING
-
-from zrb.builtin.group import llm_group
-from zrb.builtin.llm.attachment import get_media_type
-from zrb.builtin.llm.chat_session import get_llm_ask_input_mapping, read_user_prompt
-from zrb.builtin.llm.history import read_chat_conversation, write_chat_conversation
-from zrb.builtin.llm.input import PreviousSessionInput
-from zrb.builtin.llm.tool.api import (
-    create_get_current_location,
-    create_get_current_weather,
-)
-from zrb.builtin.llm.tool.cli import run_shell_command
-from zrb.builtin.llm.tool.code import analyze_repo
-from zrb.builtin.llm.tool.file import (
-    analyze_file,
-    list_files,
-    read_from_file,
-    replace_in_file,
-    search_files,
-    write_to_file,
-)
-from zrb.builtin.llm.tool.note import (
-    read_contextual_note,
-    read_long_term_note,
-    write_contextual_note,
-    write_long_term_note,
-)
-from zrb.builtin.llm.tool.web import (
-    create_search_internet_tool,
-    open_web_page,
-)
-from zrb.callback.callback import Callback
-from zrb.config.config import CFG
-from zrb.config.llm_config import llm_config
-from zrb.context.any_context import AnyContext
-from zrb.input.any_input import AnyInput
-from zrb.input.bool_input import BoolInput
-from zrb.input.str_input import StrInput
-from zrb.input.text_input import TextInput
-from zrb.task.base_trigger import BaseTrigger
-from zrb.task.llm_task import LLMTask
-from zrb.util.string.conversion import to_boolean
-
-if TYPE_CHECKING:
-    from pydantic_ai import AbstractToolset, Tool, UserContent
-
-    ToolOrCallable = Tool | Callable
-
-
-def _get_toolset(ctx: AnyContext) -> list["AbstractToolset[None] | str"]:
-    cwd = os.getcwd()
-    toolsets = []
-    for config_path in [
-        os.path.join(cwd, "mcp_config.json"),
-        os.path.join(cwd, "mcp-config.json"),
-    ]:
-        if os.path.isfile(config_path):
-            toolsets.append(config_path)
-    return toolsets
-
-
-def _get_tool(ctx: AnyContext) -> list["ToolOrCallable"]:
-    tools = [
-        read_long_term_note,
-        write_long_term_note,
-        read_contextual_note,
-        write_contextual_note,
-    ]
-    if CFG.LLM_ALLOW_ANALYZE_REPO:
-        tools.append(analyze_repo)
-    if CFG.LLM_ALLOW_ANALYZE_FILE:
-        tools.append(analyze_file)
-    if CFG.LLM_ALLOW_ACCESS_LOCAL_FILE:
-        tools.append(search_files)
-        tools.append(list_files)
-        tools.append(read_from_file)
-        tools.append(replace_in_file)
-        tools.append(write_to_file)
-    if CFG.LLM_ALLOW_ACCESS_SHELL:
-        tools.append(run_shell_command)
-    if CFG.LLM_ALLOW_OPEN_WEB_PAGE:
-        tools.append(open_web_page)
-    if CFG.LLM_ALLOW_GET_CURRENT_LOCATION:
-        tools.append(create_get_current_location())
-    if CFG.LLM_ALLOW_GET_CURRENT_WEATHER:
-        tools.append(create_get_current_weather())
-    if CFG.SERPAPI_KEY != "" and CFG.LLM_ALLOW_SEARCH_INTERNET:
-        tools.append(create_search_internet_tool())
-    return tools
-
-
-def _get_default_yolo_mode(ctx: AnyContext) -> str:
-    default_value = llm_config.default_yolo_mode
-    if isinstance(default_value, list):
-        return ",".join(default_value)
-    return f"{default_value}"
-
-
-def _render_yolo_mode_input(ctx: AnyContext) -> list[str] | bool:
-    if ctx.input.yolo.strip() == "":
-        return []
-    elements = [element.strip() for element in ctx.input.yolo.split(",")]
-    if len(elements) == 1:
-        try:
-            return to_boolean(elements[0])
-        except Exception:
-            pass
-    return elements
-
-
-def _render_attach_input(ctx: AnyContext) -> "list[UserContent]":
-    from pathlib import Path
-
-    from pydantic_ai import BinaryContent
-
-    attachment_paths: list[str] = [
-        attachment_path.strip()
-        for attachment_path in ctx.input.attach.split(",")
-        if attachment_path.strip() != ""
-    ]
-    if len(attachment_paths) == 0:
-        return []
-    attachments = []
-    for attachment_path in attachment_paths:
-        attachment_path = os.path.abspath(os.path.expanduser(attachment_path))
-        media_type = get_media_type(attachment_path)
-        if media_type is None:
-            ctx.log_error(f"Cannot get media type of {attachment_path}")
-            continue
-        data = Path(attachment_path).read_bytes()
-        attachments.append(BinaryContent(data, media_type=media_type))
-    return attachments
-
-
-def _get_inputs(require_message: bool = True) -> list[AnyInput | None]:
-    return [
-        StrInput(
-            "model",
-            description="LLM Model",
-            prompt="LLM Model",
-            default="",
-            allow_positional_parsing=False,
-            always_prompt=False,
-            allow_empty=True,
-        ),
-        StrInput(
-            "base-url",
-            description="LLM API Base URL",
-            prompt="LLM API Base URL",
-            default="",
-            allow_positional_parsing=False,
-            always_prompt=False,
-            allow_empty=True,
-        ),
-        StrInput(
-            "api-key",
-            description="LLM API Key",
-            prompt="LLM API Key",
-            default="",
-            allow_positional_parsing=False,
-            always_prompt=False,
-            allow_empty=True,
-        ),
-        TextInput(
-            "system-prompt",
-            description="System prompt",
-            prompt="System prompt",
-            default="",
-            allow_positional_parsing=False,
-            always_prompt=False,
-        ),
-        TextInput(
-            "workflows",
-            description="Workflows",
-            prompt="Workflows",
-            default=lambda ctx: ",".join(llm_config.default_workflows),
-            allow_positional_parsing=False,
-            always_prompt=False,
-        ),
-        BoolInput(
-            "start-new",
-            description="Start new session (LLM Agent will forget past conversation)",
-            prompt="Start new session (LLM Agent will forget past conversation)",
-            default=False,
-            allow_positional_parsing=False,
-            always_prompt=False,
-        ),
-        StrInput(
-            "yolo",
-            description="YOLO mode (LLM Agent will start in YOLO Mode)",
-            prompt="YOLO mode (LLM Agent will start in YOLO Mode)",
-            default=_get_default_yolo_mode,
-            allow_positional_parsing=False,
-            always_prompt=False,
-        ),
-        TextInput(
-            "message",
-            description="User message",
-            prompt="Your message",
-            always_prompt=require_message,
-            allow_empty=not require_message,
-        ),
-        StrInput(
-            name="attach",
-            description="Comma separated attachments",
-            default="",
-            allow_positional_parsing=False,
-            always_prompt=False,
-        ),
-        PreviousSessionInput(
-            "previous-session",
-            description="Previous conversation session",
-            prompt="Previous conversation session (can be empty)",
-            allow_positional_parsing=False,
-            allow_empty=True,
-            always_prompt=False,
-        ),
-    ]
-
-
-llm_ask = LLMTask(
-    name="llm-ask",
-    input=_get_inputs(True),
-    description="❓ Ask LLM",
-    model=lambda ctx: None if ctx.input.model.strip() == "" else ctx.input.model,
-    model_base_url=lambda ctx: (
-        None if ctx.input.base_url.strip() == "" else ctx.input.base_url
-    ),
-    model_api_key=lambda ctx: (
-        None if ctx.input.api_key.strip() == "" else ctx.input.api_key
-    ),
-    conversation_history_reader=read_chat_conversation,
-    conversation_history_writer=write_chat_conversation,
-    system_prompt=lambda ctx: (
-        None if ctx.input.system_prompt.strip() == "" else ctx.input.system_prompt
-    ),
-    workflows=lambda ctx: (
-        None if ctx.input.workflows.strip() == "" else ctx.input.workflows.split(",")
-    ),
-    attachment=_render_attach_input,
-    message="{ctx.input.message}",
-    tools=_get_tool,
-    toolsets=_get_toolset,
-    yolo_mode=_render_yolo_mode_input,
-    retries=0,
-)
-llm_group.add_task(llm_ask, alias="ask")
-
-llm_group.add_task(
-    BaseTrigger(
-        name="llm-chat",
-        input=_get_inputs(False),
-        description="💬 Chat with LLM",
-        queue_name="ask_trigger",
-        action=read_user_prompt,
-        callback=Callback(
-            task=llm_ask,
-            input_mapping=get_llm_ask_input_mapping,
-            result_queue="ask_result",
-            error_queue="ask_error",
-            session_name_queue="ask_session_name",
-        ),
-        retries=0,
-        cli_only=True,
-    ),
-    alias="chat",
-)

zrb/builtin/llm/previous-session.js

@@ -1,21 +0,0 @@
-async function updatePreviousSession(event) {
-    const currentInput = event.target;
-    if (currentInput.name === "CURRENT_INPUT_NAME") {
-        return
-    }
-    const previousSessionInput = submitTaskForm.querySelector('[name="CURRENT_INPUT_NAME"]');
-    if (previousSessionInput) {
-        const currentSessionName = cfg.SESSION_NAME
-        previousSessionInput.value = currentSessionName;
-    }
-}
-
-document.getElementById("submit-task-form").querySelectorAll("input[name], textarea[name]").forEach((element) => {
-    element.addEventListener("input", updatePreviousSession);
-    element.addEventListener("keyup", updatePreviousSession);
-});
-
-document.getElementById("submit-task-form").querySelectorAll("select[name]").forEach((element) => {
-    element.addEventListener("change", updatePreviousSession);
-});
-

zrb/builtin/llm/tool/api.py

@@ -1,75 +0,0 @@
-from typing import Any, Callable, Literal
-
-from zrb.config.llm_config import llm_config
-
-
-def create_get_current_location() -> Callable:
-    if llm_config.default_current_location_tool is not None:
-        return llm_config.default_current_location_tool
-
-    def get_current_location() -> dict[str, float]:
-        """
-        Gets the user's current geographical location (latitude and longitude).
-
-        Example:
-        get_current_location() # Returns {'lat': 48.8584, 'lon': 2.2945}
-
-        Returns:
-            dict: Dictionary with 'lat' and 'lon' keys.
-        """
-        import requests
-
-        try:
-            response = requests.get("http://ip-api.com/json?fields=lat,lon", timeout=5)
-            response.raise_for_status()
-            return dict(response.json())
-        except requests.RequestException as e:
-            raise requests.RequestException(f"Failed to get location: {e}")
-
-    return get_current_location
-
-
-def create_get_current_weather() -> Callable:
-    if llm_config.default_current_weather_tool is not None:
-        return llm_config.default_current_weather_tool
-
-    def get_current_weather(
-        latitude: float,
-        longitude: float,
-        temperature_unit: Literal["celsius", "fahrenheit"],
-    ) -> dict[str, Any]:
-        """
-        Gets current weather conditions for a given location.
-
-        Example:
-        get_current_weather(
-            latitude=34.0522, longitude=-118.2437, temperature_unit='fahrenheit'
-        )
-
-        Args:
-            latitude (float): Latitude of the location.
-            longitude (float): Longitude of the location.
-            temperature_unit (Literal): 'celsius' or 'fahrenheit'.
-
-        Returns:
-            dict: Detailed weather data.
-        """
-        import requests
-
-        try:
-            response = requests.get(
-                "https://api.open-meteo.com/v1/forecast",
-                params={
-                    "latitude": latitude,
-                    "longitude": longitude,
-                    "temperature_unit": temperature_unit,
-                    "current_weather": True,
-                },
-                timeout=5,
-            )
-            response.raise_for_status()
-            return dict(response.json())
-        except requests.RequestException as e:
-            raise requests.RequestException(f"Failed to get weather data: {e}")
-
-    return get_current_weather

zrb/builtin/llm/tool/cli.py

@@ -1,52 +0,0 @@
-import subprocess
-import sys
-
-if sys.version_info >= (3, 12):
-    from typing import TypedDict
-else:
-    from typing_extensions import TypedDict
-
-
-class ShellCommandResult(TypedDict):
-    """
-    Result of shell command execution
-
-    Attributes:
-        return_code: The return code, 0 indicating no error
-        stdout: Standard output
-        stderr: Standard error
-    """
-
-    return_code: int
-    stdout: str
-    stderr: str
-
-
-def run_shell_command(command: str) -> ShellCommandResult:
-    """
-    Executes a non-interactive shell command on the user's machine.
-
-    CRITICAL: This tool runs with user-level permissions. Explain commands that modify
-        the system (e.g., `git`, `pip`) and ask for confirmation.
-    IMPORTANT: Long-running processes should be run in the background (e.g., `command &`).
-
-    Example:
-    run_shell_command(command='ls -l')
-
-    Args:
-        command (str): The exact shell command to be executed.
-
-    Returns:
-        dict: return_code, stdout, and stderr.
-    """
-    result = subprocess.run(
-        command,
-        shell=True,
-        capture_output=True,
-        text=True,
-    )
-    return {
-        "return_code": result.returncode,
-        "stdout": result.stdout,
-        "stderr": result.stderr,
-    }

zrb/builtin/llm/tool/code.py

@@ -1,236 +0,0 @@
-import json
-import os
-
-from zrb.builtin.llm.tool.file import DEFAULT_EXCLUDED_PATTERNS, is_excluded
-from zrb.builtin.llm.tool.sub_agent import create_sub_agent_tool
-from zrb.config.config import CFG
-from zrb.config.llm_rate_limitter import llm_rate_limitter
-from zrb.context.any_context import AnyContext
-from zrb.util.cli.style import stylize_faint
-
-_DEFAULT_EXTENSIONS = [
-    "py",
-    "go",
-    "java",
-    "ts",
-    "js",
-    "rs",
-    "rb",
-    "php",
-    "sh",
-    "bash",
-    "c",
-    "cpp",
-    "h",
-    "hpp",
-    "cs",
-    "swift",
-    "kt",
-    "scala",
-    "m",
-    "pl",
-    "lua",
-    "sql",
-    "html",
-    "css",
-    "scss",
-    "less",
-    "json",
-    "yaml",
-    "yml",
-    "toml",
-    "ini",
-    "xml",
-    "md",
-    "rst",
-    "txt",
-]
-
-
-async def analyze_repo(
-    ctx: AnyContext,
-    path: str,
-    query: str,
-    extensions: list[str] = _DEFAULT_EXTENSIONS,
-    exclude_patterns: list[str] = DEFAULT_EXCLUDED_PATTERNS,
-    extraction_token_threshold: int | None = None,
-    summarization_token_threshold: int | None = None,
-) -> str:
-    """
-    Analyzes a code repository or directory to answer a specific query.
-
-    CRITICAL: The quality of analysis depends entirely on the query. Vague queries yield poor
-        results.
-    IMPORTANT: This tool can be slow and expensive on large repositories. Use judiciously.
-
-    Example:
-    analyze_repo(
-        path='src/my_project',
-        query='Summarize the main functionalities by analyzing Python files.',
-        extensions=['py']
-    )
-
-    Args:
-        ctx (AnyContext): The execution context.
-        path (str): Path to the directory or repository.
-        query (str): Clear and specific analysis question or goal.
-        extensions (list[str], optional): File extensions to include.
-        exclude_patterns (list[str], optional): Glob patterns to exclude.
-        extraction_token_threshold (int, optional): Token limit for extraction sub-agent.
-        summarization_token_threshold (int, optional): Token limit for summarization sub-agent.
-
-    Returns:
-        str: Detailed, markdown-formatted analysis and summary.
-    """
-    if extraction_token_threshold is None:
-        extraction_token_threshold = CFG.LLM_REPO_ANALYSIS_EXTRACTION_TOKEN_THRESHOLD
-    if summarization_token_threshold is None:
-        summarization_token_threshold = (
-            CFG.LLM_REPO_ANALYSIS_SUMMARIZATION_TOKEN_THRESHOLD
-        )
-    abs_path = os.path.abspath(os.path.expanduser(path))
-    file_metadatas = _get_file_metadatas(abs_path, extensions, exclude_patterns)
-    ctx.print(stylize_faint("  📝 Extraction"), plain=True)
-    extracted_infos = await _extract_info(
-        ctx,
-        file_metadatas=file_metadatas,
-        query=query,
-        token_limit=extraction_token_threshold,
-    )
-    if len(extracted_infos) == 0:
-        raise RuntimeError(
-            "No info can be extracted, adjust extensions or exclude_patterns."
-        )
-    if len(extracted_infos) == 1:
-        return extracted_infos[0]
-    summarized_infos = extracted_infos
-    while len(summarized_infos) > 1:
-        ctx.print(stylize_faint("  📝 Summarization"), plain=True)
-        summarized_infos = await _summarize_info(
-            ctx,
-            extracted_infos=summarized_infos,
-            query=query,
-            token_limit=summarization_token_threshold,
-        )
-    return summarized_infos[0]
-
-
-def _get_file_metadatas(
-    dir_path: str,
-    extensions: list[str],
-    exclude_patterns: list[str],
-) -> list[dict[str, str]]:
-    metadata_list = []
-    for root, _, files in os.walk(dir_path):
-        files.sort()
-        for file in files:
-            if not any(file.endswith(f".{ext}") for ext in extensions):
-                continue
-            file_path = os.path.join(root, file)
-            try:
-                rel_path = os.path.relpath(file_path, dir_path)
-                if is_excluded(rel_path, exclude_patterns):
-                    continue
-                with open(file_path, "r", encoding="utf-8", errors="ignore") as f:
-                    metadata_list.append({"path": rel_path, "content": f.read()})
-            except Exception as e:
-                print(f"Error reading file {file_path}: {e}")
-    metadata_list.sort(key=lambda m: m["path"])
-    return metadata_list
-
-
-async def _extract_info(
-    ctx: AnyContext,
-    file_metadatas: list[dict[str, str]],
-    query: str,
-    token_limit: int,
-) -> list[str]:
-    extract = create_sub_agent_tool(
-        tool_name="extract",
-        tool_description="extract",
-        system_prompt=CFG.LLM_REPO_EXTRACTOR_SYSTEM_PROMPT,
-        auto_summarize=False,
-        remember_history=False,
-    )
-    extracted_infos = []
-    content_buffer = []
-    current_token_count = 0
-    for metadata in file_metadatas:
-        path = metadata.get("path", "")
-        content = metadata.get("content", "")
-        file_obj = {"path": path, "content": content}
-        file_str = json.dumps(file_obj)
-        if current_token_count + llm_rate_limitter.count_token(file_str) > token_limit:
-            if content_buffer:
-                prompt = json.dumps(_create_extract_info_prompt(query, content_buffer))
-                extracted_info = await extract(
-                    ctx, llm_rate_limitter.clip_prompt(prompt, token_limit)
-                )
-                extracted_infos.append(extracted_info)
-            content_buffer = [file_obj]
-            current_token_count = llm_rate_limitter.count_token(file_str)
-        else:
-            content_buffer.append(file_obj)
-            current_token_count += llm_rate_limitter.count_token(file_str)
-    # Process any remaining content in the buffer
-    if content_buffer:
-        prompt = json.dumps(_create_extract_info_prompt(query, content_buffer))
-        extracted_info = await extract(
-            ctx, llm_rate_limitter.clip_prompt(prompt, token_limit)
-        )
-        extracted_infos.append(extracted_info)
-    return extracted_infos
-
-
-def _create_extract_info_prompt(query: str, content_buffer: list[dict]) -> dict:
-    return {
-        "main_assistant_query": query,
-        "files": content_buffer,
-    }
-
-
-async def _summarize_info(
-    ctx: AnyContext,
-    extracted_infos: list[str],
-    query: str,
-    token_limit: int,
-) -> list[str]:
-    summarize = create_sub_agent_tool(
-        tool_name="extract",
-        tool_description="extract",
-        system_prompt=CFG.LLM_REPO_SUMMARIZER_SYSTEM_PROMPT,
-        auto_summarize=False,
-        remember_history=False,
-    )
-    summarized_infos = []
-    content_buffer = ""
-    for extracted_info in extracted_infos:
-        new_prompt = content_buffer + extracted_info
-        if llm_rate_limitter.count_token(new_prompt) > token_limit:
-            if content_buffer:
-                prompt = json.dumps(
-                    _create_summarize_info_prompt(query, content_buffer)
-                )
-                summarized_info = await summarize(
-                    ctx, llm_rate_limitter.clip_prompt(prompt, token_limit)
-                )
-                summarized_infos.append(summarized_info)
-            content_buffer = extracted_info
-        else:
-            content_buffer += extracted_info + "\n"
-
-    # Process any remaining content in the buffer
-    if content_buffer:
-        prompt = json.dumps(_create_summarize_info_prompt(query, content_buffer))
-        summarized_info = await summarize(
-            ctx, llm_rate_limitter.clip_prompt(prompt, token_limit)
-        )
-        summarized_infos.append(summarized_info)
-    return summarized_infos
-
-
-def _create_summarize_info_prompt(query: str, content_buffer: str) -> dict:
-    return {
-        "main_assistant_query": query,
-        "extracted_info": content_buffer,
-    }