zrb 1.15.5__py3-none-any.whl → 1.15.6__py3-none-any.whl

zrb/builtin/llm/tool/sub_agent.py

@@ -118,9 +118,8 @@ def create_sub_agent_tool(
         if sub_agent_run and sub_agent_run.result:
             # Return the final message content as a string
             return json.dumps({"result": sub_agent_run.result.output})
-        else:
-            ctx.log_warning("Sub-agent run did not produce a result.")
-            return "Sub-agent failed to produce a result."
+        ctx.log_warning("Sub-agent run did not produce a result.")
+        raise ValueError(f"{tool_name} not returning any result")
 
     # Set the name and docstring for the callable function
     run_sub_agent.__name__ = tool_name

zrb/config/config.py

@@ -102,6 +102,7 @@ class Config:
         level = level.upper()
         log_levels = {
             "CRITICAL": logging.CRITICAL,  # 50
+            "FATAL": logging.CRITICAL,  # 50
             "ERROR": logging.ERROR,  # 40
             "WARN": logging.WARNING,  # 30
             "WARNING": logging.WARNING,  # 30
@@ -282,7 +283,7 @@ class Config:
         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", "15"))
+        return int(self._getenv("LLM_MAX_REQUESTS_PER_MINUTE", "60"))
 
     @property
     def LLM_MAX_TOKENS_PER_MINUTE(self) -> int:
@@ -295,7 +296,7 @@ class Config:
     @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", "50000"))
+        return int(self._getenv("LLM_MAX_TOKENS_PER_REQUEST", "100000"))
 
     @property
     def LLM_THROTTLE_SLEEP(self) -> float:
@@ -435,5 +436,13 @@ class Config:
     def LLM_CONTEXT_FILE(self) -> str:
         return self._getenv("LLM_CONTEXT_FILE", "ZRB.md")
 
+    @property
+    def USE_TIKTOKEN(self) -> bool:
+        return to_boolean(self._getenv("USE_TIKTOKEN", "true"))
+
+    @property
+    def TIKTOKEN_ENCODING_NAME(self) -> str:
+        return self._getenv("TIKTOKEN_ENCODING_NAME", "cl100k_base")
+
 
 CFG = Config()

zrb/config/llm_rate_limitter.py

@@ -3,27 +3,9 @@ import time
 from collections import deque
 from typing import Callable
 
-import tiktoken
-
 from zrb.config.config import CFG
 
 
-def _estimate_token(text: str) -> int:
-    """
-    Estimates the number of tokens in a given text.
-    Tries to use the 'gpt-4o' model's tokenizer for an accurate count.
-    If the tokenizer is unavailable (e.g., due to network issues),
-    it falls back to a heuristic of 4 characters per token.
-    """
-    try:
-        # Primary method: Use tiktoken for an accurate count
-        enc = tiktoken.encoding_for_model("gpt-4o")
-        return len(enc.encode(text))
-    except Exception:
-        # Fallback method: Heuristic (4 characters per token)
-        return len(text) // 4
-
-
 class LLMRateLimiter:
     """
     Helper class to enforce LLM API rate limits and throttling.
@@ -36,13 +18,15 @@ class LLMRateLimiter:
         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,
+        use_tiktoken: bool | None = None,
+        tiktoken_encodeing_name: str | 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._use_tiktoken = use_tiktoken
+        self._tiktoken_encoding_name = tiktoken_encodeing_name
         self.request_times = deque()
         self.token_times = deque()
 
@@ -71,10 +55,16 @@ class LLMRateLimiter:
         return CFG.LLM_THROTTLE_SLEEP
 
     @property
-    def count_token(self) -> Callable[[str], int]:
-        if self._token_counter_fn is not None:
-            return self._token_counter_fn
-        return _estimate_token
+    def use_tiktoken(self) -> bool:
+        if self._use_tiktoken is not None:
+            return self._use_tiktoken
+        return CFG.USE_TIKTOKEN
+
+    @property
+    def tiktoken_encoding_name(self) -> str:
+        if self._tiktoken_encoding_name is not None:
+            return self._tiktoken_encoding_name
+        return CFG.TIKTOKEN_ENCODING_NAME
 
     def set_max_requests_per_minute(self, value: int):
         self._max_requests_per_minute = value
@@ -88,24 +78,43 @@ class LLMRateLimiter:
     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
+    def count_token(self, prompt: str) -> int:
+        if not self.use_tiktoken:
+            return self._fallback_count_token(prompt)
+        try:
+            import tiktoken
+
+            enc = tiktoken.get_encoding(self.tiktoken_encoding_name)
+            return len(enc.encode(prompt))
+        except Exception:
+            return self._fallback_count_token(prompt)
+
+    def _fallback_count_token(self, prompt: str) -> int:
+        return len(prompt) // 4
 
     def clip_prompt(self, prompt: str, limit: int) -> str:
-        token_count = self.count_token(prompt)
-        if token_count <= limit:
-            return prompt
-        while token_count > limit:
-            prompt_parts = prompt.split(" ")
-            last_part_index = len(prompt_parts) - 2
-            clipped_prompt = " ".join(prompt_parts[:last_part_index])
-            clipped_prompt += "(Content clipped...)"
-            token_count = self.count_token(clipped_prompt)
-            if token_count < limit:
-                return clipped_prompt
-        return prompt[:limit]
-
-    async def throttle(self, prompt: str):
+        if not self.use_tiktoken:
+            return self._fallback_clip_prompt(prompt, limit)
+        try:
+            import tiktoken
+
+            enc = tiktoken.get_encoding("cl100k_base")
+            tokens = enc.encode(prompt)
+            if len(tokens) <= limit:
+                return prompt
+            truncated = tokens[: limit - 3]
+            clipped_text = enc.decode(truncated)
+            return clipped_text + "..."
+        except Exception:
+            return self._fallback_clip_prompt(prompt, limit)
+
+    def _fallback_clip_prompt(self, prompt: str, limit: int) -> str:
+        char_limit = limit * 4 if limit * 4 <= 10 else limit * 4 - 10
+        return prompt[:char_limit] + "..."
+
+    async def throttle(
+        self, prompt: str, throttle_notif_callback: Callable | None = None
+    ):
         now = time.time()
         tokens = self.count_token(prompt)
         # Clean up old entries
@@ -123,6 +132,8 @@ class LLMRateLimiter:
             len(self.request_times) >= self.max_requests_per_minute
             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()
             await asyncio.sleep(self.throttle_sleep)
             now = time.time()
             while self.request_times and now - self.request_times[0] > 60:

zrb/context/context.py

@@ -63,7 +63,7 @@ class Context(AnyContext):
 
     @property
     def session(self) -> AnySession | None:
-        return self._shared_ctx._session
+        return self._shared_ctx.session
 
     def update_task_env(self, task_env: dict[str, str]):
         self._env.update(task_env)

zrb/context/shared_context.py

@@ -40,11 +40,7 @@ class SharedContext(AnySharedContext):
 
     def __repr__(self):
         class_name = self.__class__.__name__
-        input = self._input
-        args = self._args
-        env = self._env
-        xcom = self._xcom
-        return f"<{class_name} input={input} args={args} xcom={xcom} env={env}>"
+        return f"<{class_name}>"
 
     @property
     def is_web_mode(self) -> bool:

zrb/input/any_input.py

@@ -1,4 +1,5 @@
 from abc import ABC, abstractmethod
+from typing import Any
 
 from zrb.context.any_shared_context import AnySharedContext
 
@@ -35,7 +36,10 @@ class AnyInput(ABC):
 
     @abstractmethod
     def update_shared_context(
-        self, shared_ctx: AnySharedContext, str_value: str | None = None
+        self,
+        shared_ctx: AnySharedContext,
+        str_value: str | None = None,
+        value: Any = None,
     ):
         pass
 

zrb/input/base_input.py

@@ -58,11 +58,15 @@ class BaseInput(AnyInput):
         return f'<input name="{name}" placeholder="{description}" value="{default}" />'
 
     def update_shared_context(
-        self, shared_ctx: AnySharedContext, str_value: str | None = None
+        self,
+        shared_ctx: AnySharedContext,
+        str_value: str | None = None,
+        value: Any = None,
     ):
-        if str_value is None:
-            str_value = self.get_default_str(shared_ctx)
-        value = self._parse_str_value(str_value)
+        if value is None:
+            if str_value is None:
+                str_value = self.get_default_str(shared_ctx)
+            value = self._parse_str_value(str_value)
         if self.name in shared_ctx.input:
             raise ValueError(f"Input already defined in the context: {self.name}")
         shared_ctx.input[self.name] = value

zrb/runner/cli.py

@@ -7,7 +7,7 @@ from zrb.context.any_context import AnyContext
 from zrb.context.shared_context import SharedContext
 from zrb.group.any_group import AnyGroup
 from zrb.group.group import Group
-from zrb.runner.common_util import get_run_kwargs
+from zrb.runner.common_util import get_task_str_kwargs
 from zrb.session.session import Session
 from zrb.session_state_logger.session_state_logger_factory import session_state_logger
 from zrb.task.any_task import AnyTask
@@ -38,23 +38,25 @@ class Cli(Group):
     def banner(self) -> str:
         return CFG.BANNER
 
-    def run(self, args: list[str] = []):
-        kwargs, args = self._extract_kwargs_from_args(args)
-        node, node_path, args = extract_node_from_args(self, args)
+    def run(self, str_args: list[str] = []):
+        str_kwargs, str_args = self._extract_kwargs_from_args(str_args)
+        node, node_path, str_args = extract_node_from_args(self, str_args)
         if isinstance(node, AnyGroup):
             self._show_group_info(node)
             return
-        if "h" in kwargs or "help" in kwargs:
+        if "h" in str_kwargs or "help" in str_kwargs:
             self._show_task_info(node)
             return
-        run_kwargs = get_run_kwargs(task=node, args=args, kwargs=kwargs, cli_mode=True)
+        task_str_kwargs = get_task_str_kwargs(
+            task=node, str_args=str_args, str_kwargs=str_kwargs, cli_mode=True
+        )
         try:
-            result = self._run_task(node, args, run_kwargs)
+            result = self._run_task(node, str_args, task_str_kwargs)
             if result is not None:
                 print(result)
             return result
         finally:
-            run_command = self._get_run_command(node_path, run_kwargs)
+            run_command = self._get_run_command(node_path, task_str_kwargs)
             self._print_run_command(run_command)
 
     def _print_run_command(self, run_command: str):
@@ -64,11 +66,14 @@ class Cli(Group):
             file=sys.stderr,
         )
 
-    def _get_run_command(self, node_path: list[str], run_kwargs: dict[str, str]) -> str:
+    def _get_run_command(
+        self, node_path: list[str], task_str_kwargs: dict[str, str]
+    ) -> str:
         parts = [self.name] + node_path
-        if len(run_kwargs) > 0:
+        if len(task_str_kwargs) > 0:
             parts += [
-                self._get_run_command_param(key, val) for key, val in run_kwargs.items()
+                self._get_run_command_param(key, val)
+                for key, val in task_str_kwargs.items()
             ]
         return " ".join(parts)
 
@@ -81,13 +86,9 @@ class Cli(Group):
         self, task: AnyTask, args: list[str], run_kwargs: dict[str, str]
     ) -> tuple[Any]:
         shared_ctx = SharedContext(args=args)
-        for task_input in task.inputs:
-            if task_input.name in run_kwargs:
-                task_input.update_shared_context(
-                    shared_ctx, run_kwargs[task_input.name]
-                )
-                continue
-        return task.run(Session(shared_ctx=shared_ctx, root_group=self))
+        return task.run(
+            Session(shared_ctx=shared_ctx, root_group=self), str_kwargs=run_kwargs
+        )
 
     def _show_task_info(self, task: AnyTask):
         description = task.description

zrb/runner/common_util.py

@@ -1,31 +1,36 @@
-from typing import Any
-
 from zrb.context.shared_context import SharedContext
 from zrb.task.any_task import AnyTask
 
 
-def get_run_kwargs(
-    task: AnyTask, args: list[str], kwargs: dict[str, str], cli_mode: bool
+def get_task_str_kwargs(
+    task: AnyTask, str_args: list[str], str_kwargs: dict[str, str], cli_mode: bool
 ) -> dict[str, str]:
     arg_index = 0
-    str_kwargs = {key: f"{val}" for key, val in kwargs.items()}
-    run_kwargs = {**str_kwargs}
-    shared_ctx = SharedContext(args=args)
+    dummmy_shared_ctx = SharedContext()
+    task_str_kwargs = {}
     for task_input in task.inputs:
+        task_name = task_input.name
         if task_input.name in str_kwargs:
-            # Update shared context for next input default value
-            task_input.update_shared_context(shared_ctx, str_kwargs[task_input.name])
-        elif arg_index < len(args) and task_input.allow_positional_parsing:
-            run_kwargs[task_input.name] = args[arg_index]
-            # Update shared context for next input default value
-            task_input.update_shared_context(shared_ctx, run_kwargs[task_input.name])
+            task_str_kwargs[task_input.name] = str_kwargs[task_name]
+            # Update dummy shared context for next input default value
+            task_input.update_shared_context(
+                dummmy_shared_ctx, str_value=str_kwargs[task_name]
+            )
+        elif arg_index < len(str_args) and task_input.allow_positional_parsing:
+            task_str_kwargs[task_name] = str_args[arg_index]
+            # Update dummy shared context for next input default value
+            task_input.update_shared_context(
+                dummmy_shared_ctx, str_value=task_str_kwargs[task_name]
+            )
             arg_index += 1
         else:
             if cli_mode and task_input.always_prompt:
-                str_value = task_input.prompt_cli_str(shared_ctx)
+                str_value = task_input.prompt_cli_str(dummmy_shared_ctx)
             else:
-                str_value = task_input.get_default_str(shared_ctx)
-            run_kwargs[task_input.name] = str_value
-            # Update shared context for next input default value
-            task_input.update_shared_context(shared_ctx, run_kwargs[task_input.name])
-    return run_kwargs
+                str_value = task_input.get_default_str(dummmy_shared_ctx)
+            task_str_kwargs[task_name] = str_value
+            # Update dummy shared context for next input default value
+            task_input.update_shared_context(
+                dummmy_shared_ctx, str_value=task_str_kwargs[task_name]
+            )
+    return task_str_kwargs

zrb/runner/web_route/task_input_api_route.py

@@ -3,7 +3,7 @@ from typing import TYPE_CHECKING
 
 from zrb.config.web_auth_config import WebAuthConfig
 from zrb.group.any_group import AnyGroup
-from zrb.runner.common_util import get_run_kwargs
+from zrb.runner.common_util import get_task_str_kwargs
 from zrb.runner.web_util.user import get_user_from_request
 from zrb.task.any_task import AnyTask
 from zrb.util.group import NodeNotFoundError, extract_node_from_args
@@ -39,9 +39,9 @@ def serve_task_input_api(
         if isinstance(task, AnyTask):
             if not user.can_access_task(task):
                 return JSONResponse(content={"detail": "Forbidden"}, status_code=403)
-            query_dict = json.loads(query)
-            run_kwargs = get_run_kwargs(
-                task=task, args=[], kwargs=query_dict, cli_mode=False
+            str_kwargs = json.loads(query)
+            task_str_kwargs = get_task_str_kwargs(
+                task=task, str_args=[], str_kwargs=str_kwargs, cli_mode=False
             )
-            return run_kwargs
+            return task_str_kwargs
         return JSONResponse(content={"detail": "Not found"}, status_code=404)

zrb/task/any_task.py

@@ -148,13 +148,17 @@ class AnyTask(ABC):
 
     @abstractmethod
     def run(
-        self, session: "AnySession | None" = None, str_kwargs: dict[str, str] = {}
+        self,
+        session: "AnySession | None" = None,
+        str_kwargs: dict[str, str] | None = None,
+        kwargs: dict[str, Any] | None = None,
     ) -> Any:
         """Runs the task synchronously.
 
         Args:
             session (AnySession): The shared session.
             str_kwargs(dict[str, str]): The input string values.
+            kwargs(dict[str, Any]): The input values.
 
         Returns:
             Any: The result of the task execution.
@@ -163,13 +167,17 @@ class AnyTask(ABC):
 
     @abstractmethod
     async def async_run(
-        self, session: "AnySession | None" = None, str_kwargs: dict[str, str] = {}
+        self,
+        session: "AnySession | None" = None,
+        str_kwargs: dict[str, str] | None = None,
+        kwargs: dict[str, Any] | None = None,
     ) -> Any:
         """Runs the task asynchronously.
 
         Args:
             session (AnySession): The shared session.
             str_kwargs(dict[str, str]): The input string values.
+            kwargs(dict[str, Any]): The input values.
 
         Returns:
             Any: The result of the task execution.

zrb/task/base/context.py

@@ -26,25 +26,33 @@ def build_task_context(task: AnyTask, session: AnySession) -> AnyContext:
 
 
 def fill_shared_context_inputs(
-    task: AnyTask, shared_context: AnySharedContext, str_kwargs: dict[str, str] = {}
+    shared_ctx: AnySharedContext,
+    task: AnyTask,
+    str_kwargs: dict[str, str] | None = None,
+    kwargs: dict[str, str] | None = None,
 ):
     """
-    Populates the shared context with input values provided via kwargs.
+    Populates the shared context with input values provided via str_kwargs.
     """
+    str_kwarg_dict = str_kwargs if str_kwargs is not None else {}
+    kwarg_dict = kwargs if kwargs is not None else {}
     for task_input in task.inputs:
-        if task_input.name not in shared_context.input:
-            str_value = str_kwargs.get(task_input.name, None)
-            task_input.update_shared_context(shared_context, str_value)
+        if task_input.name not in shared_ctx.input:
+            task_input.update_shared_context(
+                shared_ctx,
+                value=kwarg_dict.get(task_input.name, None),
+                str_value=str_kwarg_dict.get(task_input.name, None),
+            )
 
 
-def fill_shared_context_envs(shared_context: AnySharedContext):
+def fill_shared_context_envs(shared_ctx: AnySharedContext):
     """
     Injects OS environment variables into the shared context if they don't already exist.
     """
     os_env_map = {
-        key: val for key, val in os.environ.items() if key not in shared_context.env
+        key: val for key, val in os.environ.items() if key not in shared_ctx.env
     }
-    shared_context.env.update(os_env_map)
+    shared_ctx.env.update(os_env_map)
 
 
 def combine_inputs(

zrb/task/base/lifecycle.py

@@ -12,7 +12,8 @@ from zrb.util.run import run_async
 async def run_and_cleanup(
     task: AnyTask,
     session: AnySession | None = None,
-    str_kwargs: dict[str, str] = {},
+    str_kwargs: dict[str, str] | None = None,
+    kwargs: dict[str, Any] | None = None,
 ) -> Any:
     """
     Wrapper for async_run that ensures session termination and cleanup of
@@ -23,7 +24,9 @@ async def run_and_cleanup(
         session = Session(shared_ctx=SharedContext())
 
     # Create the main task execution coroutine
-    main_task_coro = asyncio.create_task(run_task_async(task, session, str_kwargs))
+    main_task_coro = asyncio.create_task(
+        run_task_async(task, session, str_kwargs, kwargs)
+    )
 
     try:
         result = await main_task_coro
@@ -67,7 +70,8 @@ async def run_and_cleanup(
 async def run_task_async(
     task: AnyTask,
     session: AnySession | None = None,
-    str_kwargs: dict[str, str] = {},
+    str_kwargs: dict[str, str] | None = None,
+    kwargs: dict[str, Any] | None = None,
 ) -> Any:
     """
     Asynchronous entry point for running a task (`task.async_run()`).
@@ -77,7 +81,7 @@ async def run_task_async(
         session = Session(shared_ctx=SharedContext())
 
     # Populate shared context with inputs and environment variables
-    fill_shared_context_inputs(task, session.shared_ctx, str_kwargs)
+    fill_shared_context_inputs(session.shared_ctx, task, str_kwargs, kwargs)
     fill_shared_context_envs(session.shared_ctx)  # Inject OS env vars
 
     # Start the execution chain from the root tasks

zrb/task/base_task.py

@@ -216,7 +216,10 @@ class BaseTask(AnyTask):
         return build_task_context(self, session)
 
     def run(
-        self, session: AnySession | None = None, str_kwargs: dict[str, str] = {}
+        self,
+        session: AnySession | None = None,
+        str_kwargs: dict[str, str] | None = None,
+        kwargs: dict[str, str] | None = None,
     ) -> Any:
         """
         Synchronously runs the task and its dependencies, handling async setup and cleanup.
@@ -235,12 +238,19 @@ class BaseTask(AnyTask):
             Any: The final result of the main task execution.
         """
         # Use asyncio.run() to execute the async cleanup wrapper
-        return asyncio.run(run_and_cleanup(self, session, str_kwargs))
+        return asyncio.run(
+            run_and_cleanup(self, session=session, str_kwargs=str_kwargs, kwargs=kwargs)
+        )
 
     async def async_run(
-        self, session: AnySession | None = None, str_kwargs: dict[str, str] = {}
+        self,
+        session: AnySession | None = None,
+        str_kwargs: dict[str, str] | None = None,
+        kwargs: dict[str, Any] | None = None,
     ) -> Any:
-        return await run_task_async(self, session, str_kwargs)
+        return await run_task_async(
+            self, session=session, str_kwargs=str_kwargs, kwargs=kwargs
+        )
 
     async def exec_root_tasks(self, session: AnySession):
         return await execute_root_tasks(self, session)
@@ -280,3 +290,43 @@ class BaseTask(AnyTask):
                 # fallback: use the __notes__ attribute directly
                 e.__notes__ = getattr(e, "__notes__", []) + [additional_error_note]
             raise e
+
+    def to_fn(self):
+        # NOTE: Non documented feature, untested
+        from inspect import Parameter, Signature
+
+        from zrb.context.shared_context import SharedContext
+        from zrb.session.session import Session
+
+        def task_runner_fn(**kwargs):
+            str_kwargs = {k: str(v) for k, v in kwargs.items()}
+            shared_ctx = SharedContext()
+            session = Session(shared_ctx=shared_ctx)
+            return self.run(session=session, str_kwargs=str_kwargs)
+
+        # Create docstring
+        doc = f"{self.description}\n\n"
+        if len(self.inputs) > 0:
+            doc += "Args:\n"
+            for inp in self.inputs:
+                doc += f"    {inp.name}: {inp.description}"
+                if inp.default is not None:
+                    doc += f" (default: {inp.default})"
+                doc += "\n"
+        task_runner_fn.__doc__ = doc
+
+        # Create signature
+        params = []
+        for inp in self.inputs:
+            params.append(
+                Parameter(
+                    name=inp.name,
+                    kind=Parameter.POSITIONAL_OR_KEYWORD,
+                    default=inp.default if inp.default is not None else Parameter.empty,
+                )
+            )
+        sig = Signature(params)
+        task_runner_fn.__signature__ = sig
+        task_runner_fn.__name__ = self.name
+
+        return task_runner_fn

zrb/task/llm/agent.py

@@ -9,6 +9,7 @@ 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_func, wrap_tool
 from zrb.task.llm.typing import ListOfDict
+from zrb.util.cli.style import stylize_faint
 
 if TYPE_CHECKING:
     from pydantic_ai import Agent, Tool
@@ -184,10 +185,11 @@ async def _run_single_agent_iteration(
     agent_payload = _estimate_request_payload(
         agent, user_prompt, attachments, history_list
     )
+    callback = lambda: _print_throttle_notif(ctx)
     if rate_limitter:
-        await rate_limitter.throttle(agent_payload)
+        await rate_limitter.throttle(agent_payload, callback)
     else:
-        await llm_rate_limitter.throttle(agent_payload)
+        await llm_rate_limitter.throttle(agent_payload, callback)
 
     user_prompt_with_attachments = [user_prompt] + attachments
     async with agent:
@@ -214,6 +216,10 @@ async def _run_single_agent_iteration(
             return agent_run
 
 
+def _print_throttle_notif(ctx: AnyContext):
+    ctx.print(stylize_faint("  ⌛>> Request Throttled"), plain=True)
+
+
 def _estimate_request_payload(
     agent: "Agent",
     user_prompt: str,

zrb/task/llm/history_summarization.py

@@ -16,6 +16,7 @@ from zrb.task.llm.typing import ListOfDict
 from zrb.util.attr import get_bool_attr, get_int_attr
 from zrb.util.cli.style import stylize_faint
 from zrb.util.llm.prompt import make_prompt_section
+from zrb.util.truncate import truncate_str
 
 if TYPE_CHECKING:
     from pydantic_ai.models import Model
@@ -115,7 +116,7 @@ async def summarize_history(
             ),
             make_prompt_section(
                 "Recent Conversation (JSON)",
-                json.dumps(conversation_history.history),
+                json.dumps(truncate_str(conversation_history.history, 1000)),
                 as_code=True,
             ),
             make_prompt_section(

zrb/task/llm/tool_wrapper.py

@@ -128,14 +128,13 @@ def _create_wrapper(
 async def _ask_for_approval(
     ctx: AnyContext, func: Callable, args: list[Any], kwargs: dict[str, Any]
 ) -> tuple[bool, str]:
-    func_name = get_callable_name(func)
     func_call_str = _get_func_call_str(func, args, kwargs)
-    func_detail_param = _get_detail_func_param(args, kwargs)
-    confirmation_message = render_markdown(
-        f"Allow to run `{func_name}`? (`Yes` | `No, <reason>`)"
-    )
-    complete_confirmation_message = (
-        f"\n✅ >> {func_call_str}" f"\n{func_detail_param}" f"\n{confirmation_message}"
+    complete_confirmation_message = "\n".join(
+        [
+            f"\n🎰 >> {func_call_str}",
+            _get_detail_func_param(args, kwargs),
+            f"✅ >> {_get_run_func_confirmation(func)}",
+        ]
     )
     while True:
         ctx.print(complete_confirmation_message, plain=True)
@@ -166,6 +165,13 @@ async def _ask_for_approval(
             continue
 
 
+def _get_run_func_confirmation(func: Callable) -> str:
+    func_name = get_callable_name(func)
+    return render_markdown(
+        f"Allow to run `{func_name}`? (`Yes` | `No, <reason>`)"
+    ).strip()
+
+
 def _get_detail_func_param(args: list[Any], kwargs: dict[str, Any]) -> str:
     markdown = "\n".join(
         [_get_func_param_item(key, val) for key, val in kwargs.items()]

zrb/task/llm_task.py

@@ -323,6 +323,7 @@ class LLMTask(BaseTask):
                 history_list=conversation_history.history,
                 rate_limitter=self._rate_limitter,
             )
+
             if agent_run and agent_run.result:
                 new_history_list = json.loads(agent_run.result.all_messages_json())
                 conversation_history.history = new_history_list

zrb/util/truncate.py

@@ -0,0 +1,23 @@
+from collections.abc import Mapping, Sequence
+from typing import Any
+
+
+def truncate_str(value: Any, limit: int):
+    # If value is a string, truncate
+    if isinstance(value, str):
+        if len(value) > limit:
+            if limit < 4:
+                return value[:limit]
+            return value[: limit - 4] + " ..."
+    # If value is a dict, process recursively
+    elif isinstance(value, Mapping):
+        return {k: truncate_str(v, limit) for k, v in value.items()}
+    # If value is a list or tuple, process recursively preserving type
+    elif isinstance(value, Sequence) and not isinstance(value, (str, bytes, bytearray)):
+        t = type(value)
+        return t(truncate_str(v, limit) for v in value)
+    # If value is a set, process recursively preserving type
+    elif isinstance(value, set):
+        return {truncate_str(v, limit) for v in value}
+    # Other types are returned unchanged
+    return value

{zrb-1.15.5.dist-info → zrb-1.15.6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: zrb
-Version: 1.15.5
+Version: 1.15.6
 Summary: Your Automation Powerhouse
 License: AGPL-3.0-or-later
 Keywords: Automation,Task Runner,Code Generator,Monorepo,Low Code
@@ -27,6 +27,7 @@ Requires-Dist: pdfplumber (>=0.11.7,<0.12.0)
 Requires-Dist: playwright (>=1.54.0,<2.0.0) ; extra == "playwright" or extra == "all"
 Requires-Dist: psutil (>=7.0.0,<8.0.0)
 Requires-Dist: pydantic-ai-slim[anthropic,bedrock,cli,cohere,google,groq,huggingface,mcp,mistral,openai,vertexai] (>=0.7.4,<0.8.0)
+Requires-Dist: pyjwt (>=2.10.1,<3.0.0)
 Requires-Dist: python-dotenv (>=1.1.1,<2.0.0)
 Requires-Dist: python-jose[cryptography] (>=3.5.0,<4.0.0)
 Requires-Dist: requests (>=2.32.4,<3.0.0)

{zrb-1.15.5.dist-info → zrb-1.15.6.dist-info}/RECORD

@@ -20,7 +20,7 @@ zrb/builtin/llm/tool/cli.py,sha256=8rugrKaNPEatHjr7nN4OIRLRT2TcF-oylEZGbLI9Brs,1
 zrb/builtin/llm/tool/code.py,sha256=BACeH0tGhTdDo0rZ7sTAP6oRaLi9cS7gdEigXiTd0Jg,8842
 zrb/builtin/llm/tool/file.py,sha256=eXFGGFxxpdpWGVw0svyQNQc03I5M7wotSsA_HjkXw7c,23670
 zrb/builtin/llm/tool/rag.py,sha256=Ab8_ZljnG_zfkwxPezImvorshuz3Fi4CmSzNOtU1a-g,9770
-zrb/builtin/llm/tool/sub_agent.py,sha256=hsR-5iozcgE0f-3J7VLP189JqsW6lE2h-x_1YW6pVAo,5086
+zrb/builtin/llm/tool/sub_agent.py,sha256=dPqdFCXxJ-3hZnPjheZr-bPeKNbfSBSDKcZZR5vkWFM,5075
 zrb/builtin/llm/tool/web.py,sha256=zNQWDNOz_MyyzhncBeV5E_9XijQxTFVp6BSzz_e5tBI,7261
 zrb/builtin/md5.py,sha256=690RV2LbW7wQeTFxY-lmmqTSVEEZv3XZbjEUW1Q3XpE,1480
 zrb/builtin/project/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -217,7 +217,7 @@ 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/config.py,sha256=YhmXeD5FKlMXv924_iWA-k9eUBbuOKXphoW6V56NQa4,13871
+zrb/config/config.py,sha256=AtJ61i_ZTi95vRV5h4EKtMWhPdU2YVEdv08mU1DePEk,14161
 zrb/config/default_prompt/file_extractor_system_prompt.md,sha256=tmeZMPzF9MGExsZZw7M2PZN6V0oFVRp1nIjiqUPvQ9M,1013
 zrb/config/default_prompt/interactive_system_prompt.md,sha256=sRFrwqnqudnXATkTwHnnQAhLKC0ep6lad8vKXaRAPzc,3505
 zrb/config/default_prompt/persona.md,sha256=WU4JKp-p7qJePDA6NZ_CYdBggo2B3PEq8IEnNVblIHU,41
@@ -228,7 +228,7 @@ zrb/config/default_prompt/system_prompt.md,sha256=Jkne5n9HJcBCgfeENwxvqH-kbDO2Ca
 zrb/config/llm_config.py,sha256=xt-Xf8ZuNoUT_GKCSFz5yy0BhbeHzxP-jrezB06WeiY,8857
 zrb/config/llm_context/config.py,sha256=PDsrKAduQfsEUMYt4jirG0F7KDkY7jqhrbsptxdMOEg,4962
 zrb/config/llm_context/config_parser.py,sha256=h95FbOjvVobhrsfGtG_BY3hxS-OLzQj-9F5vGZuehkY,1473
-zrb/config/llm_rate_limitter.py,sha256=P4vR7qxwiGwjlKx2kHcfdIxwGbJB98vdN-UQEH-Q2WU,4894
+zrb/config/llm_rate_limitter.py,sha256=_iQRv3d6kUPeRvmUYZX_iwCE7iDSEK1oKa4bQ9GROho,5261
 zrb/config/web_auth_config.py,sha256=_PXatQTYh2mX9H3HSYSQKp13zm1RlLyVIoeIr6KYMQ8,6279
 zrb/content_transformer/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 zrb/content_transformer/any_content_transformer.py,sha256=v8ZUbcix1GGeDQwB6OKX_1TjpY__ksxWVeqibwa_iZA,850
@@ -236,8 +236,8 @@ zrb/content_transformer/content_transformer.py,sha256=STl77wW-I69QaGzCXjvkppngYF
 zrb/context/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 zrb/context/any_context.py,sha256=2hgVKbbDwmwrEl1h1L1FaTUjuUYaDd_b7YRGkaorW6Q,6362
 zrb/context/any_shared_context.py,sha256=wJawL1jGgApcKPRcpw3js7W4-MhJRA3GMbR5zTsJmt0,1929
-zrb/context/context.py,sha256=ErGhXJgjgNaAqi6iPMejWxFZ3YvWnysC6mHEU-wodKk,6884
-zrb/context/shared_context.py,sha256=c87VujBGKbkEC6R8Bby0-Gp0h2UvX8ZsH_3S0ElEKSs,3124
+zrb/context/context.py,sha256=pnFV7KjVMKWAkYidhZTVFpPZvvGbqGuj_TERpWOvCIw,6883
+zrb/context/shared_context.py,sha256=mBbTDPfde5ZBj4EKfMEC2636bSE7GZWx7MtaQnETqgg,2972
 zrb/dot_dict/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 zrb/dot_dict/dot_dict.py,sha256=ubw_x8I7AOJ59xxtFVJ00VGmq_IYdZP3mUhNlO4nEK0,556
 zrb/env/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -249,8 +249,8 @@ zrb/group/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 zrb/group/any_group.py,sha256=sdUk82YRuJBMwDhD_b-vJ3v-Yxz8K7LFW52TM19k3HI,1242
 zrb/group/group.py,sha256=t5JnXlrLfthFfqmkVdRLKCIyms4JqsthcTODVncSmPk,4312
 zrb/input/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-zrb/input/any_input.py,sha256=mmkU7WsqIK-IK8B5rNkWdy6mKS47zasnXJWE60MTRWQ,984
-zrb/input/base_input.py,sha256=2gwIcT9xLXjcrwF-4k6ghDs819E-DWIwijlzfQtauWs,3766
+zrb/input/any_input.py,sha256=3EQgg2Qk_2t2Ege_4pHV2G95tV3XAIThLLuFZ6uV6oM,1051
+zrb/input/base_input.py,sha256=Rb2m9xLJgGDph2D8L9HnLFPtQZqmPAPKrSP2K4pK97A,3848
 zrb/input/bool_input.py,sha256=9ir8aTm8zaufrJ84_EerC5vOjyn4hHZ3BiLzFqPgPFM,1839
 zrb/input/float_input.py,sha256=8G9lJKLlb_Upk9m5pBF9JwqlAAiYJLrbIItLnyzPxpg,1475
 zrb/input/int_input.py,sha256=UhxCFYlZdJcgUSGGEkz301zOgRVpK0KDG_IxxWpQfMU,1457
@@ -259,8 +259,8 @@ zrb/input/password_input.py,sha256=szBojWxSP9QJecgsgA87OIYwQrY2AQ3USIKdDZY6snU,1
 zrb/input/str_input.py,sha256=NevZHX9rf1g8eMatPyy-kUX3DglrVAQpzvVpKAzf7bA,81
 zrb/input/text_input.py,sha256=UCkC497V6L12cPjupOgIZ5XW2eBbBDydQi5IIYtknek,3702
 zrb/runner/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-zrb/runner/cli.py,sha256=EjnTtEEkTDdTURh20Jie3SMoAG5NJQneCR3esgbPmuE,6996
-zrb/runner/common_util.py,sha256=JDMcwvQ8cxnv9kQrAoKVLA40Q1omfv-u5_d5MvvwHeE,1373
+zrb/runner/cli.py,sha256=CNZoti_cNcHEkD6TO4gQie2_t6KTinjdc7oEc-wszQg,6947
+zrb/runner/common_util.py,sha256=yIJm9ivM7hvJ4Kb4Nt5RRE7oqAlt9EN89w6JDGyLkFE,1570
 zrb/runner/web_app.py,sha256=n8iXtQ5DGIfRcFsHdBafm9VJisVSDD159XFPpEXQTN0,2796
 zrb/runner/web_route/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 zrb/runner/web_route/docs_route.py,sha256=Y8zTROzIOfmJuU_E9KZljdjgkd65DcvLeX3k0xO-o_k,550
@@ -315,7 +315,7 @@ zrb/runner/web_route/static/resources/session/current-session.js,sha256=tzUdK7qJ
 zrb/runner/web_route/static/resources/session/event.js,sha256=X5OlSHefK0SDB9VkFCRyBKE_Pb7mqM319mW9jRGoDOk,4716
 zrb/runner/web_route/static/resources/session/past-session.js,sha256=RwGJYKSp75K8NZ-iZP58XppWgdzkiKFaiC5wgcMLxDo,5470
 zrb/runner/web_route/static/static_route.py,sha256=QPs5XW4O_8CuzG0Wy4sHh5wRcLbU63CLDI4YNqkUxHA,1555
-zrb/runner/web_route/task_input_api_route.py,sha256=6JIehRjXPhzclq9qGMYkztaKB0TzWsBBbim0m47-YmA,1767
+zrb/runner/web_route/task_input_api_route.py,sha256=1uTI9efQNXJ_S9jGWSudQFIyGSkINSLLYzSWCMcOtkc,1795
 zrb/runner/web_route/task_session_api_route.py,sha256=U9fPOh_nmAzsmRnS5xe713KFUU15n0IkbbzU_Eg8YGI,6181
 zrb/runner/web_schema/session.py,sha256=NwbuS2Sv-CXO52nU-EZv8OMlD4vgCQWNeLC_dT0FK7I,92
 zrb/runner/web_schema/token.py,sha256=Y7XCPS4WzrxslTDtHeLcPTTUpmWhPOkRcl4b99zrC7c,185
@@ -334,19 +334,19 @@ zrb/session_state_logger/any_session_state_logger.py,sha256=T_-aJv63HwoTeiDOmXKH
 zrb/session_state_logger/file_session_state_logger.py,sha256=NMyj_g2ImQc6ZRM9f35EpA-CM1UO-ZgoDnPkN1DSi9U,3915
 zrb/session_state_logger/session_state_logger_factory.py,sha256=_oT1UIqm25nMwKhsUvXehnCdDvNqxCyuN8GLdv2D_U4,188
 zrb/task/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-zrb/task/any_task.py,sha256=E4HA4Fumwv5dIsEnl2q0eE6t6LHnF6uyk0O5yQ2Mz6g,5826
+zrb/task/any_task.py,sha256=SAPX1uuq4c0mxgGEQ6lyioR4eRmFovhH-Wr2xCtrHnA,6078
 zrb/task/base/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-zrb/task/base/context.py,sha256=73k3fKwup0AJwTTLpay0f_-axJextaxgbTem4w4Bmas,3670
+zrb/task/base/context.py,sha256=uj0fHPtbjiRWE4gRB8DKNJhLmEN1ZWH6FCjItlE45q4,3918
 zrb/task/base/execution.py,sha256=scDLfNYBe8Bc8Ct1LCIKmFtjpPxm7FjqZ2bJXIQAzv8,11042
-zrb/task/base/lifecycle.py,sha256=4tGeN9yE5sQt1lHYq-1_vOFSGk1z8JneNCbVUWFVm-Q,7507
+zrb/task/base/lifecycle.py,sha256=c2v977pUm7S4EqrTMcUJKhnYOWugACVwU3qORDKiLXQ,7639
 zrb/task/base/monitoring.py,sha256=UAOEcPiYNtZR4FFxzWCosuOEFE_P3c4GT5vAhQmohqI,5663
 zrb/task/base/operators.py,sha256=uAMFqpZJsPnCrojgOl1FUDXTS15mtOa_IqiAXltyYRU,1576
-zrb/task/base_task.py,sha256=Y5JNzU6Y1E8RKGdj16HTlhny0v8N2I98GCA4D8h6Kmw,10962
+zrb/task/base_task.py,sha256=qPtEIP3TEX7YbDadQtsUXLJ4_7Khzk_JxXDh_mRrluU,12602
 zrb/task/base_trigger.py,sha256=WSGcmBcGAZw8EzUXfmCjqJQkz8GEmi1RzogpF6A1V4s,6902
 zrb/task/cmd_task.py,sha256=myM8WZm6NrUD-Wv0Vb5sTOrutrAVZLt5LVsSBKwX6SM,10860
 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=miQMF7NMFsPEuAp5gTh1kAAEGxgYfLb4uoDU7FL83Go,8645
+zrb/task/llm/agent.py,sha256=jfC90N8oER2z-fTmPEuWH3ASPgw5t8cZm8rk98HBBlw,8876
 zrb/task/llm/config.py,sha256=n1SPmwab09K2i1sL_OCwrEOWHI0Owx_hvWelg3Dreus,3781
 zrb/task/llm/conversation_history.py,sha256=B_PDWYL_q66s0xwWBzMSomqPN6u3gkXlIeXBD5A0Apg,4416
 zrb/task/llm/conversation_history_model.py,sha256=DJ0KDBB0BriQuE5ugC_q0aSHhjNIBcfjUk1f0S_3I9U,9245
@@ -354,12 +354,12 @@ zrb/task/llm/default_workflow/coding.md,sha256=2uythvPsnBpYfIhiIH1cCinQXX0i0yUqs
 zrb/task/llm/default_workflow/copywriting.md,sha256=xSO7GeDolwGxiuz6kXsK2GKGpwp8UgtG0yRqTmill_s,1999
 zrb/task/llm/default_workflow/researching.md,sha256=KD-aYHFHir6Ti-4FsBBtGwiI0seSVgleYbKJZi_POXA,2139
 zrb/task/llm/error.py,sha256=QR-nIohS6pBpC_16cWR-fw7Mevo1sNYAiXMBsh_CJDE,4157
-zrb/task/llm/history_summarization.py,sha256=uW8JxCPks0RjTmCsr8AzrVnqenw4vi_WyVprOqMgAOk,8109
+zrb/task/llm/history_summarization.py,sha256=_eWFP4cAn3tTfyt7YPjnPwm_PgMhMChPg9g2q2Gsf0c,8172
 zrb/task/llm/print_node.py,sha256=Sd8ovTO6KKI9hllZf5TxRXog7QGCne1A1E83jnrH_kg,6526
 zrb/task/llm/prompt.py,sha256=FGXWYHecWtrNNkPnjg-uhnkqp7fYt8V91-AjFM_5fpA,11550
-zrb/task/llm/tool_wrapper.py,sha256=76h5fcPL3hlXlwYk2aqLqyKPJO1rABUGkBEAGAnWyfQ,9531
+zrb/task/llm/tool_wrapper.py,sha256=2cbaSNvOMlIb3l5RXEFbH7cnox01TAr4b4Vtg0wzuYs,9609
 zrb/task/llm/typing.py,sha256=c8VAuPBw_4A3DxfYdydkgedaP-LU61W9_wj3m3CAX1E,58
-zrb/task/llm_task.py,sha256=aweruBmC09RCKNGmiwLo7WVSttCUH2h2RkSfgUGvRFo,14450
+zrb/task/llm_task.py,sha256=0c9F_AjeMLxQX8VlAJHfZAkC52PhRaWbcKoqVOggcMg,14451
 zrb/task/make_task.py,sha256=PD3b_aYazthS8LHeJsLAhwKDEgdurQZpymJDKeN60u0,2265
 zrb/task/rsync_task.py,sha256=WfqNSaicJgYWpunNU34eYxXDqHDHOftuDHyWJKjqwg0,6365
 zrb/task/scaffolder.py,sha256=rME18w1HJUHXgi9eTYXx_T2G4JdqDYzBoNOkdOOo5-o,6806
@@ -405,9 +405,10 @@ zrb/util/string/format.py,sha256=MwWGAwSdtOgR_2uz-JCXlg_q-uRYUUI-G8CGkfdgqik,119
 zrb/util/string/name.py,sha256=SXEfxJ1-tDOzHqmSV8kvepRVyMqs2XdV_vyoh_9XUu0,1584
 zrb/util/todo.py,sha256=r9_KYF2-hLKMNjsp6AFK9zivykMrywd-kJ4bCwfdafI,19323
 zrb/util/todo_model.py,sha256=hhzAX-uFl5rsg7iVX1ULlJOfBtblwQ_ieNUxBWfc-Os,1670
+zrb/util/truncate.py,sha256=eSzmjBpc1Qod3lM3M73snNbDOcARHukW_tq36dWdPvc,921
 zrb/xcom/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 zrb/xcom/xcom.py,sha256=o79rxR9wphnShrcIushA0Qt71d_p3ZTxjNf7x9hJB78,1571
-zrb-1.15.5.dist-info/METADATA,sha256=NkG_9a5y03ASTFHhYSwdi1ksrh0I1aA9fXI1y871PXI,9735
-zrb-1.15.5.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
-zrb-1.15.5.dist-info/entry_points.txt,sha256=-Pg3ElWPfnaSM-XvXqCxEAa-wfVI6BEgcs386s8C8v8,46
-zrb-1.15.5.dist-info/RECORD,,
+zrb-1.15.6.dist-info/METADATA,sha256=octlKaqi1aMWs5qYYb5d02at13BGvqvMdOEjYrKbp4E,9774
+zrb-1.15.6.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
+zrb-1.15.6.dist-info/entry_points.txt,sha256=-Pg3ElWPfnaSM-XvXqCxEAa-wfVI6BEgcs386s8C8v8,46
+zrb-1.15.6.dist-info/RECORD,,