zrb 1.15.3__tar.gz → 1.15.6__tar.gz

{zrb-1.15.3 → zrb-1.15.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: zrb
-Version: 1.15.3
+Version: 1.15.6
 Summary: Your Automation Powerhouse
 License: AGPL-3.0-or-later
 Keywords: Automation,Task Runner,Code Generator,Monorepo,Low Code
@@ -16,21 +16,20 @@ Classifier: Programming Language :: Python :: 3.13
 Provides-Extra: all
 Provides-Extra: playwright
 Provides-Extra: rag
-Requires-Dist: beautifulsoup4 (>=4.13.3,<5.0.0)
-Requires-Dist: black (>=25.1.0,<25.2.0)
+Requires-Dist: beautifulsoup4 (>=4.13.4,<5.0.0)
+Requires-Dist: black (>=25.1.0,<26.0.0)
 Requires-Dist: chromadb (>=0.6.3,<0.7.0) ; extra == "rag" or extra == "all"
 Requires-Dist: fastapi[standard] (>=0.116.1,<0.117.0)
-Requires-Dist: isort (>=6.0.1,<6.1.0)
-Requires-Dist: libcst (>=1.7.0,<2.0.0)
+Requires-Dist: isort (>=6.0.1,<7.0.0)
+Requires-Dist: libcst (>=1.8.2,<2.0.0)
 Requires-Dist: markdownify (>=1.2.0,<2.0.0)
-Requires-Dist: openai (>=1.99.7)
-Requires-Dist: pdfplumber (>=0.11.6,<0.12.0)
-Requires-Dist: playwright (>=1.53.0,<2.0.0) ; extra == "playwright" or extra == "all"
+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.0,<0.8.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.4.0,<4.0.0)
+Requires-Dist: python-jose[cryptography] (>=3.5.0,<4.0.0)
 Requires-Dist: requests (>=2.32.4,<3.0.0)
 Requires-Dist: tiktoken (>=0.8.0,<0.9.0)
 Requires-Dist: ulid-py (>=1.1.0,<2.0.0)

{zrb-1.15.3 → zrb-1.15.6}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "zrb"
-version = "1.15.3"
+version = "1.15.6"
 description = "Your Automation Powerhouse"
 authors = ["Go Frendi Gunawan <gofrendiasgard@gmail.com>"]
 license = "AGPL-3.0-or-later"
