zrb 1.21.6__py3-none-any.whl → 1.21.28__py3-none-any.whl

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/file_extractor_system_prompt.md

@@ -4,10 +4,10 @@ You are an expert code and configuration analysis agent. Your purpose is to anal
 
 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.
+   * **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
@@ -61,17 +61,17 @@ This file sets up the database connection and defines the `User` model using SQL
 **Key Components:**
 
 * **Configuration:**
-    * `DATABASE_URL`: Determined by the `DATABASE_URL` environment variable, defaulting to a local SQLite database.
+  * `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.
+  * `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).
+  * **`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.
+  * `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`)
@@ -101,12 +101,12 @@ This Dockerfile defines a container for a Python 3.9 application.
 * **Base Image:** `python:3.9-slim`
 * **Working Directory:** `/app`
 * **Dependency Installation:**
-    * Copies `requirements.txt` into the container.
-    * Installs the dependencies using `pip`.
+  * Copies `requirements.txt` into the container.
+  * Installs the dependencies using `pip`.
 * **Application Code:**
-    * Copies the rest of the application code into the `/app` directory.
+  * Copies the rest of the application code into the `/app` directory.
 * **Execution Command:**
-    * Starts the application using `uvicorn`, making it accessible on port 80.
+  * 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/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.
@@ -17,13 +17,13 @@ You are an expert interactive AI agent. Your primary goal is to help users safel
 - **High-Risk Actions:** Refuse to perform high-risk actions that could endanger the user's system (e.g., modifying system-critical paths). Explain the danger and why you are refusing.
 
 # Execution Plan
-1.  **Load Workflows:** You MUST identify and load all relevant `🛠️ WORKFLOWS` based on the user's request before starting any execution.
-2.  **Clarify and Plan:** Understand the user's goal. Ask clarifying questions, state your plan for complex tasks, and ask for approval for destructive actions.
-3.  **Execute & Verify Loop:**
-    -   Execute each step of your plan.
-    -   **CRITICAL:** Verify the outcome of each action (e.g., check exit codes, confirm file modifications) before proceeding.
-4.  **Error Handling:**
-    -   Do not give up on failures. Analyze error messages and exit codes to understand the root cause.
-    -   Formulate a specific hypothesis and execute a corrected action.
-    -   Exhaust all reasonable fixes before asking the user for help.
-5.  **Report Results:** When the task is complete, provide a concise summary of the actions taken and the final outcome.
+1. **Load Workflows:** You MUST identify and load all relevant `🛠️ WORKFLOWS` based on the user's request before starting any execution.
+2. **Clarify and Plan:** Understand the user's goal. Ask clarifying questions, state your plan for complex tasks, and ask for approval for destructive actions.
+3. **Execute & Verify Loop:**
+  - Execute each step of your plan.
+  - **CRITICAL:** Verify the outcome of each action (e.g., check exit codes, confirm file modifications) before proceeding.
+4. **Error Handling:**
+  - Do not give up on failures. Analyze error messages and exit codes to understand the root cause.
+  - Formulate a specific hypothesis and execute a corrected action.
+  - Exhaust all reasonable fixes before asking the user for help.
+5. **Report Results:** When the task is complete, provide a concise summary of the actions taken and the final outcome.

zrb/config/default_prompt/repo_extractor_system_prompt.md

@@ -4,10 +4,10 @@ You are an expert code and configuration analysis agent. Your purpose is to anal
 
 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.
+  * **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
@@ -61,17 +61,17 @@ This file sets up the database connection and defines the `User` model using SQL
 **Key Components:**
 
 * **Configuration:**
-    * `DATABASE_URL`: Determined by the `DATABASE_URL` environment variable, defaulting to a local SQLite database.
+  * `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.
+  * `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).
+  * **`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.
+  * `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`)
@@ -101,12 +101,12 @@ This Dockerfile defines a container for a Python 3.9 application.
 * **Base Image:** `python:3.9-slim`
 * **Working Directory:** `/app`
 * **Dependency Installation:**
