zrb 1.8.3__py3-none-any.whl → 1.8.5__py3-none-any.whl

zrb/__init__.py

@@ -34,6 +34,7 @@ from zrb.input.password_input import PasswordInput
 from zrb.input.str_input import StrInput
 from zrb.input.text_input import TextInput
 from zrb.llm_config import llm_config
+from zrb.llm_rate_limitter import llm_rate_limitter
 from zrb.runner.cli import cli
 from zrb.runner.web_auth_config import web_auth_config
 from zrb.runner.web_schema.user import User
@@ -105,6 +106,7 @@ assert Scaffolder
 assert Scheduler
 assert cli
 assert llm_config
+assert llm_rate_limitter
 assert Xcom
 assert web_auth_config
 assert User

zrb/builtin/llm/chat_session.py

@@ -33,10 +33,10 @@ async def read_user_prompt(ctx: AnyContext) -> str:
         previous_session_name=ctx.input.previous_session,
         start_new=ctx.input.start_new,
     )
+    if result is not None:
+        final_result = result
     if ctx.env.get("_ZRB_WEB_ENV", "0") != "0":
-        # Don't run in web environment
-        if result is not None:
-            final_result = result
+        # On web environment this won't be interactive
         return final_result
     multiline_mode = False
     user_inputs = []

zrb/builtin/llm/tool/code.py

@@ -0,0 +1,233 @@
+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.context.any_context import AnyContext
+
+_EXTRACT_INFO_SYSTEM_PROMPT = """
+You are an extraction info agent.
+Your goal is to help to extract relevant information to help the main LLM Agent.
+You write your output is in markdown format containing path and relevant information.
+Extract only information that relevant to main LLM Agent's goal.
+
+Extracted Information format (Use this as reference, extract relevant information only):
+# <file-name>
+## imports
+- <imported-package>
+- ...
+## variables
+- <variable-type> <variable-name>: <the-purpose-of-the-variable>
+- ...
+## functions
+- <function-name>:
+  - parameters: <parameters>
+  - logic/description: <what-the-function-do-and-how-it-works>
+...
+# <other-file-name>
+...
+""".strip()
+
+
+_SUMMARIZE_INFO_SYSTEM_PROMPT = """
+You are an information summarization agent.
+Your goal is to summarize information to help the main LLM Agent.
+The summarization result should contains all necessary details
+to help main LLM Agent achieve the goal.
+"""
+
+_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,
+    goal: str,
+    extensions: list[str] = _DEFAULT_EXTENSIONS,
+    exclude_patterns: list[str] = DEFAULT_EXCLUDED_PATTERNS,
+    extraction_char_limit: int = 150000,
+    summarization_char_limit: int = 150000,
+) -> str:
+    """
+    Extract and summarize information from a directory that probably
+    contains a large resources.
+    You should state the goal specifically so that the tool can return relevant informations.
+    Use this tool for:
+    - summarization
+    - outline/structure extraction
+    - code review
+    - create diagram as code
+    - other tasks
+    Args:
+        path (str): File path to be analyze. Pass exactly as provided, including '~'.
+        goal(str): Goal of extracting information (for example creating C4 diagram)
+        extensions(Optional[list[str]]): List of extension to be included
+            while reading resources. Defaults to common programming languages and config files.
+        exclude_patterns(Optional[list[str]]): List of patterns to exclude from analysis.
+            Common patterns like '.venv', 'node_modules' should be excluded by default.
+        extraction_char_limit(Optional[int]): Max resource content char length
+            the extraction assistant able to handle. Defaults to 150000
+        summarization_char_limit(Optional[int]): Max resource content char length
+            the summarization assistant able to handle. Defaults to 150000
+    Returns:
+        str: The analysis result
+    Raises:
+        Exception: If an error occurs.
+    """
+    abs_path = os.path.abspath(os.path.expanduser(path))
+    file_metadatas = _get_file_metadatas(abs_path, extensions, exclude_patterns)
+    ctx.print("Extraction")
+    extracted_infos = await _extract_info(
+        ctx,
+        file_metadatas=file_metadatas,
+        goal=goal,
+        char_limit=extraction_char_limit,
+    )
+    ctx.print("Summarization")
+    summarized_infos = await _summarize_info(
+        ctx,
+        extracted_infos=extracted_infos,
+        goal=goal,
+        char_limit=summarization_char_limit,
+    )
+    while len(summarized_infos) > 1:
+        ctx.print("Summarization")
+        summarized_infos = await _summarize_info(
+            ctx,
+            extracted_infos=summarized_infos,
+            goal=goal,
+            char_limit=summarization_char_limit,
+        )
+    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)
+            if is_excluded(file_path, exclude_patterns):
+                continue
+            try:
+                with open(file_path, "r", encoding="utf-8", errors="ignore") as f:
+                    rel_path = os.path.relpath(file_path, dir_path)
+                    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]],
+    goal: str,
+    char_limit: int,
+) -> list[str]:
+    extract = create_sub_agent_tool(
+        tool_name="extract",
+        tool_description="extract",
+        system_prompt=_EXTRACT_INFO_SYSTEM_PROMPT,
+    )
+    extracted_infos = []
+    content_buffer = ""
+    for metadata in file_metadatas:
+        path = metadata.get("path", "")
+        content = metadata.get("content", "")
+        metadata_str = f"Path: {path}\nContent: {content}"
+        if len(content_buffer) + len(metadata_str) > char_limit:
+            if content_buffer:
+                prompt = _create_extract_info_prompt(goal, content_buffer)
+                extracted_info = await extract(ctx, prompt)
+                extracted_infos.append(extracted_info)
+            content_buffer = metadata_str
+        else:
+            content_buffer += metadata_str + "\n"
+
+    # Process any remaining content in the buffer
+    if content_buffer:
+        prompt = _create_extract_info_prompt(goal, content_buffer)
+        extracted_info = await extract(ctx, prompt)
+        extracted_infos.append(extracted_info)
+    return extracted_infos
+
+
+def _create_extract_info_prompt(goal: str, content_buffer: str) -> str:
+    return f"# Main LLM Agent Goal\n{goal}\n# Files\n{content_buffer}"
+
+
+async def _summarize_info(
+    ctx: AnyContext,
+    extracted_infos: list[str],
+    goal: str,
+    char_limit: int,
+) -> list[str]:
+    summarize = create_sub_agent_tool(
+        tool_name="extract",
+        tool_description="extract",
+        system_prompt=_SUMMARIZE_INFO_SYSTEM_PROMPT,
+    )
+    summarized_infos = []
+    content_buffer = ""
+    for extracted_info in extracted_infos:
+        if len(content_buffer) + len(extracted_info) > char_limit:
+            if content_buffer:
+                prompt = _create_summarize_info_prompt(goal, content_buffer)
+                summarized_info = await summarize(ctx, prompt)
+                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 = _create_summarize_info_prompt(goal, content_buffer)
+        summarized_info = await summarize(ctx, prompt)
+        summarized_infos.append(summarized_info)
+    return summarized_infos
+
+
+def _create_summarize_info_prompt(goal: str, content_buffer: str) -> str:
+    return f"# Main LLM Agent Goal\n{goal}\n# Extracted Info\n{content_buffer}"

