zrb 1.15.2__tar.gz → 1.15.4__tar.gz

{zrb-1.15.2 → zrb-1.15.4}/PKG-INFO

@@ -1,7 +1,8 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.1
 Name: zrb
-Version: 1.15.2
+Version: 1.15.4
 Summary: Your Automation Powerhouse
+Home-page: https://github.com/state-alchemists/zrb
 License: AGPL-3.0-or-later
 Keywords: Automation,Task Runner,Code Generator,Monorepo,Low Code
 Author: Go Frendi Gunawan
@@ -12,7 +13,6 @@ Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
-Classifier: Programming Language :: Python :: 3.13
 Provides-Extra: all
 Provides-Extra: playwright
 Provides-Extra: rag
@@ -35,7 +35,6 @@ 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)
 Project-URL: Documentation, https://github.com/state-alchemists/zrb
-Project-URL: Homepage, https://github.com/state-alchemists/zrb
 Project-URL: Repository, https://github.com/state-alchemists/zrb
 Description-Content-Type: text/markdown
 

{zrb-1.15.2 → zrb-1.15.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "zrb"
-version = "1.15.2"
+version = "1.15.4"
 description = "Your Automation Powerhouse"
 authors = ["Go Frendi Gunawan <gofrendiasgard@gmail.com>"]
 license = "AGPL-3.0-or-later"

{zrb-1.15.2 → zrb-1.15.4}/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
 
@@ -34,7 +35,7 @@ async def read_user_prompt(ctx: AnyContext) -> str:
         # Get user input based on mode
         if not multiline_mode:
             ctx.print("💬 >>", plain=True)
-        user_input = await _read_next_line(is_tty, reader, ctx)
+        user_input = await _read_next_line(reader, ctx)
         if not multiline_mode:
             ctx.print("", plain=True)
         # Handle user input
@@ -111,6 +112,7 @@ def _show_info(ctx: AnyContext):
         ),
         plain=True,
     )
+    ctx.print("", plain=True)
 
 
 def _show_command(command: str, description: str) -> str:
@@ -157,9 +159,11 @@ async def _setup_input_reader(is_interactive: bool):
     return reader
 
 
-async def _read_next_line(is_interactive: bool, reader, ctx: AnyContext) -> str:
+async def _read_next_line(reader, ctx: AnyContext) -> str:
     """Reads one line of input using the provided reader."""
-    if is_interactive:
+    from prompt_toolkit import PromptSession
+
+    if isinstance(reader, PromptSession):
         return await reader.prompt_async()
 
     line_bytes = await reader.readline()
@@ -197,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.2 → zrb-1.15.4}/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.2 → zrb-1.15.4}/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,6 +111,7 @@ 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

{zrb-1.15.2 → zrb-1.15.4}/src/zrb/task/llm/agent.py