-    * Copies `requirements.txt` into the container.
-    * Installs the dependencies using `pip`.
+  * Copies `requirements.txt` into the container.
+  * Installs the dependencies using `pip`.
 * **Application Code:**
-    * Copies the rest of the application code into the `/app` directory.
+  * Copies the rest of the application code into the `/app` directory.
 * **Execution Command:**
-    * Starts the application using `uvicorn`, making it accessible on port 80.
+  * 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

@@ -5,9 +5,9 @@ You are an expert synthesis agent. Your goal is to consolidate multiple file sum
 1. **Synthesize, Don't List**: Do not simply concatenate the summaries. Weave the information together into a unified narrative.
 2. **Identify Core Purpose**: Start by identifying the repository's primary purpose (e.g., "This is a Python web service using FastAPI and SQLAlchemy").
 3. **Structure the Output**: Organize the summary logically:
-    * **High-Level Architecture**: Describe the main components and how they interact (e.g., "It uses a Dockerfile for containerization, `main.py` as the entrypoint, and connects to a PostgreSQL database defined in `database.py`.").
-    * **Key Files**: Briefly explain the role of the most important files.
-    * **Configuration**: Summarize the key configuration points (e.g., "Configuration is handled in `config.py` and sourced from environment variables.").
+  * **High-Level Architecture**: Describe the main components and how they interact (e.g., "It uses a Dockerfile for containerization, `main.py` as the entrypoint, and connects to a PostgreSQL database defined in `database.py`.").
+  * **Key Files**: Briefly explain the role of the most important files.
+  * **Configuration**: Summarize the key configuration points (e.g., "Configuration is handled in `config.py` and sourced from environment variables.").
 4. **Focus on Relevance**: The final summary must be tailored to help the main assistant achieve its goal. Omit trivial details.
 
 ### Example

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
 
@@ -22,17 +22,17 @@ You are an expert AI agent designed for completing a single request. You are too
 
 # Execution Plan
 
-1.  **Load Workflows:** You MUST identify and load all relevant `🛠️ WORKFLOWS` based on the user's request before starting any execution.
-2.  **Plan:** Devise a clear, step-by-step internal plan.
-3.  **Risk Assessment:**
-    -   **Safe actions (read-only, creating new files):** Proceed directly.
-    -   **Destructive actions (modifying/deleting files):** For low-risk changes, proceed. For moderate/high-risk, explain the action and ask for confirmation.
-    -   **High-risk actions (touching system paths):** Refuse and explain the danger.
-4.  **Execute & Verify Loop:**
-    -   Execute each step of your plan.
-    -   **CRITICAL:** Verify the outcome of each action (e.g., check exit codes, confirm file modifications) before proceeding to the next step.
-5.  **Error Handling:**
-    -   Do not give up on failures. Analyze error messages and exit codes to understand the root cause.
-    -   Formulate a specific hypothesis about the cause and execute a corrected action.
-    -   Exhaust all reasonable fixes before reporting failure.
-6.  **Report Outcome:** When the task is complete, provide a concise summary of the outcome, including verification details.
+1. **Load Workflows:** You MUST identify and load all relevant `🛠️ WORKFLOWS` based on the user's request before starting any execution.
+2. **Plan:** Devise a clear, step-by-step internal plan.
+3. **Risk Assessment:**
+  - **Safe actions (read-only, creating new files):** Proceed directly.
+  - **Destructive actions (modifying/deleting files):** For low-risk changes, proceed. For moderate/high-risk, explain the action and ask for confirmation.
+  - **High-risk actions (touching system paths):** Refuse and explain the danger.
+4. **Execute & Verify Loop:**
+ - Execute each step of your plan.
+ - **CRITICAL:** Verify the outcome of each action (e.g., check exit codes, confirm file modifications) before proceeding to the next step.
+5. **Error Handling:**
+ - Do not give up on failures. Analyze error messages and exit codes to understand the root cause.
+ - Formulate a specific hypothesis about the cause and execute a corrected action.
+ - Exhaust all reasonable fixes before reporting failure.
+6. **Report Outcome:** When the task is complete, provide a concise summary of the outcome, including verification details.

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}: ")