zrb/builtin/llm/tool/file.py

@@ -71,6 +71,9 @@ DEFAULT_EXCLUDED_PATTERNS = [
     "*.so",
     "*.dylib",
     "*.dll",
+    # Minified files
+    "*.min.css",
+    "*.min.js",
 ]
 
 
@@ -112,17 +115,17 @@ def list_files(
                     d
                     for d in dirs
                     if (include_hidden or not _is_hidden(d))
-                    and not _is_excluded(d, patterns_to_exclude)
+                    and not is_excluded(d, patterns_to_exclude)
                 ]
                 # Process files
                 for filename in files:
-                    if (
-                        include_hidden or not _is_hidden(filename)
-                    ) and not _is_excluded(filename, patterns_to_exclude):
+                    if (include_hidden or not _is_hidden(filename)) and not is_excluded(
+                        filename, patterns_to_exclude
+                    ):
                         full_path = os.path.join(root, filename)
                         # Check rel path for patterns like '**/node_modules/*'
                         rel_full_path = os.path.relpath(full_path, abs_path)
-                        is_rel_path_excluded = _is_excluded(
+                        is_rel_path_excluded = is_excluded(
                             rel_full_path, patterns_to_exclude
                         )
                         if not is_rel_path_excluded:
@@ -132,7 +135,7 @@ def list_files(
             for item in os.listdir(abs_path):
                 full_path = os.path.join(abs_path, item)
                 # Include both files and directories if not recursive
-                if (include_hidden or not _is_hidden(item)) and not _is_excluded(
+                if (include_hidden or not _is_hidden(item)) and not is_excluded(
                     item, patterns_to_exclude
                 ):
                     all_files.append(full_path)
@@ -169,7 +172,7 @@ def _is_hidden(path: str) -> bool:
     return basename.startswith(".")
 
 
-def _is_excluded(name: str, patterns: list[str]) -> bool:
+def is_excluded(name: str, patterns: list[str]) -> bool:
     """Check if a name/path matches any exclusion patterns."""
     for pattern in patterns:
         if fnmatch.fnmatch(name, pattern):
@@ -461,14 +464,14 @@ async def analyze_file(ctx: AnyContext, path: str, query: str) -> str:
     _analyze_file = create_sub_agent_tool(
         tool_name="analyze_file",
         tool_description="analyze file with LLM capability",
-        sub_agent_system_prompt="\n".join(
+        system_prompt="\n".join(
             [
                 "You are a file analyzer assistant",
                 "Your goal is to help the main asisstant by reading file",
                 "and perform necessary indepth analysis required by the main assistant",
             ]
         ),
-        sub_agent_tools=[read_from_file, search_files],
+        tools=[read_from_file, search_files],
     )
     return await _analyze_file(
         ctx,

zrb/builtin/llm/tool/sub_agent.py

@@ -28,11 +28,11 @@ else:
 def create_sub_agent_tool(
     tool_name: str,
     tool_description: str,
-    sub_agent_system_prompt: str | None = None,  # Make optional
-    sub_agent_model: str | Model | None = None,
-    sub_agent_model_settings: ModelSettings | None = None,
-    sub_agent_tools: list[ToolOrCallable] = [],
-    sub_agent_mcp_servers: list[MCPServer] = [],
+    system_prompt: str | None = None,
+    model: str | Model | None = None,
+    model_settings: ModelSettings | None = None,
+    tools: list[ToolOrCallable] = [],
+    mcp_servers: list[MCPServer] = [],
 ) -> Callable[[AnyContext, str], str]:
     """
     Create an LLM "sub-agent" tool function for use by a main LLM agent.
@@ -63,7 +63,7 @@ def create_sub_agent_tool(
         # Resolve parameters, falling back to llm_config defaults if None
         resolved_model = get_model(
             ctx=ctx,
-            model_attr=sub_agent_model,
+            model_attr=model,
             render_model=True,  # Assuming we always want to render model string attributes
             model_base_url_attr=None,
             # Sub-agent tool doesn't have separate base_url/api_key params
@@ -73,10 +73,10 @@ def create_sub_agent_tool(
         )
         resolved_model_settings = get_model_settings(
             ctx=ctx,
-            model_settings_attr=sub_agent_model_settings,
+            model_settings_attr=model_settings,
         )
 
-        if sub_agent_system_prompt is None:
+        if system_prompt is None:
             resolved_system_prompt = get_combined_system_prompt(
                 ctx=ctx,
                 persona_attr=None,
@@ -87,20 +87,16 @@ def create_sub_agent_tool(
                 render_special_instruction_prompt=False,
             )
         else:
-            resolved_system_prompt = sub_agent_system_prompt
-
+            resolved_system_prompt = system_prompt
         # Create the sub-agent instance
         sub_agent_agent = create_agent_instance(
             ctx=ctx,
             model=resolved_model,
             system_prompt=resolved_system_prompt,
             model_settings=resolved_model_settings,
-            tools_attr=sub_agent_tools,  # Pass tools from factory closure
-            additional_tools=[],  # No additional tools added after factory creation
-            mcp_servers_attr=sub_agent_mcp_servers,  # Pass servers from factory closure
-            additional_mcp_servers=[],  # No additional servers added after factory creation
+            tools=tools,
+            mcp_servers=mcp_servers,
         )
-
         # Run the sub-agent iteration
         # Start with an empty history for the sub-agent
         sub_agent_run = await run_agent_iteration(

zrb/callback/callback.py

@@ -1,3 +1,4 @@
+import traceback
 from typing import Any
 
 from zrb.attr.type import StrDictAttr
@@ -5,6 +6,7 @@ from zrb.callback.any_callback import AnyCallback
 from zrb.session.any_session import AnySession
 from zrb.task.any_task import AnyTask
 from zrb.util.attr import get_str_dict_attr
+from zrb.util.cli.style import stylize_faint
 from zrb.util.string.conversion import to_snake_case
 from zrb.xcom.xcom import Xcom
 
@@ -67,6 +69,8 @@ class Callback(AnyCallback):
             self._maybe_publish_result_to_parent_session(parent_session, result)
             return result
         except BaseException as e:
+            ctx = session.get_ctx(self._task)
+            ctx.print(traceback.format_exc())
             self._maybe_publish_error_to_parent_session(parent_session, e)
 
     def _maybe_publish_session_name_to_parent_session(

zrb/config.py

@@ -237,6 +237,26 @@ class Config:
     def LLM_SUMMARIZATION_PROMPT(self) -> str | None:
         return os.getenv("ZRB_LLM_SUMMARIZATION_PROMPT", None)
 
+    @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"))
+
+    @property
+    def LLM_MAX_TOKENS_PER_MINUTE(self) -> int:
+        """Maximum number of LLM tokens allowed per minute."""
+        return int(os.getenv("LLM_MAX_TOKENS_PER_MINUTE", "120000"))
+
+    @property
+    def LLM_MAX_TOKENS_PER_REQUEST(self) -> int:
+        """Maximum number of tokens allowed per individual LLM request."""
+        return int(os.getenv("LLM_MAX_TOKENS_PER_REQUEST", "4096"))
+
+    @property
+    def LLM_THROTTLE_SLEEP(self) -> float:
+        """Number of seconds to sleep when throttling is required."""
+        return float(os.getenv("LLM_THROTTLE_SLEEP", "1.0"))
+
     @property
     def LLM_CONTEXT_ENRICHMENT_PROMPT(self) -> str | None:
         return os.getenv("ZRB_LLM_CONTEXT_ENRICHMENT_PROMPT", None)

zrb/llm_rate_limitter.py

@@ -0,0 +1,105 @@
+import asyncio
+import time
+from collections import deque
+from typing import Callable
+
+from zrb.config import CFG
+
+
+class LLMRateLimiter:
+    """
+    Helper class to enforce LLM API rate limits and throttling.
+    Tracks requests and tokens in a rolling 60-second window.
+    """
+
+    def __init__(
+        self,
+        max_requests_per_minute: int | None = None,
+        max_tokens_per_minute: int | None = None,
+        max_tokens_per_request: int | None = None,
+        throttle_sleep: float | None = None,
+        token_counter_fn: Callable[[str], int] | None = None,
+    ):
+        self._max_requests_per_minute = max_requests_per_minute
+        self._max_tokens_per_minute = max_tokens_per_minute
+        self._max_tokens_per_request = max_tokens_per_request
+        self._throttle_sleep = throttle_sleep
+        self._token_counter_fn = token_counter_fn
+        self.request_times = deque()
+        self.token_times = deque()
+
+    @property
+    def max_requests_per_minute(self) -> int:
+        if self._max_requests_per_minute is not None:
+            return self._max_requests_per_minute
+        return CFG.LLM_MAX_REQUESTS_PER_MINUTE
+
+    @property
+    def max_tokens_per_minute(self) -> int:
+        if self._max_tokens_per_minute is not None:
+            return self._max_tokens_per_minute
+        return CFG.LLM_MAX_TOKENS_PER_MINUTE
+
+    @property
+    def max_tokens_per_request(self) -> int:
+        if self._max_tokens_per_request is not None:
+            return self._max_tokens_per_request
+        return CFG.LLM_MAX_TOKENS_PER_REQUEST
+
+    @property
+    def throttle_sleep(self) -> float:
+        if self._throttle_sleep is not None:
+            return self._throttle_sleep
+        return CFG.LLM_THROTTLE_SLEEP
+
+    @property
+    def token_counter_fn(self) -> Callable[[str], int]:
+        if self._token_counter_fn is not None:
+            return self._token_counter_fn
+        return lambda x: len(x.split())
+
+    def set_max_requests_per_minute(self, value: int):
+        self._max_requests_per_minute = value
+
+    def set_max_tokens_per_minute(self, value: int):
+        self._max_tokens_per_minute = value
+
+    def set_max_tokens_per_request(self, value: int):
+        self._max_tokens_per_request = value
+
+    def set_throttle_sleep(self, value: float):
+        self._throttle_sleep = value
+
+    def set_token_counter_fn(self, fn: Callable[[str], int]):
+        self._token_counter_fn = fn
+
+    async def throttle(self, prompt: str):
+        now = time.time()
+        tokens = self.token_counter_fn(prompt)
+        # Clean up old entries
+        while self.request_times and now - self.request_times[0] > 60:
+            self.request_times.popleft()
+        while self.token_times and now - self.token_times[0][0] > 60:
+            self.token_times.popleft()
+        # 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})."
+            )
+        # Wait if over per-minute request or token limit
+        while (
+            len(self.request_times) >= self.max_requests_per_minute
+            or sum(t for _, t in self.token_times) + tokens > 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:
+                self.request_times.popleft()
+            while self.token_times and now - self.token_times[0][0] > 60:
+                self.token_times.popleft()
+        # Record this request
+        self.request_times.append(now)
+        self.token_times.append((now, tokens))
+
+
+llm_rate_limitter = LLMRateLimiter()

zrb/session/session.py

@@ -186,17 +186,16 @@ class Session(AnySession):
 
     def defer_monitoring(self, task: AnyTask, coro: Coroutine):
         self._register_single_task(task)
-        self._monitoring_coros[task] = asyncio.create_task(coro)
+        self._monitoring_coros[task] = coro
 
     def defer_action(self, task: AnyTask, coro: Coroutine):
         self._register_single_task(task)
-        self._action_coros[task] = asyncio.create_task(coro)
+        self._action_coros[task] = coro
 
     def defer_coro(self, coro: Coroutine):
-        task = asyncio.create_task(coro)
-        self._coros.append(task)
+        self._coros.append(coro)
         self._coros = [
-            existing_task for existing_task in self._coros if not existing_task.done()
+            existing_coro for existing_coro in self._coros if not existing_coro.done()
         ]
 
     async def wait_deferred(self):

zrb/task/llm/agent.py

@@ -18,6 +18,7 @@ else:
 
 from zrb.context.any_context import AnyContext
 from zrb.context.any_shared_context import AnySharedContext
+from zrb.llm_rate_limitter import LLMRateLimiter, llm_rate_limitter
 from zrb.task.llm.error import extract_api_error_details
 from zrb.task.llm.print_node import print_node
 from zrb.task.llm.tool_wrapper import wrap_tool
@@ -28,42 +29,32 @@ ToolOrCallable = Tool | Callable
 
 def create_agent_instance(
     ctx: AnyContext,
-    model: str | Model | None,
-    system_prompt: str,
-    model_settings: ModelSettings | None,
-    tools_attr: (
-        list[ToolOrCallable] | Callable[[AnySharedContext], list[ToolOrCallable]]
-    ),
-    additional_tools: list[ToolOrCallable],
-    mcp_servers_attr: list[MCPServer] | Callable[[AnySharedContext], list[MCPServer]],
-    additional_mcp_servers: list[MCPServer],
+    model: str | Model | None = None,
+    system_prompt: str = "",
+    model_settings: ModelSettings | None = None,
+    tools: list[ToolOrCallable] = [],
+    mcp_servers: list[MCPServer] = [],
+    retries: int = 3,
 ) -> Agent:
     """Creates a new Agent instance with configured tools and servers."""
-    # Get tools
     from pydantic_ai import Agent, Tool
 
-    tools_or_callables = list(tools_attr(ctx) if callable(tools_attr) else tools_attr)
-    tools_or_callables.extend(additional_tools)
-    tools = []
-    for tool_or_callable in tools_or_callables:
+    # Normalize tools
+    tool_list = []
+    for tool_or_callable in tools:
         if isinstance(tool_or_callable, Tool):
-            tools.append(tool_or_callable)
+            tool_list.append(tool_or_callable)
         else:
             # Pass ctx to wrap_tool
-            tools.append(wrap_tool(tool_or_callable, ctx))
-    # Get MCP Servers
-    mcp_servers = list(
-        mcp_servers_attr(ctx) if callable(mcp_servers_attr) else mcp_servers_attr
-    )
-    mcp_servers.extend(additional_mcp_servers)
+            tool_list.append(wrap_tool(tool_or_callable, ctx))
     # Return Agent
     return Agent(
         model=model,
         system_prompt=system_prompt,
-        tools=tools,
+        tools=tool_list,
         mcp_servers=mcp_servers,
         model_settings=model_settings,
-        retries=3,  # Consider making retries configurable?
+        retries=retries,
     )
 
 
@@ -79,10 +70,12 @@ def get_agent(
     additional_tools: list[ToolOrCallable],
     mcp_servers_attr: list[MCPServer] | Callable[[AnySharedContext], list[MCPServer]],
     additional_mcp_servers: list[MCPServer],
+    retries: int = 3,
 ) -> Agent:
     """Retrieves the configured Agent instance or creates one if necessary."""
     from pydantic_ai import Agent
 
+    # Render agent instance and return if agent_attr is already an agent
     if isinstance(agent_attr, Agent):
         return agent_attr
     if callable(agent_attr):
@@ -94,16 +87,23 @@ def get_agent(
             )
             raise TypeError(err_msg)
         return agent_instance
+    # Get tools for agent
+    tools = list(tools_attr(ctx) if callable(tools_attr) else tools_attr)
+    tools.extend(additional_tools)
+    # Get MCP Servers for agent
+    mcp_servers = list(
+        mcp_servers_attr(ctx) if callable(mcp_servers_attr) else mcp_servers_attr
+    )
+    mcp_servers.extend(additional_mcp_servers)
     # If no agent provided, create one using the configuration
     return create_agent_instance(
         ctx=ctx,
         model=model,
         system_prompt=system_prompt,
+        tools=tools,
+        mcp_servers=mcp_servers,
         model_settings=model_settings,
-        tools_attr=tools_attr,
-        additional_tools=additional_tools,
-        mcp_servers_attr=mcp_servers_attr,
-        additional_mcp_servers=additional_mcp_servers,
+        retries=retries,
     )
 
 
@@ -112,6 +112,7 @@ async def run_agent_iteration(
     agent: Agent,
     user_prompt: str,
     history_list: ListOfDict,
+    rate_limitter: LLMRateLimiter | None = None,
 ) -> AgentRun:
     """
     Runs a single iteration of the agent execution loop.
@@ -131,6 +132,11 @@ async def run_agent_iteration(
     from openai import APIError
     from pydantic_ai.messages import ModelMessagesTypeAdapter
 
+    if rate_limitter:
+        await rate_limitter.throttle(user_prompt)
+    else:
+        await llm_rate_limitter.throttle(user_prompt)
+
     async with agent.run_mcp_servers():
         async with agent.iter(
             user_prompt=user_prompt,

zrb/task/llm/config.py

@@ -18,7 +18,7 @@ def get_model_settings(
     ctx: AnyContext,
     model_settings_attr: (
         ModelSettings | Callable[[AnySharedContext], ModelSettings] | None
-    ),
+    ) = None,
 ) -> ModelSettings | None:
     """Gets the model settings, resolving callables if necessary."""
     model_settings = get_attr(ctx, model_settings_attr, None, auto_render=False)
@@ -29,8 +29,8 @@ def get_model_settings(
 
 def get_model_base_url(
     ctx: AnyContext,
-    model_base_url_attr: StrAttr | None,
-    render_model_base_url: bool,
+    model_base_url_attr: StrAttr | None = None,
+    render_model_base_url: bool = True,
 ) -> str | None:
     """Gets the model base URL, rendering if configured."""
     base_url = get_attr(
@@ -45,8 +45,8 @@ def get_model_base_url(
 
 def get_model_api_key(
     ctx: AnyContext,
-    model_api_key_attr: StrAttr | None,
-    render_model_api_key: bool,
+    model_api_key_attr: StrAttr | None = None,
+    render_model_api_key: bool = True,
 ) -> str | None:
     """Gets the model API key, rendering if configured."""
     api_key = get_attr(ctx, model_api_key_attr, None, auto_render=render_model_api_key)
@@ -61,10 +61,10 @@ def get_model(
     ctx: AnyContext,
     model_attr: Callable[[AnySharedContext], Model | str | fstring] | Model | None,
     render_model: bool,
-    model_base_url_attr: StrAttr | None,
-    render_model_base_url: bool,
-    model_api_key_attr: StrAttr | None,
-    render_model_api_key: bool,
+    model_base_url_attr: StrAttr | None = None,
+    render_model_base_url: bool = True,
+    model_api_key_attr: StrAttr | None = None,
+    render_model_api_key: bool = True,
 ) -> str | Model | None:
     """Gets the model instance or name, handling defaults and configuration."""
     from pydantic_ai.models import Model

zrb/task/llm/context_enrichment.py

@@ -7,6 +7,7 @@ from pydantic import BaseModel
 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.task.llm.agent import run_agent_iteration
 from zrb.task.llm.history import (
     count_part_in_history_list,
@@ -29,7 +30,7 @@ class EnrichmentConfig(BaseModel):
     model: Model | str | None = None
     settings: ModelSettings | None = None
     prompt: str
-    retries: int = 1
+    retries: int = 3
 
 
 class EnrichmentResult(BaseModel):
@@ -41,6 +42,7 @@ async def enrich_context(
     config: EnrichmentConfig,
     conversation_context: dict[str, Any],
     history_list: ListOfDict,
+    rate_limitter: LLMRateLimiter | None = None,
 ) -> dict[str, Any]:
     """Runs an LLM call to extract key info and merge it into the context."""
     from pydantic_ai import Agent
@@ -74,10 +76,7 @@ async def enrich_context(
 
     enrichment_agent = Agent(
         model=config.model,
-        # System prompt is part of the user prompt for this specific call
         system_prompt=config.prompt,  # Use the main prompt as system prompt
-        tools=[],
-        mcp_servers=[],
         model_settings=config.settings,
         retries=config.retries,
         output_type=EnrichmentResult,
@@ -90,6 +89,7 @@ async def enrich_context(
             agent=enrichment_agent,
             user_prompt=user_prompt_data,  # Pass the formatted data as user prompt
             history_list=[],  # Enrichment agent doesn't need prior history itself
+            rate_limitter=rate_limitter,
         )
         if enrichment_run and enrichment_run.result.output:
             response = enrichment_run.result.output.response
@@ -173,6 +173,7 @@ async def maybe_enrich_context(
     model: str | Model | None,
     model_settings: ModelSettings | None,
     context_enrichment_prompt: str,
+    rate_limitter: LLMRateLimiter | None = None,
 ) -> dict[str, Any]:
     """Enriches context based on history if enabled and threshold met."""
     shorten_history_list = replace_system_prompt_in_history_list(history_list)
@@ -193,5 +194,6 @@ async def maybe_enrich_context(
             ),
             conversation_context=conversation_context,
             history_list=shorten_history_list,
+            rate_limitter=rate_limitter,
         )
     return conversation_context

zrb/task/llm/history_summarization.py

@@ -6,6 +6,7 @@ from pydantic import BaseModel
 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.task.llm.agent import run_agent_iteration
 from zrb.task.llm.history import (
     count_part_in_history_list,
@@ -78,7 +79,7 @@ class SummarizationConfig(BaseModel):
     model: Model | str | None = None
     settings: ModelSettings | None = None
     prompt: str
-    retries: int = 1
+    retries: int = 3
 
 
 async def summarize_history(
@@ -86,6 +87,7 @@ async def summarize_history(
     config: SummarizationConfig,
     conversation_context: dict[str, Any],
     history_list: ListOfDict,
+    rate_limitter: LLMRateLimiter | None = None,
 ) -> dict[str, Any]:
     """Runs an LLM call to summarize history and update the context."""
     from pydantic_ai import Agent
@@ -95,8 +97,6 @@ async def summarize_history(
     summarization_agent = Agent(
         model=config.model,
         system_prompt=config.prompt,
-        tools=[],  # No tools needed for summarization
-        mcp_servers=[],
         model_settings=config.settings,
         retries=config.retries,
     )
@@ -122,6 +122,7 @@ async def summarize_history(
             agent=summarization_agent,
             user_prompt=summarization_user_prompt,
             history_list=[],  # Summarization agent doesn't need prior history
+            rate_limitter=rate_limitter,
         )
         if summary_run and summary_run.result.output:
             summary_text = str(summary_run.result.output)
@@ -150,6 +151,7 @@ async def maybe_summarize_history(
     model: str | Model | None,
     model_settings: ModelSettings | None,
     summarization_prompt: str,
+    rate_limitter: LLMRateLimiter | None = None,
 ) -> tuple[ListOfDict, dict[str, Any]]:
     """Summarizes history and updates context if enabled and threshold met."""
     shorten_history_list = replace_system_prompt_in_history_list(history_list)
@@ -171,6 +173,7 @@ async def maybe_summarize_history(
             ),
             conversation_context=conversation_context,
             history_list=shorten_history_list,  # Pass the full list for context
+            rate_limitter=rate_limitter,
         )
         # Truncate the history list after summarization
         return [], updated_context

zrb/task/llm_task.py

@@ -19,6 +19,7 @@ from zrb.context.any_context import AnyContext
 from zrb.context.any_shared_context import AnySharedContext
 from zrb.env.any_env import AnyEnv
 from zrb.input.any_input import AnyInput
+from zrb.llm_rate_limitter import LLMRateLimiter
 from zrb.task.any_task import AnyTask
 from zrb.task.base_task import BaseTask
 from zrb.task.llm.agent import get_agent, run_agent_iteration
@@ -113,6 +114,7 @@ class LLMTask(BaseTask):
         render_summarize_history: bool = True,
         history_summarization_threshold: IntAttr | None = None,
         render_history_summarization_threshold: bool = True,
+        rate_limitter: LLMRateLimiter | None = None,
         execute_condition: bool | str | Callable[[AnySharedContext], bool] = True,
         retries: int = 2,
         retry_period: float = 0,
@@ -175,6 +177,7 @@ class LLMTask(BaseTask):
         self._context_enrichment_threshold = context_enrichment_threshold
         self._render_context_enrichment_threshold = render_context_enrichment_threshold
         self._tools = tools
+        self._rate_limitter = rate_limitter
         self._additional_tools: list["ToolOrCallable"] = []
         self._mcp_servers = mcp_servers
         self._additional_mcp_servers: list["MCPServer"] = []
@@ -276,6 +279,7 @@ class LLMTask(BaseTask):
             model=model,
             model_settings=model_settings,
             context_enrichment_prompt=context_enrichment_prompt,
+            rate_limitter=self._rate_limitter,
         )
         # 3. Summarize history (optional, modifies history_list and context)
         history_list, conversation_context = await maybe_summarize_history(
@@ -291,6 +295,7 @@ class LLMTask(BaseTask):
             model=model,
             model_settings=model_settings,
             summarization_prompt=summarization_prompt,
+            rate_limitter=self._rate_limitter,
         )
         # 4. Build the final user prompt and system prompt
         final_user_prompt, default_context = extract_default_context(user_message)
@@ -333,6 +338,7 @@ class LLMTask(BaseTask):
                 agent=agent,
                 user_prompt=user_prompt,
                 history_list=history_list,
+                rate_limitter=self._rate_limitter,
             )
             if agent_run and agent_run.result:
                 new_history_list = json.loads(agent_run.result.all_messages_json())

zrb/util/run.py

@@ -13,6 +13,8 @@ async def run_async(value: Any) -> Any:
     Returns:
         Any: The result of the awaited value or the value itself if not awaitable.
     """
+    if isinstance(value, asyncio.Task):
+        return value
     if inspect.isawaitable(value):
         return await value
     return await asyncio.to_thread(lambda: value)

{zrb-1.8.3.dist-info → zrb-1.8.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: zrb
-Version: 1.8.3
+Version: 1.8.5
 Summary: Your Automation Powerhouse
 Home-page: https://github.com/state-alchemists/zrb
 License: AGPL-3.0-or-later
@@ -30,7 +30,7 @@ Requires-Dist: pydantic-ai (>=0.2.7,<0.3.0)
 Requires-Dist: pyjwt (>=2.10.1,<3.0.0)
 Requires-Dist: python-dotenv (>=1.1.0,<2.0.0)
 Requires-Dist: python-jose[cryptography] (>=3.4.0,<4.0.0)
-Requires-Dist: requests (>=2.32.3,<3.0.0)
+Requires-Dist: requests (>=2.32.4,<3.0.0)
 Requires-Dist: ulid-py (>=1.1.0,<2.0.0)
 Project-URL: Documentation, https://github.com/state-alchemists/zrb
 Project-URL: Repository, https://github.com/state-alchemists/zrb

{zrb-1.8.3.dist-info → zrb-1.8.5.dist-info}/RECORD

@@ -1,4 +1,4 @@
-zrb/__init__.py,sha256=e0fZglzFsjO-jz0HhHaBV5Vm0e3MZJBtXcrgDOPESB0,3103
+zrb/__init__.py,sha256=6q6sd4KnIwerCPOjv0ouyoXYlmnCfzT87KApckucp9M,3180
 zrb/__main__.py,sha256=aeIpBjlLef8bfdp0CYumnn5jVkHDPS5bwAxfuCJVUNI,2650
 zrb/attr/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 zrb/attr/type.py,sha256=4TV5gPYMMrKh5V-yB6iRYKCbsXAH_AvGXMsjxKLHcUs,568
@@ -9,7 +9,7 @@ zrb/builtin/git_subtree.py,sha256=7BKwOkVTWDrR0DXXQ4iJyHqeR6sV5VYRt8y_rEB0EHg,35
 zrb/builtin/group.py,sha256=t008xLM4_fgbjfZrPoi_fQAnSHIo6MOiQSCHBO4GDYU,2379
 zrb/builtin/http.py,sha256=sLqEczuSxGYXWzyJR6frGOHkPTviu4BeyroUr3-ZuAI,4322
 zrb/builtin/jwt.py,sha256=3M5uaQhJZbKQLjTUft1OwPz_JxtmK-xtkjxWjciOQho,2859
-zrb/builtin/llm/chat_session.py,sha256=HqFwrE1DiSlJrR-S3LRYWQBHkVsD-sfAV8_IIbnmtqY,6631
+zrb/builtin/llm/chat_session.py,sha256=ot2ss6yA4qIINg0nl3KJYnLag8H0eB9ggAgRGEUkZdE,6639
 zrb/builtin/llm/history.py,sha256=cnkOyO43uiMQ9cEvmqk-pPoCk1zCAH_fwAqSgBtsjzY,3079
 zrb/builtin/llm/input.py,sha256=Nw-26uTWp2QhUgKJcP_IMHmtk-b542CCSQ_vCOjhvhM,877
 zrb/builtin/llm/llm_ask.py,sha256=TIHpZFofbehJO1LXbsi4O84kHF85Xfqjev6UkI1RiL0,4367
@@ -17,9 +17,10 @@ zrb/builtin/llm/previous-session.js,sha256=xMKZvJoAbrwiyHS0OoPrWuaKxWYLoyR5sgueP
 zrb/builtin/llm/tool/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 zrb/builtin/llm/tool/api.py,sha256=yR9I0ZsI96OeQl9pgwORMASVuXsAL0a89D_iPS4C8Dc,1699
 zrb/builtin/llm/tool/cli.py,sha256=_CNEmEc6K2Z0i9ppYeM7jGpqaEdT3uxaWQatmxP3jKE,858
-zrb/builtin/llm/tool/file.py,sha256=nCY74VtruTr9LgAq5mroSr4zF0g6LA_uXMI5sh9c8OE,17909
+zrb/builtin/llm/tool/code.py,sha256=X2wEHJlYUcJXhQUrpZ-WXr2BZFS6gXvbv18dEoeHzf4,7408
+zrb/builtin/llm/tool/file.py,sha256=-lw-_ts5UyrbfWL-LKGIelljfvU7D7MTL-C0jfNMxpY,17938
 zrb/builtin/llm/tool/rag.py,sha256=yqx7vXXyrOCJjhQJl4s0TnLL-2uQUTuKRnkWlSQBW0M,7883
-zrb/builtin/llm/tool/sub_agent.py,sha256=7n14KzUSFe5Bjf2lpluKlLyL-b1Mehj2QekkuDzo0ik,5091
+zrb/builtin/llm/tool/sub_agent.py,sha256=_ItDE5MV_RZtnY_-IUsSMmm6mYaDY3YRINT0hVNsGkA,4702
 zrb/builtin/llm/tool/web.py,sha256=pXRLhcB_Y6z-2w4C4WezH8n-pg3PSMgt_bwn3aaqi6g,5479
 zrb/builtin/md5.py,sha256=690RV2LbW7wQeTFxY-lmmqTSVEEZv3XZbjEUW1Q3XpE,1480
 zrb/builtin/project/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -212,11 +213,11 @@ zrb/builtin/todo.py,sha256=pDbDKp94VHy-JsOr1sFtY8K4nIpNr1v6siqs5ptypsg,11568
 zrb/builtin/uuid.py,sha256=lIdhSGzPQ1rixRzMXxQDcgFgV7W-gUduHIudZXlzZzg,5393
 zrb/callback/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 zrb/callback/any_callback.py,sha256=PqEJYX_RigXEmoPniSeZusZBZSLWEoVIHvHk8MZ0Mvg,253
-zrb/callback/callback.py,sha256=mk_RIHuWi-oP5b81jfhzU6fruhsIjhRtKpwh2yYmsiM,3876
+zrb/callback/callback.py,sha256=PFhCqzfxdk6IAthmXcZ13DokT62xtBzJr_ciLw6I8Zg,4030
 zrb/cmd/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 zrb/cmd/cmd_result.py,sha256=L8bQJzWCpcYexIxHBNsXj2pT3BtLmWex0iJSMkvimOA,597
 zrb/cmd/cmd_val.py,sha256=7Doowyg6BK3ISSGBLt-PmlhzaEkBjWWm51cED6fAUOQ,1014
-zrb/config.py,sha256=lpJJv5ns-bNntEpScSLptPHv9gQYvEl4M8LP6rE7zfk,9423
+zrb/config.py,sha256=FsDU_SyX3NL9xX3sMvaGflKjRyNm8k-x5OYSfR6dcFw,10211
 zrb/content_transformer/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 zrb/content_transformer/any_content_transformer.py,sha256=v8ZUbcix1GGeDQwB6OKX_1TjpY__ksxWVeqibwa_iZA,850
 zrb/content_transformer/content_transformer.py,sha256=STl77wW-I69QaGzCXjvkppngYFLufow8ybPLSyAvlHs,2404
@@ -246,6 +247,7 @@ zrb/input/password_input.py,sha256=szBojWxSP9QJecgsgA87OIYwQrY2AQ3USIKdDZY6snU,1
 zrb/input/str_input.py,sha256=NevZHX9rf1g8eMatPyy-kUX3DglrVAQpzvVpKAzf7bA,81
 zrb/input/text_input.py,sha256=6T3MngWdUs0u0ZVs5Dl11w5KS7nN1RkgrIR_zKumzPM,3695
 zrb/llm_config.py,sha256=w_GSyQiJ_Q2jupej8xvQULScqPaSYICdNcH9J54W1lE,11696
+zrb/llm_rate_limitter.py,sha256=RXdtPreMcmoYSE2Ab2StyHH95F0bD2pGmyySXs4gRio,3725
 zrb/runner/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 zrb/runner/cli.py,sha256=AbLTNqFy5FuyGQOWOjHZGaBC8e2yuE_Dx1sBdnisR18,6984
 zrb/runner/common_util.py,sha256=JDMcwvQ8cxnv9kQrAoKVLA40Q1omfv-u5_d5MvvwHeE,1373
@@ -315,7 +317,7 @@ zrb/runner/web_util/token.py,sha256=6Yqp6mQJJMAOsSkAN-6dvtdiQbAv5xtll9jOmNYzbUY,
 zrb/runner/web_util/user.py,sha256=vE61pDjHoaHw9K0YAv1Gu2zWX2WkM2aWG-8776_aAiM,2061
 zrb/session/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 zrb/session/any_session.py,sha256=x57mS15E-AfUjdVxwOWEzCBjW32zjer7WoeBw0guoDc,5266
-zrb/session/session.py,sha256=wkWwueMotpbXaMew1JKil4QMR3UbcBbx4IAZWKSFYjY,10272
+zrb/session/session.py,sha256=1COMZ1JDCpkiAHxSFcaFE71GmatZ4cCHmHbpUPvt8k0,10189
 zrb/session_state_log/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 zrb/session_state_log/session_state_log.py,sha256=VVghDMU72PbrvnzQ7MJuc-KTJ5P5fX0FYuCh3Rlwd9M,709
 zrb/session_state_logger/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -335,18 +337,18 @@ zrb/task/base_trigger.py,sha256=WSGcmBcGAZw8EzUXfmCjqJQkz8GEmi1RzogpF6A1V4s,6902
 zrb/task/cmd_task.py,sha256=irGi0txTcsvGhxjfem4_radR4csNXhgtfcxruSF1LFI,10853
 zrb/task/http_check.py,sha256=Gf5rOB2Se2EdizuN9rp65HpGmfZkGc-clIAlHmPVehs,2565
 zrb/task/llm/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-zrb/task/llm/agent.py,sha256=6wGSsw03GdY_fj12CsJh7wxB6BnE13N8RYXaWfbiUsk,5451
-zrb/task/llm/config.py,sha256=oGxHYMdIvhASnKwNuMPwcdeJiFfS0tNskzGHakpfpQU,3458
+zrb/task/llm/agent.py,sha256=pLldTsXzdaPs07WIw6DbpLpe-y6xIPU5MAPQ0fRA8Bk,5526
+zrb/task/llm/config.py,sha256=Gb0lSHCgGXOAr7igkU7k_Ew5Yp_wOTpNQyZrLrtA7oc,3521
 zrb/task/llm/context.py,sha256=U9a8lxa2ikz6my0Sd5vpO763legHrMHyvBjbrqNmv0Y,3838
-zrb/task/llm/context_enrichment.py,sha256=jB7lekwo4hTk8HIwhhq7HSMfgAzwaV2U867icBRt6Z0,7088
+zrb/task/llm/context_enrichment.py,sha256=BlW2CjSUsKJT8EZBXYxOE4MEBbRCoO34PlQQdzA-zBM,7201
 zrb/task/llm/error.py,sha256=27DQXSG8SH1-XuvXFdZQKzP39wZDWmd_YnSTz6DJKKI,3690
 zrb/task/llm/history.py,sha256=3WMXoi7RquxosXQf3iv2_BCeF8iKtY1f407pR71xERs,7745
-zrb/task/llm/history_summarization.py,sha256=n3GbgwXlDIkgpJppMGfpqF_8Wpi9yAoZYh46O1pFQeU,6432
+zrb/task/llm/history_summarization.py,sha256=d6RF1duVe7aog2gUf7kzQLIqTwNTfVsOtvx5629hiTU,6582
 zrb/task/llm/print_node.py,sha256=bpISOUxSH_JBLR-4Nq6-iLrzNWFagrKFX6u8ogYYMw8,4395
 zrb/task/llm/prompt.py,sha256=zBo3xT3YPX_A4_t8Cd-QjNqQZl9dsoWMTt-NdytI2f4,3827
 zrb/task/llm/tool_wrapper.py,sha256=Xygd4VCY3ykjVv63pqlTI16ZG41ySkp683_5VTnL-Zo,6481
 zrb/task/llm/typing.py,sha256=c8VAuPBw_4A3DxfYdydkgedaP-LU61W9_wj3m3CAX1E,58
-zrb/task/llm_task.py,sha256=Yav1pmV26Eh4h9xTh16dN-DbTvhfYINI0EDp_ptJHLg,15643
+zrb/task/llm_task.py,sha256=R-VBzESfuzo4RxbtvXd3XBhHoWe8PEDiuNmKe_93wEo,15934
 zrb/task/make_task.py,sha256=PD3b_aYazthS8LHeJsLAhwKDEgdurQZpymJDKeN60u0,2265
 zrb/task/rsync_task.py,sha256=GSL9144bmp6F0EckT6m-2a1xG25AzrrWYzH4k3SVUKM,6370
 zrb/task/scaffolder.py,sha256=rME18w1HJUHXgi9eTYXx_T2G4JdqDYzBoNOkdOOo5-o,6806
@@ -380,7 +382,7 @@ zrb/util/git_subtree.py,sha256=E_UB5OIgm8WkHL9beifRxpZ25_BB9p1H578OhLZTgRU,4611
 zrb/util/group.py,sha256=T82yr3qg9I5k10VPXkMyrIRIqyfzadSH813bqzwKEPI,4718
 zrb/util/init_path.py,sha256=n4BgLGeq3mPLS1la8VEqZpqJHx0vJRe2WRwTtbw-FjE,652
 zrb/util/load.py,sha256=DK0KYSlu48HCoGPqnW1IxnE3pHrZSPCstfz8Fjyqqv8,2140
-zrb/util/run.py,sha256=FPRCCvl5g6GuDvHTkaV95CFDlqxQ-5FZb2-F-Jz1fnI,485
+zrb/util/run.py,sha256=vu-mcSWDP_WuuvIKqM_--Gk3WkABO1oTXiHmBRTvVQk,546
 zrb/util/string/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 zrb/util/string/conversion.py,sha256=sMmstzbrNgLvWAQukqoXz45JtsNpJrniudAtzJaQlYw,6240
 zrb/util/string/format.py,sha256=MwWGAwSdtOgR_2uz-JCXlg_q-uRYUUI-G8CGkfdgqik,1198
@@ -388,7 +390,7 @@ zrb/util/string/name.py,sha256=SXEfxJ1-tDOzHqmSV8kvepRVyMqs2XdV_vyoh_9XUu0,1584
 zrb/util/todo.py,sha256=VGISej2KQZERpornK-8X7bysp4JydMrMUTnG8B0-liI,20708
 zrb/xcom/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 zrb/xcom/xcom.py,sha256=o79rxR9wphnShrcIushA0Qt71d_p3ZTxjNf7x9hJB78,1571
-zrb-1.8.3.dist-info/METADATA,sha256=VMBmGEImGJOvME1Jr6IrdYEWexUsmYcmgh8kmhE-kT4,9760
-zrb-1.8.3.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-zrb-1.8.3.dist-info/entry_points.txt,sha256=-Pg3ElWPfnaSM-XvXqCxEAa-wfVI6BEgcs386s8C8v8,46
-zrb-1.8.3.dist-info/RECORD,,
+zrb-1.8.5.dist-info/METADATA,sha256=R27kDs_HVlzKm-rSSnkk4XVbPI_dIehXERaiZgGGL_M,9760
+zrb-1.8.5.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+zrb-1.8.5.dist-info/entry_points.txt,sha256=-Pg3ElWPfnaSM-XvXqCxEAa-wfVI6BEgcs386s8C8v8,46
+zrb-1.8.5.dist-info/RECORD,,