@@ -39,30 +39,27 @@ exclude = [
 [tool.poetry.dependencies]
 python = ">=3.10.0,<4.0.0"
 python-dotenv = "^1.1.1"
-black = "~25.1.0"
-isort = "~6.0.1"
+black = "^25.1.0"
+isort = "^6.0.1"
 requests = "^2.32.4"
-libcst = "^1.7.0"
-beautifulsoup4 = "^4.13.3"
-pdfplumber = "^0.11.6"
+libcst = "^1.8.2"
+beautifulsoup4 = "^4.13.4"
+pdfplumber = "^0.11.7"
 fastapi = {extras = ["standard"], version = "^0.116.1"}
-python-jose = {extras = ["cryptography"], version = "^3.4.0"}
+python-jose = {extras = ["cryptography"], version = "^3.5.0"}
 ulid-py = "^1.1.0"
 psutil = "^7.0.0"
-pyjwt = "^2.10.1"
 
 # NOTE: Look at https://github.com/pydantic/pydantic-ai/blob/main/pydantic_ai_slim/pyproject.toml
 # - We want to include all models, as well as mcp capability.
 # - We also need prompt-toolkit and rich which are included in pydantic ai's cli optional dependency
-pydantic-ai-slim = {extras = ["openai", "cohere", "vertexai", "google", "anthropic", "groq", "mistral", "bedrock", "huggingface", "cli", "mcp"], version = "^0.7.0"} 
-
-# NOTE: On Pydantic AI 0.7.0, OpenAI is 1.99.2 to 1.99.6 seems to be broken
-openai = ">=1.99.7"
+pydantic-ai-slim = {extras = ["openai", "cohere", "vertexai", "google", "anthropic", "groq", "mistral", "bedrock", "huggingface", "cli", "mcp"], version = "~0.7.4"} 
 
 tiktoken = "^0.8.0"
-playwright = {version = "^1.53.0", optional = true}
+playwright = {version = "^1.54.0", optional = true}
 chromadb = {version = "^0.6.3", optional = true}
 markdownify = "^1.2.0"
+pyjwt = "^2.10.1"
 
 [tool.poetry.extras]
 # poetry install -E rag
@@ -71,17 +68,18 @@ playwright = ["playwright"]
 all = ["chromadb", "playwright"]
 
 [tool.poetry.group.dev.dependencies]
-alembic = "^1.16.2" # FastApp dependencies
-autopep8 = "^2.0.4"
-flake8 = "~7.2.0"
-pytest = "~8.3.5"
-pytest-cov = "~6.1.0"
-pytest-asyncio = "~0.26.0"
+alembic = "^1.16.4" # FastApp dependencies
+autopep8 = "^2.3.2"
+flake8 = "^7.2.0"
+pytest = "^8.3.5"
+pytest-cov = "^6.1.0"
+pytest-asyncio = "^0.26.0"
 sqlmodel = "^0.0.24" # FastApp dependencies
-tomlkit = "^0.13.2"
+tomlkit = "^0.13.3"
 
 [tool.pytest.ini_options]
 asyncio_default_fixture_loop_scope = "function"
+norecursedirs = "playground src/zrb/builtin/project/add/fastapp/fastapp_template"
 
 [tool.poetry.scripts]
 zrb = "zrb.__main__:serve_cli"

{zrb-1.15.3 → zrb-1.15.6}/src/zrb/builtin/llm/chat_session.py

@@ -10,6 +10,7 @@ import sys
 
 from zrb.config.llm_config import llm_config
 from zrb.context.any_context import AnyContext
+from zrb.util.cli.markdown import render_markdown
 from zrb.util.cli.style import stylize_blue, stylize_bold_yellow, stylize_faint
 from zrb.util.string.conversion import to_boolean
 
@@ -200,27 +201,13 @@ async def _trigger_ask_and_wait_for_result(
         ctx, user_prompt, modes, yolo_mode, previous_session_name, start_new
     )
     result = await _wait_ask_result(ctx)
-    md_result = _render_markdown(result) if result is not None else ""
+    md_result = render_markdown(result) if result is not None else ""
     ctx.print("\n🤖 >>", plain=True)
     ctx.print(md_result, plain=True)
     ctx.print("", plain=True)
     return result
 
 
-def _render_markdown(markdown_text: str) -> str:
-    """
-    Renders Markdown to a string, ensuring link URLs are visible.
-    """
-    from rich.console import Console
-    from rich.markdown import Markdown
-
-    console = Console()
-    markdown = Markdown(markdown_text, hyperlinks=False)
-    with console.capture() as capture:
-        console.print(markdown)
-    return capture.get()
-
-
 def get_llm_ask_input_mapping(callback_ctx: AnyContext):
     """
     Generates the input mapping for the LLM ask task from the callback context.

{zrb-1.15.3 → zrb-1.15.6}/src/zrb/builtin/llm/tool/code.py

@@ -6,6 +6,7 @@ from zrb.builtin.llm.tool.sub_agent import create_sub_agent_tool
 from zrb.config.config import CFG
 from zrb.config.llm_rate_limitter import llm_rate_limitter
 from zrb.context.any_context import AnyContext
+from zrb.util.cli.style import stylize_faint
 
 _DEFAULT_EXTENSIONS = [
     "py",
@@ -112,7 +113,7 @@ async def analyze_repo(
         )
     abs_path = os.path.abspath(os.path.expanduser(path))
     file_metadatas = _get_file_metadatas(abs_path, extensions, exclude_patterns)
-    ctx.print("Extraction")
+    ctx.print(stylize_faint("  📝 Extraction"), plain=True)
     extracted_infos = await _extract_info(
         ctx,
         file_metadatas=file_metadatas,
@@ -121,10 +122,10 @@ async def analyze_repo(
     )
     if len(extracted_infos) == 1:
         return extracted_infos[0]
-    ctx.print("Summarization")
+    ctx.print(stylize_faint("  📝 Summarization"), plain=True)
     summarized_infos = extracted_infos
     while len(summarized_infos) > 1:
-        ctx.print("Summarization")
+        ctx.print(stylize_faint("  📝 Summarization"), plain=True)
         summarized_infos = await _summarize_info(
             ctx,
             extracted_infos=summarized_infos,

{zrb-1.15.3 → zrb-1.15.6}/src/zrb/builtin/llm/tool/sub_agent.py

@@ -26,6 +26,7 @@ def create_sub_agent_tool(
     tools: "list[ToolOrCallable]" = [],
     toolsets: list["AbstractToolset[Agent]"] = [],
     is_yolo_mode: bool | None = None,
+    log_indent_level: int = 2,
 ) -> Callable[[AnyContext, str], Coroutine[Any, Any, str]]:
     """
     Creates a "tool that is another AI agent," capable of handling complex,
@@ -110,15 +111,15 @@ def create_sub_agent_tool(
             user_prompt=query,
             attachments=[],
             history_list=[],
+            log_indent_level=log_indent_level,
         )
 
         # Return the sub-agent's final message content
         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-1.15.3 → zrb-1.15.6}/src/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-1.15.3 → zrb-1.15.6}/src/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-1.15.3 → zrb-1.15.6}/src/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-1.15.3 → zrb-1.15.6}/src/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-1.15.3 → zrb-1.15.6}/src/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-1.15.3 → zrb-1.15.6}/src/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-1.15.3 → zrb-1.15.6}/src/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-1.15.6/src/zrb/runner/common_util.py

@@ -0,0 +1,36 @@
+from zrb.context.shared_context import SharedContext
+from zrb.task.any_task import AnyTask
+
+
+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
+    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:
+            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(dummmy_shared_ctx)
+            else:
+                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-1.15.3 → zrb-1.15.6}/src/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-1.15.3 → zrb-1.15.6}/src/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.