zrb 1.21.9__py3-none-any.whl → 1.21.31__py3-none-any.whl

zrb/builtin/llm/tool/web.py

@@ -2,6 +2,7 @@ from collections.abc import Callable
 from typing import Any
 from urllib.parse import urljoin
 
+from zrb.builtin.llm.tool.search import brave, searxng, serpapi
 from zrb.config.config import CFG
 from zrb.config.llm_config import llm_config
 
@@ -30,78 +31,17 @@ async def open_web_page(url: str) -> dict[str, Any]:
 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
+    if (
+        CFG.SEARCH_INTERNET_METHOD.strip().lower() == "serpapi"
+        and CFG.SERPAPI_KEY != ""
+    ):
+        return serpapi.search_internet
+    if (
+        CFG.SEARCH_INTERNET_METHOD.strip().lower() == "brave"
+        and CFG.BRAVE_API_KEY != ""
+    ):
+        return brave.search_internet
+    return searxng.search_internet
 
 
 async def _fetch_page_content(url: str) -> tuple[str, list[str]]:

zrb/config/config.py

@@ -28,8 +28,13 @@ class Config:
     def ENV_PREFIX(self) -> str:
         return os.getenv("_ZRB_ENV_PREFIX", "ZRB")
 
-    def _getenv(self, env_name: str, default: str = "") -> str:
-        return os.getenv(f"{self.ENV_PREFIX}_{env_name}", default)
+    def _getenv(self, env_name: str | list[str], default: str = "") -> str:
+        env_name_list = env_name if isinstance(env_name, list) else [env_name]
+        for env_name in env_name_list:
+            value = os.getenv(f"{self.ENV_PREFIX}_{env_name}", None)
+            if value is not None:
+                return value
+        return default
 
     def _get_internal_default_prompt(self, name: str) -> str:
         if name not in self.__internal_default_prompt:
@@ -60,6 +65,38 @@ class Config:
     def DEFAULT_EDITOR(self) -> str:
         return self._getenv("EDITOR", "nano")
 
+    @property
+    def DEFAULT_DIFF_EDIT_COMMAND_TPL(self) -> str:
+        return self._getenv("DIFF_EDIT_COMMAND", self._get_default_diff_edit_command())
+
+    def _get_default_diff_edit_command(self) -> str:
+        editor = self.DEFAULT_EDITOR
+        if editor in [
+            "code",
+            "vscode",
+            "vscodium",
+            "windsurf",
+            "cursor",
+            "zed",
+            "zeditor",
+            "agy",
+        ]:
+            return f"{editor} --wait --diff {{old}} {{new}}"
+        if editor == "emacs":
+            return 'emacs --eval \'(ediff-files "{old}" "{new}")\''
+        if editor in ["nvim", "vim"]:
+            return (
+                f"{editor} -d {{old}} {{new}} "
+                "-i NONE "
+                '-c "wincmd h | set readonly | wincmd l" '
+                '-c "highlight DiffAdd cterm=bold ctermbg=22 guibg=#005f00 | highlight DiffChange cterm=bold ctermbg=24 guibg=#005f87 | highlight DiffText ctermbg=21 guibg=#0000af | highlight DiffDelete ctermbg=52 guibg=#5f0000" '  # noqa
+                '-c "set showtabline=2 | set tabline=[Instructions]\\ :wqa(save\\ &\\ quit)\\ \\|\\ i/esc(toggle\\ edit\\ mode)" '  # noqa
+                '-c "wincmd h | setlocal statusline=OLD\\ FILE" '
+                '-c "wincmd l | setlocal statusline=%#StatusBold#NEW\\ FILE\\ :wqa(save\\ &\\ quit)\\ \\|\\ i/esc(toggle\\ edit\\ mode)" '  # noqa
+                '-c "autocmd BufWritePost * wqa"'
+            )
+        return 'vimdiff {old} {new} +"setlocal ro" +"wincmd l" +"autocmd BufWritePost <buffer> qa"'  # noqa
+
     @property
     def INIT_MODULES(self) -> list[str]:
         init_modules_str = self._getenv("INIT_MODULES", "")
@@ -287,7 +324,9 @@ class Config:
     @property
     def LLM_BUILTIN_WORKFLOW_PATHS(self) -> list[str]:
         """Get a list of additional builtin workflow paths from environment variables."""
