zrb 1.9.0__tar.gz → 1.9.1__tar.gz

{zrb-1.9.0 → zrb-1.9.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: zrb
-Version: 1.9.0
+Version: 1.9.1
 Summary: Your Automation Powerhouse
 Home-page: https://github.com/state-alchemists/zrb
 License: AGPL-3.0-or-later

{zrb-1.9.0 → zrb-1.9.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "zrb"
-version = "1.9.0"
+version = "1.9.1"
 description = "Your Automation Powerhouse"
 authors = ["Go Frendi Gunawan <gofrendiasgard@gmail.com>"]
 license = "AGPL-3.0-or-later"

{zrb-1.9.0 → zrb-1.9.1}/src/zrb/builtin/llm/llm_ask.py

@@ -10,7 +10,9 @@ from zrb.builtin.llm.tool.file import (
     apply_diff,
     list_files,
     read_from_file,
+    read_many_files,
     search_files,
+    write_many_files,
     write_to_file,
 )
 from zrb.builtin.llm.tool.web import (
@@ -132,8 +134,10 @@ if CFG.LLM_ALLOW_ACCESS_LOCAL_FILE:
         search_files,
         list_files,
         read_from_file,
+        read_many_files,
         apply_diff,
         write_to_file,
+        write_many_files,
     )
 
 if CFG.LLM_ALLOW_ACCESS_SHELL:

{zrb-1.9.0 → zrb-1.9.1}/src/zrb/builtin/llm/tool/code.py

@@ -82,8 +82,8 @@ async def analyze_repo(
     goal: str,
     extensions: list[str] = _DEFAULT_EXTENSIONS,
     exclude_patterns: list[str] = DEFAULT_EXCLUDED_PATTERNS,
-    extraction_token_limit: int = 30000,
-    summarization_token_limit: int = 30000,
+    extraction_token_limit: int = 40000,
+    summarization_token_limit: int = 40000,
 ) -> str:
     """
     Extract and summarize information from any directory.

{zrb-1.9.0 → zrb-1.9.1}/src/zrb/builtin/llm/tool/file.py

@@ -2,7 +2,7 @@ import fnmatch
 import json
 import os
 import re
-from typing import Any, Optional
+from typing import Any, Dict, List, Optional
 
 from zrb.builtin.llm.tool.sub_agent import create_sub_agent_tool
 from zrb.context.any_context import AnyContext
@@ -215,6 +215,7 @@ def read_from_file(
     end_line: Optional[int] = None,
 ) -> str:
     """Read file content (or specific lines) at a path, including line numbers.
+    This tool can read both, text and pdf file.
     Args:
         path (str): Path to read. Pass exactly as provided, including '~'.
         start_line (Optional[int]): Starting line number (1-based).
@@ -466,7 +467,7 @@ def apply_diff(
 
 
 async def analyze_file(
-    ctx: AnyContext, path: str, query: str, token_limit: int = 30000
+    ctx: AnyContext, path: str, query: str, token_limit: int = 40000
 ) -> str:
     """Analyze file using LLM capability to reduce context usage.
     Use this tool for:
@@ -498,3 +499,105 @@ async def analyze_file(
     )
     clipped_payload = llm_rate_limitter.clip_prompt(payload, token_limit)
     return await _analyze_file(ctx, clipped_payload)
+
+
+def read_many_files(paths: List[str]) -> str:
+    """
+    Read and return the content of multiple files.
+
+    This function is ideal for when you need to inspect the contents of
+    several files at once. For each file path provided in the input list,
+    it reads the entire file content. The result is a JSON string
+    containing a dictionary where keys are the file paths and values are
+    the corresponding file contents.
+
+    Use this tool when you need a comprehensive view of multiple files,
+    for example, to understand how different parts of a module interact,
+    to check configurations across various files, or to gather context
+    before making widespread changes.
+
+    Args:
+        paths (List[str]): A list of absolute or relative paths to the
+                           files you want to read. It is crucial to
+                           provide accurate paths. Use the `list_files`
+                           tool if you are unsure about the exact file
+                           locations.
+
+    Returns:
+        str: A JSON string representing a dictionary where each key is a
+             file path and the corresponding value is the content of that
+             file. If a file cannot be read, its entry in the dictionary
+             will contain an error message.
+             Example:
+             {
+                 "results": {
+                     "path/to/file1.py": "...",
+                     "path/to/file2.txt": "..."
+                 }
+             }
+    """
+    results = {}
+    for path in paths:
+        try:
+            abs_path = os.path.abspath(os.path.expanduser(path))
+            if not os.path.exists(abs_path):
+                raise FileNotFoundError(f"File not found: {path}")
+            content = read_file_with_line_numbers(abs_path)
+            results[path] = content
+        except Exception as e:
+            results[path] = f"Error reading file: {e}"
+    return json.dumps({"results": results})
+
+
+def write_many_files(files: Dict[str, str]) -> str:
+    """
+    Write content to multiple files simultaneously.
+
+    This function allows you to create, overwrite, or update multiple
+    files in a single operation. You provide a dictionary where each
+    key is a file path and the corresponding value is the content to be
+    written to that file. This is particularly useful for applying
+    changes across a project, such as refactoring code, updating
+    configuration files, or creating a set of new files from a template.
+
+    Each file is handled as a complete replacement of its content. If the
+    file does not exist, it will be created. If it already exists, its
+
+    entire content will be overwritten with the new content you provide.
+    Therefore, it is essential to provide the full, intended content for
+    each file.
+
+    Args:
+        files (Dict[str, str]): A dictionary where keys are the file paths
+                                (absolute or relative) and values are the
+                                complete contents to be written to those
+                                files.
+
+    Returns:
+        str: A JSON string summarizing the operation. It includes a list
+             of successfully written files and a list of files that
+             failed, along with the corresponding error messages.
+             Example:
+             {
+                 "success": [
+                     "path/to/file1.py",
+                     "path/to/file2.txt"
+                 ],
+                 "errors": {
+                     "path/to/problematic/file.py": "Error message"
+                 }
+             }
+    """
+    success = []
+    errors = {}
+    for path, content in files.items():
+        try:
+            abs_path = os.path.abspath(os.path.expanduser(path))
+            directory = os.path.dirname(abs_path)
+            if directory and not os.path.exists(directory):
+                os.makedirs(directory, exist_ok=True)
+            write_file(abs_path, content)
+            success.append(path)
+        except Exception as e:
+            errors[path] = f"Error writing file: {e}"
+    return json.dumps({"success": success, "errors": errors})

{zrb-1.9.0 → zrb-1.9.1}/src/zrb/builtin/llm/tool/web.py

@@ -58,7 +58,7 @@ async def open_web_page(url: str) -> str:
 
 def create_search_internet_tool(serp_api_key: str) -> Callable[[str, int], str]:
     def search_internet(query: str, num_results: int = 10) -> str:
-        """Search the internet using SerpApi (Google Search) and return parsed results.
+        """Search the internet Google Search and return parsed results.
         Args:
             query (str): Search query.
             num_results (int): Search result count. Defaults to 10.

{zrb-1.9.0 → zrb-1.9.1}/src/zrb/config.py

@@ -243,13 +243,19 @@ class Config:
 
     @property
     def LLM_MAX_REQUESTS_PER_MINUTE(self) -> int:
-        """Maximum number of LLM requests allowed per minute."""
-        return int(os.getenv("LLM_MAX_REQUESTS_PER_MINUTE", "60"))
+        """
+        Maximum number of LLM requests allowed per minute.
+        Default is conservative to accommodate free-tier LLM providers.
+        """
+        return int(os.getenv("LLM_MAX_REQUESTS_PER_MINUTE", "15"))
 
     @property
     def LLM_MAX_TOKENS_PER_MINUTE(self) -> int:
-        """Maximum number of LLM tokens allowed per minute."""
-        return int(os.getenv("ZRB_LLM_MAX_TOKENS_PER_MINUTE", "200000"))
+        """
+        Maximum number of LLM tokens allowed per minute.
+        Default is conservative to accommodate free-tier LLM providers.
+        """
+        return int(os.getenv("ZRB_LLM_MAX_TOKENS_PER_MINUTE", "100000"))
 
     @property
     def LLM_MAX_TOKENS_PER_REQUEST(self) -> int:
@@ -270,16 +276,16 @@ class Config:
         return to_boolean(os.getenv("ZRB_LLM_SUMMARIZE_HISTORY", "true"))
 
     @property
-    def LLM_HISTORY_SUMMARIZATION_THRESHOLD(self) -> int:
-        return int(os.getenv("ZRB_LLM_HISTORY_SUMMARIZATION_THRESHOLD", "5"))
+    def LLM_HISTORY_SUMMARIZATION_TOKEN_THRESHOLD(self) -> int:
+        return int(os.getenv("ZRB_LLM_HISTORY_SUMMARIZATION_TOKEN_THRESHOLD", "3000"))
 
     @property
     def LLM_ENRICH_CONTEXT(self) -> bool:
         return to_boolean(os.getenv("ZRB_LLM_ENRICH_CONTEXT", "true"))
 
     @property
-    def LLM_CONTEXT_ENRICHMENT_THRESHOLD(self) -> int:
-        return int(os.getenv("ZRB_LLM_CONTEXT_ENRICHMENT_THRESHOLD", "5"))
+    def LLM_CONTEXT_ENRICHMENT_TOKEN_THRESHOLD(self) -> int:
+        return int(os.getenv("ZRB_LLM_CONTEXT_ENRICHMENT_TOKEN_THRESHOLD", "3000"))
 
     @property
     def LLM_HISTORY_DIR(self) -> str:

{zrb-1.9.0 → zrb-1.9.1}/src/zrb/llm_config.py

@@ -178,9 +178,9 @@ class LLMConfig:
         default_summarization_prompt: str | None = None,
         default_context_enrichment_prompt: str | None = None,
         default_summarize_history: bool | None = None,
-        default_history_summarization_threshold: int | None = None,
+        default_history_summarization_token_threshold: int | None = None,
         default_enrich_context: bool | None = None,
-        default_context_enrichment_threshold: int | None = None,
+        default_context_enrichment_token_threshold: int | None = None,
         default_model: "Model | None" = None,
         default_model_settings: "ModelSettings | None" = None,
         default_model_provider: "Provider | None" = None,
@@ -195,12 +195,12 @@ class LLMConfig:
         self._default_summarization_prompt = default_summarization_prompt
         self._default_context_enrichment_prompt = default_context_enrichment_prompt
         self._default_summarize_history = default_summarize_history
-        self._default_history_summarization_threshold = (
-            default_history_summarization_threshold
+        self._default_history_summarization_token_threshold = (
+            default_history_summarization_token_threshold
         )
         self._default_enrich_context = default_enrich_context
-        self._default_context_enrichment_threshold = (
-            default_context_enrichment_threshold
+        self._default_context_enrichment_token_threshold = (
+            default_context_enrichment_token_threshold
         )
         self._default_model_settings = default_model_settings
         self._default_model_provider = default_model_provider
@@ -316,10 +316,10 @@ class LLMConfig:
         return CFG.LLM_SUMMARIZE_HISTORY
 
     @property
-    def default_history_summarization_threshold(self) -> int:
-        if self._default_history_summarization_threshold is not None:
-            return self._default_history_summarization_threshold
-        return CFG.LLM_HISTORY_SUMMARIZATION_THRESHOLD
+    def default_history_summarization_token_threshold(self) -> int:
+        if self._default_history_summarization_token_threshold is not None:
+            return self._default_history_summarization_token_threshold
+        return CFG.LLM_HISTORY_SUMMARIZATION_TOKEN_THRESHOLD
 
     @property
     def default_enrich_context(self) -> bool:
@@ -328,10 +328,10 @@ class LLMConfig:
         return CFG.LLM_ENRICH_CONTEXT
 
     @property
-    def default_context_enrichment_threshold(self) -> int:
-        if self._default_context_enrichment_threshold is not None:
-            return self._default_context_enrichment_threshold
-        return CFG.LLM_CONTEXT_ENRICHMENT_THRESHOLD
+    def default_context_enrichment_token_threshold(self) -> int:
+        if self._default_context_enrichment_token_threshold is not None:
+            return self._default_context_enrichment_token_threshold
+        return CFG.LLM_CONTEXT_ENRICHMENT_TOKEN_THRESHOLD
 
     def set_default_persona(self, persona: str):
         self._default_persona = persona
@@ -369,18 +369,22 @@ class LLMConfig:
     def set_default_summarize_history(self, summarize_history: bool):
         self._default_summarize_history = summarize_history
 
-    def set_default_history_summarization_threshold(
-        self, history_summarization_threshold: int
+    def set_default_history_summarization_token_threshold(
+        self, history_summarization_token_threshold: int
     ):
-        self._default_history_summarization_threshold = history_summarization_threshold
+        self._default_history_summarization_token_threshold = (
+            history_summarization_token_threshold
+        )
 
     def set_default_enrich_context(self, enrich_context: bool):
         self._default_enrich_context = enrich_context
 
-    def set_default_context_enrichment_threshold(
-        self, context_enrichment_threshold: int
+    def set_default_context_enrichment_token_threshold(
+        self, context_enrichment_token_threshold: int
     ):
-        self._default_context_enrichment_threshold = context_enrichment_threshold
+        self._default_context_enrichment_token_threshold = (
+            context_enrichment_token_threshold
+        )
 
     def set_default_model_settings(self, model_settings: "ModelSettings"):
         self._default_model_settings = model_settings

{zrb-1.9.0 → zrb-1.9.1}/src/zrb/task/llm/context_enrichment.py

@@ -5,7 +5,7 @@ from typing import TYPE_CHECKING
 from zrb.attr.type import BoolAttr, IntAttr
 from zrb.context.any_context import AnyContext
 from zrb.llm_config import llm_config
-from zrb.llm_rate_limitter import LLMRateLimiter
+from zrb.llm_rate_limitter import LLMRateLimiter, llm_rate_limitter
 from zrb.task.llm.agent import run_agent_iteration
 from zrb.task.llm.history import (
     count_part_in_history_list,
@@ -20,6 +20,12 @@ if TYPE_CHECKING:
     from pydantic_ai.settings import ModelSettings
 
 
+def _count_token_in_history(history_list: ListOfDict) -> int:
+    """Counts the total number of tokens in a conversation history list."""
+    text_to_count = json.dumps(history_list)
+    return llm_rate_limitter.count_token(text_to_count)
+
+
 async def enrich_context(
     ctx: AnyContext,
     model: "Model | str | None",
@@ -77,22 +83,22 @@ async def enrich_context(
     return previous_long_term_context
 
 
-def get_context_enrichment_threshold(
+def get_context_enrichment_token_threshold(
     ctx: AnyContext,
-    context_enrichment_threshold_attr: IntAttr | None,
-    render_context_enrichment_threshold: bool,
+    context_enrichment_token_threshold_attr: IntAttr | None,
+    render_context_enrichment_token_threshold: bool,
 ) -> int:
-    """Gets the context enrichment threshold, handling defaults and errors."""
+    """Gets the context enrichment token threshold, handling defaults and errors."""
     try:
         return get_int_attr(
             ctx,
-            context_enrichment_threshold_attr,
-            llm_config.default_context_enrichment_threshold,
-            auto_render=render_context_enrichment_threshold,
+            context_enrichment_token_threshold_attr,
+            llm_config.default_context_enrichment_token_threshold,
+            auto_render=render_context_enrichment_token_threshold,
         )
     except ValueError as e:
         ctx.log_warning(
-            f"Could not convert context_enrichment_threshold to int: {e}. "
+            f"Could not convert context_enrichment_token_threshold to int: {e}. "
             "Defaulting to -1 (no threshold)."
         )
         return -1
@@ -103,21 +109,25 @@ def should_enrich_context(
     history_list: ListOfDict,
     should_enrich_context_attr: BoolAttr | None,
     render_enrich_context: bool,
-    context_enrichment_threshold_attr: IntAttr | None,
-    render_context_enrichment_threshold: bool,
+    context_enrichment_token_threshold_attr: IntAttr | None,
+    render_context_enrichment_token_threshold: bool,
 ) -> bool:
     """
-    Determines if context enrichment should occur based on history, threshold, and config.
+    Determines if context enrichment should occur based on history, token threshold, and config.
     """
     history_part_count = count_part_in_history_list(history_list)
     if history_part_count == 0:
         return False
-    enrichment_threshold = get_context_enrichment_threshold(
+    enrichment_token_threshold = get_context_enrichment_token_threshold(
         ctx,
-        context_enrichment_threshold_attr,
-        render_context_enrichment_threshold,
+        context_enrichment_token_threshold_attr,
+        render_context_enrichment_token_threshold,
     )
-    if enrichment_threshold == -1 or enrichment_threshold > history_part_count:
+    history_token_count = _count_token_in_history(history_list)
+    if (
+        enrichment_token_threshold == -1
+        or enrichment_token_threshold > history_token_count
+    ):
         return False
     return get_bool_attr(
         ctx,
@@ -133,22 +143,22 @@ async def maybe_enrich_context(
     long_term_context: str,
     should_enrich_context_attr: BoolAttr | None,
     render_enrich_context: bool,
-    context_enrichment_threshold_attr: IntAttr | None,
-    render_context_enrichment_threshold: bool,
+    context_enrichment_token_threshold_attr: IntAttr | None,
+    render_context_enrichment_token_threshold: bool,
     model: "str | Model | None",
     model_settings: "ModelSettings | None",
     context_enrichment_prompt: str,
     rate_limitter: LLMRateLimiter | None = None,
 ) -> str:
-    """Enriches context based on history if enabled and threshold met."""
+    """Enriches context based on history if enabled and token threshold met."""
     shorten_history_list = replace_system_prompt_in_history_list(history_list)
     if should_enrich_context(
         ctx,
         shorten_history_list,
         should_enrich_context_attr,
         render_enrich_context,
-        context_enrichment_threshold_attr,
-        render_context_enrichment_threshold,
+        context_enrichment_token_threshold_attr,
+        render_context_enrichment_token_threshold,
     ):
         return await enrich_context(
             ctx=ctx,

{zrb-1.9.0 → zrb-1.9.1}/src/zrb/task/llm/history_summarization.py

@@ -5,7 +5,7 @@ from typing import TYPE_CHECKING
 from zrb.attr.type import BoolAttr, IntAttr
 from zrb.context.any_context import AnyContext
 from zrb.llm_config import llm_config
-from zrb.llm_rate_limitter import LLMRateLimiter
+from zrb.llm_rate_limitter import LLMRateLimiter, llm_rate_limitter
 from zrb.task.llm.agent import run_agent_iteration
 from zrb.task.llm.history import (
     count_part_in_history_list,
@@ -20,22 +20,28 @@ if TYPE_CHECKING:
     from pydantic_ai.settings import ModelSettings
 
 
-def get_history_summarization_threshold(
+def _count_token_in_history(history_list: ListOfDict) -> int:
+    """Counts the total number of tokens in a conversation history list."""
+    text_to_count = json.dumps(history_list)
+    return llm_rate_limitter.count_token(text_to_count)
+
+
+def get_history_summarization_token_threshold(
     ctx: AnyContext,
-    history_summarization_threshold_attr: IntAttr | None,
-    render_history_summarization_threshold: bool,
+    history_summarization_token_threshold_attr: IntAttr | None,
+    render_history_summarization_token_threshold: bool,
 ) -> int:
-    """Gets the history summarization threshold, handling defaults and errors."""
+    """Gets the history summarization token threshold, handling defaults and errors."""
     try:
         return get_int_attr(
             ctx,
-            history_summarization_threshold_attr,
-            llm_config.default_history_summarization_threshold,
-            auto_render=render_history_summarization_threshold,
+            history_summarization_token_threshold_attr,
+            llm_config.default_history_summarization_token_threshold,
+            auto_render=render_history_summarization_token_threshold,
         )
     except ValueError as e:
         ctx.log_warning(
-            f"Could not convert history_summarization_threshold to int: {e}. "
+            f"Could not convert history_summarization_token_threshold to int: {e}. "
             "Defaulting to -1 (no threshold)."
         )
         return -1
@@ -46,19 +52,23 @@ def should_summarize_history(
     history_list: ListOfDict,
     should_summarize_history_attr: BoolAttr | None,
     render_summarize_history: bool,
-    history_summarization_threshold_attr: IntAttr | None,
-    render_history_summarization_threshold: bool,
+    history_summarization_token_threshold_attr: IntAttr | None,
+    render_history_summarization_token_threshold: bool,
 ) -> bool:
-    """Determines if history summarization should occur based on length and config."""
+    """Determines if history summarization should occur based on token length and config."""
     history_part_count = count_part_in_history_list(history_list)
     if history_part_count == 0:
         return False
-    summarization_threshold = get_history_summarization_threshold(
+    summarization_token_threshold = get_history_summarization_token_threshold(
         ctx,
-        history_summarization_threshold_attr,
-        render_history_summarization_threshold,
+        history_summarization_token_threshold_attr,
+        render_history_summarization_token_threshold,
     )
-    if summarization_threshold == -1 or summarization_threshold > history_part_count:
+    history_token_count = _count_token_in_history(history_list)
+    if (
+        summarization_token_threshold == -1
+        or summarization_token_threshold > history_token_count
+    ):
         return False
     return get_bool_attr(
         ctx,
@@ -102,7 +112,7 @@ async def summarize_history(
             history_list=[],
             rate_limitter=rate_limitter,
         )
-        if summary_run and summary_run.result.output:
+        if summary_run and summary_run.result and summary_run.result.output:
             new_summary = str(summary_run.result.output)
             usage = summary_run.result.usage()
             ctx.print(stylize_faint(f"📝 Summarization Token: {usage}"), plain=True)
@@ -126,8 +136,8 @@ async def maybe_summarize_history(
     conversation_summary: str,
     should_summarize_history_attr: BoolAttr | None,
     render_summarize_history: bool,
-    history_summarization_threshold_attr: IntAttr | None,
-    render_history_summarization_threshold: bool,
+    history_summarization_token_threshold_attr: IntAttr | None,
+    render_history_summarization_token_threshold: bool,
     model: "str | Model | None",
     model_settings: "ModelSettings | None",
     summarization_prompt: str,
@@ -140,8 +150,8 @@ async def maybe_summarize_history(
         shorten_history_list,
         should_summarize_history_attr,
         render_summarize_history,
-        history_summarization_threshold_attr,
-        render_history_summarization_threshold,
+        history_summarization_token_threshold_attr,
+        render_history_summarization_token_threshold,
     ):
         new_summary = await summarize_history(
             ctx=ctx,