@@ -129,6 +129,7 @@ async def run_agent_iteration(
     history_list: ListOfDict | None = None,
     rate_limitter: LLMRateLimiter | None = None,
     max_retry: int = 2,
+    log_indent_level: int = 0,
 ) -> "AgentRun":
     """
     Runs a single iteration of the agent execution loop.
@@ -159,6 +160,7 @@ async def run_agent_iteration(
                 rate_limitter=(
                     llm_rate_limitter if rate_limitter is None else rate_limitter
                 ),
+                log_indent_level=log_indent_level,
             )
         except BaseException:
             attempt += 1
@@ -174,6 +176,7 @@ async def _run_single_agent_iteration(
     attachments: "list[UserContent]",
     history_list: ListOfDict,
     rate_limitter: LLMRateLimiter,
+    log_indent_level: int,
 ) -> "AgentRun":
     from openai import APIError
     from pydantic_ai.messages import ModelMessagesTypeAdapter
@@ -196,7 +199,9 @@ async def _run_single_agent_iteration(
                 # Each node represents a step in the agent's execution
                 # Reference: https://ai.pydantic.dev/agents/#streaming
                 try:
-                    await print_node(_get_plain_printer(ctx), agent_run, node)
+                    await print_node(
+                        _get_plain_printer(ctx), agent_run, node, log_indent_level
+                    )
                 except APIError as e:
                     # Extract detailed error information from the response
                     error_details = extract_api_error_details(e)

{zrb-1.15.2 → zrb-1.15.4}/src/zrb/task/llm/history_summarization.py

@@ -152,7 +152,7 @@ async def summarize_history(
         ],
     )
     try:
-        ctx.print(stylize_faint("📝 Summarize Conversation >>>"), plain=True)
+        ctx.print(stylize_faint("  📝 Rollup Conversation"), plain=True)
         summary_run = await run_agent_iteration(
             ctx=ctx,
             agent=summarization_agent,
@@ -160,10 +160,13 @@ async def summarize_history(
             attachments=[],
             history_list=[],
             rate_limitter=rate_limitter,
+            log_indent_level=2,
         )
         if summary_run and summary_run.result and summary_run.result.output:
             usage = summary_run.result.usage()
-            ctx.print(stylize_faint(f"📝 Summarization Token: {usage}"), plain=True)
+            ctx.print(
+                stylize_faint(f"  📝 Rollup Conversation Token: {usage}"), plain=True
+            )
             ctx.print(plain=True)
             ctx.log_info("History summarized and updated.")
         else:

zrb-1.15.4/src/zrb/task/llm/print_node.py

@@ -0,0 +1,175 @@
+import json
+from collections.abc import Callable
+from typing import Any
+
+from zrb.util.cli.style import stylize_faint
+
+
+async def print_node(
+    print_func: Callable, agent_run: Any, node: Any, log_indent_level: int = 0
+):
+    """Prints the details of an agent execution node using a provided print function."""
+    from pydantic_ai import Agent
+    from pydantic_ai.messages import (
+        FinalResultEvent,
+        FunctionToolCallEvent,
+        FunctionToolResultEvent,
+        PartDeltaEvent,
+        PartStartEvent,
+        TextPartDelta,
+        ThinkingPartDelta,
+        ToolCallPartDelta,
+    )
+
+    if Agent.is_user_prompt_node(node):
+        print_func(_format_header("🔠 Receiving input...", log_indent_level))
+    elif Agent.is_model_request_node(node):
+        # A model request node => We can stream tokens from the model's request
+        print_func(_format_header("🧠 Processing...", log_indent_level))
+        # Reference: https://ai.pydantic.dev/agents/#streaming
+        async with node.stream(agent_run.ctx) as request_stream:
+            is_streaming = False
+            async for event in request_stream:
+                if isinstance(event, PartStartEvent) and event.part:
+                    if is_streaming:
+                        print_func("")
+                    content = _get_event_part_content(event)
+                    print_func(_format_content(content, log_indent_level), end="")
+                    is_streaming = True
+                elif isinstance(event, PartDeltaEvent):
+                    if isinstance(event.delta, TextPartDelta) or isinstance(
+                        event.delta, ThinkingPartDelta
+                    ):
+                        content_delta = event.delta.content_delta
+                        print_func(
+                            _format_stream_content(content_delta, log_indent_level),
+                            end="",
+                        )
+                    elif isinstance(event.delta, ToolCallPartDelta):
+                        args_delta = event.delta.args_delta
+                        print_func(
+                            _format_stream_content(args_delta, log_indent_level), end=""
+                        )
+                    is_streaming = True
+                elif isinstance(event, FinalResultEvent) and event.tool_name:
+                    if is_streaming:
+                        print_func("")
+                    tool_name = event.tool_name
+                    print_func(
+                        _format_content(
+                            f"Result: tool_name={tool_name}", log_indent_level
+                        )
+                    )
+                    is_streaming = False
+            if is_streaming:
+                print_func("")
+    elif Agent.is_call_tools_node(node):
+        # A handle-response node => The model returned some data, potentially calls a tool
+        print_func(_format_header("🧰 Calling Tool...", log_indent_level))
+        async with node.stream(agent_run.ctx) as handle_stream:
+            async for event in handle_stream:
+                if isinstance(event, FunctionToolCallEvent):
+                    args = _get_event_part_args(event)
+                    call_id = event.part.tool_call_id
+                    tool_name = event.part.tool_name
+                    print_func(
+                        _format_content(
+                            f"{call_id} | Call {tool_name} {args}", log_indent_level
+                        )
+                    )
+                elif isinstance(event, FunctionToolResultEvent):
+                    call_id = event.tool_call_id
+                    result_content = event.result.content
+                    print_func(
+                        _format_content(
+                            f"{call_id} | {result_content}", log_indent_level
+                        )
+                    )
+    elif Agent.is_end_node(node):
+        # Once an End node is reached, the agent run is complete
+        print_func(_format_header("✅ Completed...", log_indent_level))
+
+
+def _format_header(text: str, log_indent_level: int = 0) -> str:
+    return _format(
+        text,
+        base_indent=2,
+        first_indent=0,
+        indent=0,
+        log_indent_level=log_indent_level,
+    )
+
+
+def _format_content(text: str, log_indent_level: int = 0) -> str:
+    return _format(
+        text,
+        base_indent=2,
+        first_indent=3,
+        indent=3,
+        log_indent_level=log_indent_level,
+    )
+
+
+def _format_stream_content(text: str, log_indent_level: int = 0) -> str:
+    return _format(
+        text,
+        base_indent=2,
+        indent=3,
+        log_indent_level=log_indent_level,
+        is_stream=True,
+    )
+
+
+def _format(
+    text: str,
+    base_indent: int = 0,
+    first_indent: int = 0,
+    indent: int = 0,
+    log_indent_level: int = 0,
+    is_stream: bool = False,
+) -> str:
+    line_prefix = (base_indent * (log_indent_level + 1) + indent) * " "
+    processed_text = text.replace("\n", f"\n{line_prefix}")
+    if is_stream:
+        return stylize_faint(processed_text)
+    first_line_prefix = (base_indent * (log_indent_level + 1) + first_indent) * " "
+    return stylize_faint(f"{first_line_prefix}{processed_text}")
+
+
+def _get_event_part_args(event: Any) -> Any:
+    # Handle empty arguments across different providers
+    if event.part.args == "" or event.part.args is None:
+        return {}
+    if isinstance(event.part.args, str):
+        # Some providers might send "null" or "{}" as a string
+        if event.part.args.strip() in ["null", "{}"]:
+            return {}
+        try:
+            obj = json.loads(event.part.args)
+            if isinstance(obj, dict):
+                return _truncate_kwargs(obj)
+        except json.JSONDecodeError:
+            pass
+    # Handle dummy property if present (from our schema sanitization)
+    if isinstance(event.part.args, dict):
+        return _truncate_kwargs(event.part.args)
+    print(type(event.part.args))
+    return event.part.args
+
+
+def _truncate_kwargs(kwargs: dict[str, Any]) -> dict[str, Any]:
+    return {key: _truncate_arg(val) for key, val in kwargs.items() if key != "_dummy"}
+
+
+def _truncate_arg(arg: str, length: int = 19) -> str:
+    if isinstance(arg, str) and len(arg) > length:
+        return f"{arg[:length-4]} ..."
+    return arg
+
+
+def _get_event_part_content(event: Any) -> str:
+    if not hasattr(event, "part"):
+        return f"{event}"
+    if not hasattr(event.part, "content"):
+        return f"{event.part}"
+    return getattr(event.part, "content")

{zrb-1.15.2 → zrb-1.15.4}/src/zrb/task/llm/prompt.py

@@ -93,28 +93,54 @@ def get_workflow_prompt(
     modes_attr: StrListAttr | None,
     render_modes: bool,
 ) -> str:
-    modes = get_modes(ctx, modes_attr, render_modes)
+    builtin_workflow_dir = os.path.join(os.path.dirname(__file__), "default_workflow")
+    modes = set(get_modes(ctx, modes_attr, render_modes))
+
     # Get user-defined workflows
     workflows = {
         workflow_name.strip().lower(): content
         for workflow_name, content in llm_context_config.get_workflows().items()
         if workflow_name.strip().lower() in modes
     }
-    # Get requested builtin-workflow names
+
+    # Get available builtin workflow names from the file system
+    available_builtin_workflow_names = set()
+    try:
+        for filename in os.listdir(builtin_workflow_dir):
+            if filename.endswith(".md"):
+                available_builtin_workflow_names.add(filename[:-3].lower())
+    except FileNotFoundError:
+        # Handle case where the directory might not exist
+        ctx.log_error(
+            f"Warning: Default workflow directory not found at {builtin_workflow_dir}"
+        )
+    except Exception as e:
+        # Catch other potential errors during directory listing
+        ctx.log_error(f"Error listing default workflows: {e}")
+
+    # Determine which builtin workflows are requested and not already loaded
     requested_builtin_workflow_names = [
-        workflow_name.lower()
-        for workflow_name in ("coding", "copywriting", "researching")
-        if workflow_name.lower() in modes and workflow_name.lower() not in workflows
+        workflow_name
+        for workflow_name in available_builtin_workflow_names
+        if workflow_name in modes and workflow_name not in workflows
     ]
-    # add builtin-workflows if requested
+
+    # Add builtin-workflows if requested
     if len(requested_builtin_workflow_names) > 0:
-        dir_path = os.path.dirname(__file__)
         for workflow_name in requested_builtin_workflow_names:
             workflow_file_path = os.path.join(
-                dir_path, "default_workflow", f"{workflow_name}.md"
+                builtin_workflow_dir, f"{workflow_name}.md"
             )
-            with open(workflow_file_path, "r") as f:
-                workflows[workflow_name] = f.read()
+            try:
+                with open(workflow_file_path, "r") as f:
+                    workflows[workflow_name] = f.read()
+            except FileNotFoundError:
+                ctx.log_error(
+                    f"Warning: Builtin workflow file not found: {workflow_file_path}"
+                )
+            except Exception as e:
+                ctx.log_error(f"Error reading builtin workflow {workflow_name}: {e}")
+
     return "\n".join(
         [
             make_prompt_section(header.capitalize(), content)

{zrb-1.15.2 → zrb-1.15.4}/src/zrb/task/llm/tool_wrapper.py

@@ -8,6 +8,7 @@ from typing import TYPE_CHECKING, Any
 from zrb.context.any_context import AnyContext
 from zrb.task.llm.error import ToolExecutionError
 from zrb.util.callable import get_callable_name
+from zrb.util.cli.markdown import render_markdown
 from zrb.util.cli.style import (
     stylize_blue,
     stylize_error,
@@ -123,25 +124,21 @@ def _create_wrapper(
 
 
 async def _ask_for_approval(
-    ctx: AnyContext, func: Callable, args: list[Any], kwargs: dict[Any]
+    ctx: AnyContext, func: Callable, args: list[Any], kwargs: dict[str, Any]
 ) -> tuple[bool, str]:
     func_name = get_callable_name(func)
-    normalized_args = [stylize_green(_truncate_arg(arg)) for arg in args]
-    normalized_kwargs = []
-    for key, val in kwargs.items():
-        truncated_val = _truncate_arg(f"{val}")
-        normalized_kwargs.append(
-            f"{stylize_yellow(key)}={stylize_green(truncated_val)}"
-        )
-    func_param_str = ",".join(normalized_args + normalized_kwargs)
-    func_call_str = (
-        f"{stylize_blue(func_name + '(')}{func_param_str}{stylize_blue(')')}"
+    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}"
     )
     while True:
-        ctx.print(
-            f"✅ >> Allow to run tool: {func_call_str} (Yes | No, <reason>)", plain=True
-        )
+        ctx.print(complete_confirmation_message, plain=True)
         user_input = await _read_line()
+        ctx.print("", plain=True)
         user_responses = [val.strip() for val in user_input.split(",", maxsplit=1)]
         while len(user_responses) < 2:
             user_responses.append("")
@@ -167,6 +164,39 @@ async def _ask_for_approval(
             continue
 
 
+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()]
+    )
+    return render_markdown(markdown)
+
+
+def _get_func_param_item(key: str, val: Any) -> str:
+    upper_key = key.upper()
+    val_str = f"{val}"
+    val_parts = val_str.split("\n")
+    if len(val_parts) == 1:
+        return f"- {upper_key} `{val}`"
+    lines = [f"- {upper_key}", "  ```"]
+    for val_part in val_parts:
+        lines.append(f"  {val_part}")
+    lines.append("  ```")
+    return "\n".join(lines)
+
+
+def _get_func_call_str(func: Callable, args: list[Any], kwargs: dict[str, Any]) -> str:
+    func_name = get_callable_name(func)
+    normalized_args = [stylize_green(_truncate_arg(arg)) for arg in args]
+    normalized_kwargs = []
+    for key, val in kwargs.items():
+        truncated_val = _truncate_arg(f"{val}")
+        normalized_kwargs.append(
+            f"{stylize_yellow(key)}={stylize_green(truncated_val)}"
+        )
+    func_param_str = ", ".join(normalized_args + normalized_kwargs)
+    return f"{stylize_blue(func_name + '(')}{func_param_str}{stylize_blue(')')}"
+
+
 def _truncate_arg(arg: str, length: int = 19) -> str:
     if len(arg) > length:
         return f"{arg[:length-4]} ..."

{zrb-1.15.2 → zrb-1.15.4}/src/zrb/task/llm_task.py

@@ -331,7 +331,7 @@ class LLMTask(BaseTask):
                     ctx.xcom[xcom_usage_key] = Xcom([])
                 usage = agent_run.result.usage()
                 ctx.xcom[xcom_usage_key].push(usage)
-                ctx.print(stylize_faint(f"💸 Token: {usage}"), plain=True)
+                ctx.print(stylize_faint(f"  💸 Token: {usage}"), plain=True)
                 return agent_run.result.output
             else:
                 ctx.log_warning("Agent run did not produce a result.")

zrb-1.15.4/src/zrb/util/cli/markdown.py

@@ -0,0 +1,12 @@
+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()

zrb-1.15.2/src/zrb/task/llm/print_node.py

@@ -1,94 +0,0 @@
-from collections.abc import Callable
-from typing import Any
-
-from zrb.util.cli.style import stylize_faint
-
-
-async def print_node(print_func: Callable, agent_run: Any, node: Any):
-    """Prints the details of an agent execution node using a provided print function."""
-    from pydantic_ai import Agent
-    from pydantic_ai.messages import (
-        FinalResultEvent,
-        FunctionToolCallEvent,
-        FunctionToolResultEvent,
-        PartDeltaEvent,
-        PartStartEvent,
-        TextPartDelta,
-        ThinkingPartDelta,
-        ToolCallPartDelta,
-    )
-
-    if Agent.is_user_prompt_node(node):
-        print_func(stylize_faint("🔠 Receiving input..."))
-    elif Agent.is_model_request_node(node):
-        # A model request node => We can stream tokens from the model's request
-        print_func(stylize_faint("🧠 Processing..."))
-        # Reference: https://ai.pydantic.dev/agents/#streaming
-        async with node.stream(agent_run.ctx) as request_stream:
-            is_streaming = False
-            async for event in request_stream:
-                if isinstance(event, PartStartEvent) and event.part:
-                    if is_streaming:
-                        print_func("")
-                    print_func(
-                        stylize_faint(f"    Starting part {event.index}: {event.part}"),
-                    )
-                    is_streaming = False
-                elif isinstance(event, PartDeltaEvent):
-                    if isinstance(event.delta, TextPartDelta) or isinstance(
-                        event.delta, ThinkingPartDelta
-                    ):
-                        print_func(
-                            stylize_faint(f"{event.delta.content_delta}"),
-                            end="",
-                        )
-                    elif isinstance(event.delta, ToolCallPartDelta):
-                        print_func(
-                            stylize_faint(f"{event.delta.args_delta}"),
-                            end="",
-                        )
-                    is_streaming = True
-                elif isinstance(event, FinalResultEvent) and event.tool_name:
-                    if is_streaming:
-                        print_func("")
-                    print_func(
-                        stylize_faint(f"    Result: tool_name={event.tool_name}"),
-                    )
-                    is_streaming = False
-            if is_streaming:
-                print_func("")
-    elif Agent.is_call_tools_node(node):
-        # A handle-response node => The model returned some data, potentially calls a tool
-        print_func(stylize_faint("🧰 Calling Tool..."))
-        async with node.stream(agent_run.ctx) as handle_stream:
-            async for event in handle_stream:
-                if isinstance(event, FunctionToolCallEvent):
-                    # Handle empty arguments across different providers
-                    if event.part.args == "" or event.part.args is None:
-                        event.part.args = {}
-                    elif isinstance(
-                        event.part.args, str
-                    ) and event.part.args.strip() in ["null", "{}"]:
-                        # Some providers might send "null" or "{}" as a string
-                        event.part.args = {}
-                    # Handle dummy property if present (from our schema sanitization)
-                    if (
-                        isinstance(event.part.args, dict)
-                        and "_dummy" in event.part.args
-                    ):
-                        del event.part.args["_dummy"]
-                    print_func(
-                        stylize_faint(
-                            f"    {event.part.tool_call_id} | "
-                            f"Call {event.part.tool_name} {event.part.args}"
-                        )
-                    )
-                elif isinstance(event, FunctionToolResultEvent):
-                    print_func(
-                        stylize_faint(
-                            f"    {event.tool_call_id} | {event.result.content}"
-                        )
-                    )
-    elif Agent.is_end_node(node):
-        # Once an End node is reached, the agent run is complete
-        print_func(stylize_faint("✅ Completed..."))