-        builtin_workflow_paths_str = self._getenv("LLM_BUILTIN_WORKFLOW_PATHS", "")
+        builtin_workflow_paths_str = self._getenv(
+            ["LLM_BUILTIN_WORFKLOW_PATH", "LLM_BUILTIN_WORKFLOW_PATHS"], ""
+        )
         if builtin_workflow_paths_str != "":
             return [
                 path.strip()
@@ -306,13 +345,21 @@ class Config:
         value = self._getenv("LLM_SUMMARIZATION_PROMPT")
         return None if value == "" else value
 
+    @property
+    def LLM_SHOW_TOOL_CALL_RESULT(self) -> bool:
+        return to_boolean(self._getenv("LLM_SHOW_TOOL_CALL_RESULT", "false"))
+
     @property
     def LLM_MAX_REQUESTS_PER_MINUTE(self) -> int:
         """
         Maximum number of LLM requests allowed per minute.
         Default is conservative to accommodate free-tier LLM providers.
         """
-        return int(self._getenv("LLM_MAX_REQUESTS_PER_MINUTE", "60"))
+        return int(
+            self._getenv(
+                ["LLM_MAX_REQUEST_PER_MINUTE", "LLM_MAX_REQUESTS_PER_MINUTE"], "60"
+            )
+        )
 
     @property
     def LLM_MAX_TOKENS_PER_MINUTE(self) -> int:
@@ -320,22 +367,38 @@ class Config:
         Maximum number of LLM tokens allowed per minute.
         Default is conservative to accommodate free-tier LLM providers.
         """
-        return int(self._getenv("LLM_MAX_TOKENS_PER_MINUTE", "100000"))
+        return int(
+            self._getenv(
+                ["LLM_MAX_TOKEN_PER_MINUTE", "LLM_MAX_TOKENS_PER_MINUTE"], "100000"
+            )
+        )
 
     @property
     def LLM_MAX_TOKENS_PER_REQUEST(self) -> int:
         """Maximum number of tokens allowed per individual LLM request."""
-        return int(self._getenv("LLM_MAX_TOKENS_PER_REQUEST", "100000"))
+        return int(
+            self._getenv(
+                ["LLM_MAX_TOKEN_PER_REQUEST", "LLM_MAX_TOKENS_PER_REQUEST"], "120000"
+            )
+        )
 
     @property
     def LLM_MAX_TOKENS_PER_TOOL_CALL_RESULT(self) -> int:
         """Maximum number of tokens allowed per tool call result."""
-        return int(self._getenv("LLM_MAX_TOKENS_PER_TOOL_CALL_RESULT", "75000"))
+        return int(
+            self._getenv(
+                [
+                    "LLM_MAX_TOKEN_PER_TOOL_CALL_RESULT",
+                    "LLM_MAX_TOKENS_PER_TOOL_CALL_RESULT",
+                ],
+                str(self._get_max_threshold(0.4)),
+            )
+        )
 
     @property
     def LLM_THROTTLE_SLEEP(self) -> float:
         """Number of seconds to sleep when throttling is required."""
-        return float(self._getenv("LLM_THROTTLE_SLEEP", "1.0"))
+        return float(self._getenv("LLM_THROTTLE_SLEEP", "5.0"))
 
     @property
     def LLM_YOLO_MODE(self) -> bool | list[str]:
@@ -351,19 +414,51 @@ class Config:
 
     @property
     def LLM_HISTORY_SUMMARIZATION_TOKEN_THRESHOLD(self) -> int:
-        return int(self._getenv("LLM_HISTORY_SUMMARIZATION_TOKEN_THRESHOLD", "20000"))
+        threshold = int(
+            self._getenv(
+                "LLM_HISTORY_SUMMARIZATION_TOKEN_THRESHOLD",
+                str(self._get_max_threshold(0.6)),
+            )
+        )
+        return self._limit_token_threshold(threshold, 0.6)
 
     @property
     def LLM_REPO_ANALYSIS_EXTRACTION_TOKEN_THRESHOLD(self) -> int:
-        return int(self._getenv("LLM_REPO_ANALYSIS_EXTRACTION_TOKEN_LIMIT", "100000"))
+        threshold = int(
+            self._getenv(
+                "LLM_REPO_ANALYSIS_EXTRACTION_TOKEN_THRESHOLD",
+                str(self._get_max_threshold(0.4)),
+            )
+        )
+        return self._limit_token_threshold(threshold, 0.4)
 
     @property
     def LLM_REPO_ANALYSIS_SUMMARIZATION_TOKEN_THRESHOLD(self) -> int:
-        return int(self._getenv("LLM_REPO_ANALYSIS_SUMMARIZATION_TOKEN_LIMIT", "20000"))
+        threshold = int(
+            self._getenv(
+                "LLM_REPO_ANALYSIS_SUMMARIZATION_TOKEN_THRESHOLD",
+                str(self._get_max_threshold(0.4)),
+            )
+        )
+        return self._limit_token_threshold(threshold, 0.4)
 
     @property
-    def LLM_FILE_ANALYSIS_TOKEN_LIMIT(self) -> int:
-        return int(self._getenv("LLM_FILE_ANALYSIS_TOKEN_LIMIT", "100000"))
+    def LLM_FILE_ANALYSIS_TOKEN_THRESHOLD(self) -> int:
+        threshold = int(
+            self._getenv(
+                "LLM_FILE_ANALYSIS_TOKEN_THRESHOLD", str(self._get_max_threshold(0.4))
+            )
+        )
+        return self._limit_token_threshold(threshold, 0.4)
+
+    def _limit_token_threshold(self, threshold: int, factor: float) -> int:
+        return min(threshold, self._get_max_threshold(factor))
+
+    def _get_max_threshold(self, factor: float) -> int:
+        return round(
+            factor
+            * min(self.LLM_MAX_TOKENS_PER_MINUTE, self.LLM_MAX_TOKENS_PER_REQUEST)
+        )
 
     @property
     def LLM_FILE_EXTRACTOR_SYSTEM_PROMPT(self) -> str:

zrb/config/default_prompt/interactive_system_prompt.md

@@ -1,4 +1,4 @@
-You are an expert interactive AI agent. Your primary goal is to help users safely and efficiently.
+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.

zrb/config/default_prompt/summarization_prompt.md

@@ -1,11 +1,57 @@
-You are a memory management AI. Your only task is to process the provided conversation history and call the `final_result` tool **once**.
+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.
 
-Follow these instructions carefully:
+You will receive a JSON string representing the full conversation history. This JSON contains a list of message objects.
 
-1. **Summarize:** Create a concise narrative summary that integrates the `Past Conversation Summary` with the `Recent Conversation`. **This summary must not be more than two paragraphs.**
-2. **Transcript:** Extract ONLY the last 4 (four) turns of the `Recent Conversation` to serve as the new transcript.
-  * **Do not change or shorten the content of these turns, with one exception:** If a tool call returns a very long output, do not include the full output. Instead, briefly summarize the result of the tool call.
-  * Ensure the timestamp format is `[YYYY-MM-DD HH:MM:SS UTC+Z] Role: Message/Tool name being called`.
-3. **Update Memory:** Call the `final_result` tool with all the information you consolidated.
+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.
 
-After you have called the tool, your task is complete.
+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,4 +1,4 @@
-You are an expert AI agent designed for completing a single request. 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.
+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
 

zrb/config/llm_rate_limitter.py

@@ -7,7 +7,7 @@ from typing import Any, Callable
 from zrb.config.config import CFG
 
 
-class LLMRateLimiter:
+class LLMRateLimitter:
     """
     Helper class to enforce LLM API rate limits and throttling.
     Tracks requests and tokens in a rolling 60-second window.
@@ -129,7 +129,7 @@ class LLMRateLimiter:
     async def throttle(
         self,
         prompt: Any,
-        throttle_notif_callback: Callable | None = None,
+        throttle_notif_callback: Callable[[str], Any] | None = None,
     ):
         now = time.time()
         str_prompt = self._prompt_to_str(prompt)
@@ -142,7 +142,17 @@ class LLMRateLimiter:
         # Check per-request token limit
         if tokens > self.max_tokens_per_request:
             raise ValueError(
-                f"Request exceeds max_tokens_per_request ({self.max_tokens_per_request})."
+                (
+                    "Request exceeds max_tokens_per_request "
+                    f"({tokens} > {self.max_tokens_per_request})."
+                )
+            )
+        if tokens > self.max_tokens_per_minute:
+            raise ValueError(
+                (
+                    "Request exceeds max_tokens_per_minute "
+                    f"({tokens} > {self.max_tokens_per_minute})."
+                )
             )
         # Wait if over per-minute request or token limit
         while (
@@ -150,7 +160,16 @@ class LLMRateLimiter:
             or sum(t for _, t in self.token_times) + tokens > self.max_tokens_per_minute
         ):
             if throttle_notif_callback is not None:
-                throttle_notif_callback()
+                if len(self.request_times) >= self.max_requests_per_minute:
+                    rpm = len(self.request_times)
+                    throttle_notif_callback(
+                        f"Max request per minute exceeded: {rpm} of {self.max_requests_per_minute}"
+                    )
+                else:
+                    tpm = sum(t for _, t in self.token_times) + tokens
+                    throttle_notif_callback(
+                        f"Max token per minute exceeded: {tpm} of {self.max_tokens_per_minute}"
+                    )
             await asyncio.sleep(self.throttle_sleep)
             now = time.time()
             while self.request_times and now - self.request_times[0] > 60:
@@ -168,4 +187,4 @@ class LLMRateLimiter:
             return f"{prompt}"
 
 
-llm_rate_limitter = LLMRateLimiter()
+llm_rate_limitter = LLMRateLimitter()

zrb/input/option_input.py

@@ -47,9 +47,21 @@ class OptionInput(BaseInput):
         option_str = ", ".join(options)
         if default_value != "":
             prompt_message = f"{prompt_message} ({option_str}) [{default_value}]"
-        value = input(f"{prompt_message}: ")
+        value = self._get_value_from_user_input(shared_ctx, prompt_message, options)
         if value.strip() != "" and value.strip() not in options:
             value = self._prompt_cli_str(shared_ctx)
         if value.strip() == "":
             value = default_value
         return value
+
+    def _get_value_from_user_input(
+        self, shared_ctx: AnySharedContext, prompt_message: str, options: list[str]
+    ) -> str:
+        from prompt_toolkit import PromptSession
+        from prompt_toolkit.completion import WordCompleter
+
+        if shared_ctx.is_tty:
+            reader = PromptSession()
+            option_completer = WordCompleter(options, ignore_case=True)
+            return reader.prompt(f"{prompt_message}: ", completer=option_completer)
+        return input(f"{prompt_message}: ")