zrb 1.21.31__py3-none-any.whl → 1.21.37__py3-none-any.whl

zrb/config/llm_rate_limitter.py

@@ -129,56 +129,79 @@ class LLMRateLimitter:
     async def throttle(
         self,
         prompt: Any,
-        throttle_notif_callback: Callable[[str], Any] | None = None,
+        throttle_notif_callback: Callable[..., Any] | None = None,
     ):
         now = time.time()
         str_prompt = self._prompt_to_str(prompt)
-        tokens = self.count_token(str_prompt)
+        new_requested_tokens = self.count_token(str_prompt)
         # Clean up old entries
         while self.request_times and now - self.request_times[0] > 60:
             self.request_times.popleft()
         while self.token_times and now - self.token_times[0][0] > 60:
             self.token_times.popleft()
         # Check per-request token limit
-        if tokens > self.max_tokens_per_request:
+        if new_requested_tokens > self.max_tokens_per_request:
             raise ValueError(
                 (
-                    "Request exceeds max_tokens_per_request "
-                    f"({tokens} > {self.max_tokens_per_request})."
+                    "New request exceeds max_tokens_per_request "
+                    f"({new_requested_tokens} > {self.max_tokens_per_request})."
                 )
             )
-        if tokens > self.max_tokens_per_minute:
+        if new_requested_tokens > self.max_tokens_per_minute:
             raise ValueError(
                 (
-                    "Request exceeds max_tokens_per_minute "
-                    f"({tokens} > {self.max_tokens_per_minute})."
+                    "New request exceeds max_tokens_per_minute "
+                    f"({new_requested_tokens} > {self.max_tokens_per_minute})."
                 )
             )
         # Wait if over per-minute request or token limit
+        callback_new_line = True
+        ever_throttled = False
         while (
             len(self.request_times) >= self.max_requests_per_minute
-            or sum(t for _, t in self.token_times) + tokens > self.max_tokens_per_minute
+            or sum(t for _, t in self.token_times) + new_requested_tokens
+            > self.max_tokens_per_minute
         ):
+            ever_throttled = True
             if throttle_notif_callback is not None:
                 if len(self.request_times) >= self.max_requests_per_minute:
+                    limit = self.max_requests_per_minute
                     rpm = len(self.request_times)
+                    wait_time = max(0, 60 - (now - self.request_times[0]))
                     throttle_notif_callback(
-                        f"Max request per minute exceeded: {rpm} of {self.max_requests_per_minute}"
+                        f"Max request per minute exceeded: {rpm} of {limit}. "
+                        f"Waiting for {wait_time:.2f} seconds.",
+                        new_line=callback_new_line,
                     )
                 else:
-                    tpm = sum(t for _, t in self.token_times) + tokens
+                    limit = self.max_tokens_per_minute
+                    current_tokens = sum(t for _, t in self.token_times)
+                    tpm = current_tokens + new_requested_tokens
+                    needed = tpm - self.max_tokens_per_minute
+                    freed = 0
+                    wait_time = 0
+                    for t_time, t_count in self.token_times:
+                        freed += t_count
+                        if freed >= needed:
+                            wait_time = max(0, 60 - (now - t_time))
+                            break
                     throttle_notif_callback(
-                        f"Max token per minute exceeded: {tpm} of {self.max_tokens_per_minute}"
+                        f"Max token per minute exceeded: {tpm} of {limit}. "
+                        f"Waiting for {wait_time:.2f} seconds.",
+                        new_line=callback_new_line,
                     )
+                callback_new_line = False
             await asyncio.sleep(self.throttle_sleep)
             now = time.time()
             while self.request_times and now - self.request_times[0] > 60:
                 self.request_times.popleft()
             while self.token_times and now - self.token_times[0][0] > 60:
                 self.token_times.popleft()
+        if ever_throttled and throttle_notif_callback is not None:
+            throttle_notif_callback("", new_line=True)
         # Record this request
         self.request_times.append(now)
-        self.token_times.append((now, tokens))
+        self.token_times.append((now, new_requested_tokens))
 
     def _prompt_to_str(self, prompt: Any) -> str:
         try:

zrb/input/option_input.py

@@ -1,7 +1,13 @@
+from typing import TYPE_CHECKING
+
 from zrb.attr.type import StrAttr, StrListAttr
 from zrb.context.any_shared_context import AnySharedContext
 from zrb.input.base_input import BaseInput
 from zrb.util.attr import get_str_list_attr
+from zrb.util.match import fuzzy_match
+
+if TYPE_CHECKING:
+    from prompt_toolkit.completion import Completer
 
 
 class OptionInput(BaseInput):
@@ -58,10 +64,32 @@ class OptionInput(BaseInput):
         self, shared_ctx: AnySharedContext, prompt_message: str, options: list[str]
     ) -> str:
         from prompt_toolkit import PromptSession
-        from prompt_toolkit.completion import WordCompleter
 
         if shared_ctx.is_tty:
             reader = PromptSession()
-            option_completer = WordCompleter(options, ignore_case=True)
+            option_completer = self._get_option_completer(options)
             return reader.prompt(f"{prompt_message}: ", completer=option_completer)
         return input(f"{prompt_message}: ")
+
+    def _get_option_completer(self, options: list[str]) -> "Completer":
+        from prompt_toolkit.completion import CompleteEvent, Completer, Completion
+        from prompt_toolkit.document import Document
+
+        class OptionCompleter(Completer):
+            def __init__(self, options: list[str]):
+                self._options = options
+
+            def get_completions(
+                self, document: Document, complete_event: CompleteEvent
+            ):
+                search_pattern = document.get_word_before_cursor(WORD=True)
+                candidates = []
+                for option in self._options:
+                    matched, score = fuzzy_match(option, search_pattern)
+                    if matched:
+                        candidates.append((score, option))
+                candidates.sort(key=lambda x: (x[0], x[1]))
+                for _, option in candidates:
+                    yield Completion(option, start_position=-len(search_pattern))
+
+        return OptionCompleter(options)

zrb/task/cmd_task.py

@@ -48,6 +48,7 @@ class CmdTask(BaseTask):
         warn_unrecommended_command: bool | None = None,
         max_output_line: int = 1000,
         max_error_line: int = 1000,
+        execution_timeout: int = 3600,
         is_interactive: bool = False,
         execute_condition: BoolAttr = True,
         retries: int = 2,
@@ -103,6 +104,7 @@ class CmdTask(BaseTask):
         self._render_cwd = render_cwd
         self._max_output_line = max_output_line
         self._max_error_line = max_error_line
+        self._execution_timeout = execution_timeout
         self._should_plain_print = plain_print
         self._should_warn_unrecommended_command = warn_unrecommended_command
         self._is_interactive = is_interactive
@@ -142,6 +144,7 @@ class CmdTask(BaseTask):
             register_pid_method=lambda pid: ctx.xcom.get(xcom_pid_key).push(pid),
             max_output_line=self._max_output_line,
             max_error_line=self._max_error_line,
+            timeout=self._execution_timeout,
             is_interactive=self._is_interactive,
         )
         # Check for errors

zrb/task/llm/agent_runner.py

@@ -112,8 +112,12 @@ async def _run_single_agent_iteration(
 
 
 def _create_print_throttle_notif(ctx: AnyContext) -> Callable[[str], None]:
-    def _print_throttle_notif(reason: str):
-        ctx.print(stylize_faint(f"  ⌛>> Request Throttled: {reason}"), plain=True)
+    def _print_throttle_notif(text: str, *args: Any, **kwargs: Any):
+        new_line = kwargs.get("new_line", True)
+        prefix = "\r" if not new_line else "\n"
+        if text != "":
+            prefix = f"{prefix}  🐢 Request Throttled: "
+        ctx.print(stylize_faint(f"{prefix}{text}"), plain=True, end="")
 
     return _print_throttle_notif
 

zrb/task/llm/history_list.py

@@ -0,0 +1,13 @@
+from typing import Any
+
+
+def remove_system_prompt_and_instruction(
+    history_list: list[dict[str, Any]],
+) -> list[dict[str, Any]]:
+    for msg in history_list:
+        if msg.get("instructions"):
+            msg["instructions"] = ""
+        msg["parts"] = [
+            p for p in msg.get("parts", []) if p.get("part_kind") != "system-prompt"
+        ]
+    return history_list

zrb/task/llm/history_processor.py

@@ -88,30 +88,21 @@ def create_summarize_history_processor(
         messages: list[ModelMessage],
     ) -> list[ModelMessage]:
         history_list = json.loads(ModelMessagesTypeAdapter.dump_json(messages))
-        history_json_str = json.dumps(history_list)
+        history_list_str = json.dumps(history_list)
         # Estimate token usage
         # Note: Pydantic ai has run context parameter
         # (https://ai.pydantic.dev/message-history/#runcontext-parameter)
         # But we cannot use run_ctx.usage.total_tokens because total token keep increasing
         # even after summariztion.
-        estimated_token_usage = rate_limitter.count_token(history_json_str)
+        estimated_token_usage = rate_limitter.count_token(history_list_str)
         _print_request_info(
             ctx, estimated_token_usage, summarization_token_threshold, messages
         )
         if estimated_token_usage < summarization_token_threshold or len(messages) == 1:
             return messages
-        history_list_without_instruction = [
-            {
-                key: obj[key]
-                for key in obj
-                if index == len(history_list) - 1 or key != "instructions"
-            }
-            for index, obj in enumerate(history_list)
-        ]
-        history_json_str_without_instruction = json.dumps(
-            history_list_without_instruction
+        summarization_message = (
+            f"Summarize the following conversation: {history_list_str}"
         )
-        summarization_message = f"Summarize the following conversation: {history_json_str_without_instruction}"
         summarization_agent = Agent[None, ConversationSummary](
             model=summarization_model,
             output_type=save_conversation_summary,

zrb/task/llm/print_node.py

@@ -24,15 +24,19 @@ async def print_node(
     )
 
     meta = getattr(node, "id", None) or getattr(node, "request_id", None)
+    progress_char_list = ["|", "/", "-", "\\"]
+    progress_index = 0
     if Agent.is_user_prompt_node(node):
         print_func(_format_header("🔠 Receiving input...", log_indent_level))
-    elif Agent.is_model_request_node(node):
+        return
+    if 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-all-events-and-output
         try:
             async with node.stream(agent_run.ctx) as request_stream:
                 is_streaming = False
+                is_tool_processing = False
                 async for event in request_stream:
                     if isinstance(event, PartStartEvent) and event.part:
                         if is_streaming:
@@ -40,29 +44,59 @@ async def print_node(
                         content = _get_event_part_content(event)
                         print_func(_format_content(content, log_indent_level), end="")
                         is_streaming = True
-                    elif isinstance(event, PartDeltaEvent):
+                        is_tool_processing = False
+                        continue
+                    if isinstance(event, PartDeltaEvent):
                         if isinstance(event.delta, TextPartDelta):
                             content_delta = event.delta.content_delta
                             print_func(
                                 _format_stream_content(content_delta, log_indent_level),
                                 end="",
                             )
-                        elif isinstance(event.delta, ThinkingPartDelta):
+                            is_tool_processing = False
+                            is_streaming = True
+                            continue
+                        if 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
-                            if isinstance(args_delta, dict):
-                                args_delta = json.dumps(args_delta)
+                            is_tool_processing = False
+                            is_streaming = True
+                            continue
+                        if isinstance(event.delta, ToolCallPartDelta):
+                            if CFG.LLM_SHOW_TOOL_CALL_PREPARATION:
+                                args_delta = event.delta.args_delta
+                                if isinstance(args_delta, dict):
+                                    args_delta = json.dumps(args_delta)
+                                print_func(
+                                    _format_stream_content(
+                                        args_delta, log_indent_level
+                                    ),
+                                    end="",
+                                )
+                                is_streaming = True
+                                is_tool_processing = True
+                                continue
+                            prefix = "\n" if not is_tool_processing else ""
+                            progress_char = progress_char_list[progress_index]
                             print_func(
-                                _format_stream_content(args_delta, log_indent_level),
+                                _format_content(
+                                    f"Preparing Tool Parameters... {progress_char}",
+                                    log_indent_level,
+                                    prefix=f"\r{prefix}",
+                                ),
                                 end="",
                             )
+                            progress_index += 1
+                            if progress_index >= len(progress_char_list):
+                                progress_index = 0
+                            is_tool_processing = True
+                            is_streaming = True
+                            continue
                         is_streaming = True
-                    elif isinstance(event, FinalResultEvent) and event.tool_name:
+                    if isinstance(event, FinalResultEvent) and event.tool_name:
                         if is_streaming:
                             print_func("")
                         tool_name = event.tool_name
@@ -72,6 +106,7 @@ async def print_node(
                             )
                         )
                         is_streaming = False
+                        is_tool_processing = False
                 if is_streaming:
                     print_func("")
         except UnexpectedModelBehavior as e:
@@ -85,7 +120,8 @@ async def print_node(
                     log_indent_level,
                 )
             )
-    elif Agent.is_call_tools_node(node):
+        return
+    if 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))
         try:
@@ -100,7 +136,8 @@ async def print_node(
                                 f"{call_id} | Call {tool_name} {args}", log_indent_level
                             )
                         )
-                    elif (
+                        continue
+                    if (
                         isinstance(event, FunctionToolResultEvent)
                         and event.tool_call_id
                     ):
@@ -113,12 +150,10 @@ async def print_node(
                                     log_indent_level,
                                 )
                             )
-                        else:
-                            print_func(
-                                _format_content(
-                                    f"{call_id} | Executed", log_indent_level
-                                )
-                            )
+                            continue
+                        print_func(
+                            _format_content(f"{call_id} | Executed", log_indent_level)
+                        )
         except UnexpectedModelBehavior as e:
             print_func("")  # ensure newline consistency
             print_func(
@@ -130,9 +165,11 @@ async def print_node(
                     log_indent_level,
                 )
             )
-    elif Agent.is_end_node(node):
+        return
+    if Agent.is_end_node(node):
         # Once an End node is reached, the agent run is complete
         print_func(_format_header("✅ Completed...", log_indent_level))
+        return
 
 
 def _format_header(text: str | None, log_indent_level: int = 0) -> str:
@@ -145,8 +182,10 @@ def _format_header(text: str | None, log_indent_level: int = 0) -> str:
     )
 
 
-def _format_content(text: str | None, log_indent_level: int = 0) -> str:
-    return _format(
+def _format_content(
+    text: str | None, log_indent_level: int = 0, prefix: str = ""
+) -> str:
+    return prefix + _format(
         text,
         base_indent=2,
         first_indent=3,
@@ -155,8 +194,10 @@ def _format_content(text: str | None, log_indent_level: int = 0) -> str:
     )
 
 
-def _format_stream_content(text: str | None, log_indent_level: int = 0) -> str:
-    return _format(
+def _format_stream_content(
+    text: str | None, log_indent_level: int = 0, prefix: str = ""
+) -> str:
+    return prefix + _format(
         text,
         base_indent=2,
         indent=3,
@@ -207,7 +248,7 @@ def _truncate_kwargs(kwargs: dict[str, Any]) -> dict[str, Any]:
     return {key: _truncate_arg(val) for key, val in kwargs.items()}
 
 
-def _truncate_arg(arg: str, length: int = 19) -> str:
+def _truncate_arg(arg: str, length: int = 30) -> str:
     if isinstance(arg, str) and len(arg) > length:
         return f"{arg[:length-4]} ..."
     return arg

zrb/task/llm/tool_wrapper.py

@@ -136,9 +136,12 @@ def _create_wrapper(
             result = await run_async(func(*args, **kwargs))
             _check_tool_call_result_limit(result)
             if has_ever_edited:
+                serializable_kwargs = kwargs.copy()
+                if any_context_param_name is not None:
+                    serializable_kwargs.pop(any_context_param_name, None)
                 return {
                     "tool_call_result": result,
-                    "new_tool_parameters": kwargs,
+                    "new_tool_parameters": serializable_kwargs,
                     "message": "User correction: Tool was called with user's parameters",
                 }
             return result

zrb/task/llm/workflow.py

@@ -44,26 +44,40 @@ def get_available_workflows() -> dict[str, LLMWorkflow]:
         workflow_name.strip().lower(): workflow
         for workflow_name, workflow in llm_context_config.get_workflows().items()
     }
-    # Define builtin workflow locations in order of precedence
-    builtin_workflow_locations = [
-        os.path.expanduser(additional_builtin_workflow_path)
-        for additional_builtin_workflow_path in CFG.LLM_BUILTIN_WORKFLOW_PATHS
-        if os.path.isdir(os.path.expanduser(additional_builtin_workflow_path))
-    ]
-    builtin_workflow_locations.append(
-        os.path.join(os.path.dirname(__file__), "default_workflow")
+    workflow_hidden_folder = f".{CFG.ROOT_GROUP_NAME}"
+    # Define workflow locations in order of precedence
+    default_workflow_locations = (
+        [
+            # Project specific + user specific workflows
+            os.path.join(
+                os.path.dirname(__file__), workflow_hidden_folder, "workflows"
+            ),
+            os.path.join(os.path.dirname(__file__), workflow_hidden_folder, "skills"),
+            os.path.join(os.path.dirname(__file__), ".claude", "skills"),
+            os.path.join(os.path.expanduser("~"), workflow_hidden_folder, "workflows"),
+            os.path.join(os.path.expanduser("~"), workflow_hidden_folder, "skills"),
+            os.path.join(os.path.expanduser("~"), ".claude", "skills"),
+        ]
+        + [
+            # User defined builtin workflows
+            os.path.expanduser(additional_builtin_workflow_path)
+            for additional_builtin_workflow_path in CFG.LLM_BUILTIN_WORKFLOW_PATHS
+            if os.path.isdir(os.path.expanduser(additional_builtin_workflow_path))
+        ]
+        + [
+            # Zrb builtin workflows
+            os.path.join(os.path.dirname(__file__), "default_workflow"),
+        ]
     )
     # Load workflows from all locations
-    for workflow_location in builtin_workflow_locations:
+    for workflow_location in default_workflow_locations:
         if not os.path.isdir(workflow_location):
             continue
         for workflow_name in os.listdir(workflow_location):
             workflow_dir = os.path.join(workflow_location, workflow_name)
-            workflow_file = os.path.join(workflow_dir, "workflow.md")
-            if not os.path.isfile(workflow_file):
-                workflow_file = os.path.join(workflow_dir, "SKILL.md")
-                if not os.path.isfile(path=workflow_file):
-                    continue
+            workflow_file = _get_workflow_file_name(workflow_dir)
+            if not workflow_file:
+                continue
             # Only add if not already defined (earlier locations have precedence)
             if workflow_name not in available_workflows:
                 with open(workflow_file, "r") as f:
@@ -74,3 +88,16 @@ def get_available_workflows() -> dict[str, LLMWorkflow]:
                     content=workflow_content,
                 )
     return available_workflows
+
+
+def _get_workflow_file_name(workflow_dir: str) -> str | None:
+    workflow_file = os.path.join(workflow_dir, "workflow.md")
+    if os.path.isfile(workflow_file):
+        return workflow_file
+    workflow_file = os.path.join(workflow_dir, "WORKFLOW.md")
+    if os.path.isfile(workflow_file):
+        return workflow_file
+    workflow_file = os.path.join(workflow_dir, "SKILL.md")
+    if os.path.isfile(workflow_file):
+        return workflow_file
+    return None

zrb/task/llm_task.py

@@ -22,6 +22,7 @@ from zrb.task.llm.conversation_history import (
     write_conversation_history,
 )
 from zrb.task.llm.conversation_history_model import ConversationHistory
+from zrb.task.llm.history_list import remove_system_prompt_and_instruction
 from zrb.task.llm.history_summarization import get_history_summarization_token_threshold
 from zrb.task.llm.prompt import (
     get_attachments,
@@ -134,9 +135,6 @@ class LLMTask(BaseTask):
         upstream: list[AnyTask] | AnyTask | None = None,
         fallback: list[AnyTask] | AnyTask | None = None,
         successor: list[AnyTask] | AnyTask | None = None,
-        conversation_context: (
-            dict[str, Any] | Callable[[AnyContext], dict[str, Any]] | None
-        ) = None,
     ):
         super().__init__(
             name=name,
@@ -204,7 +202,6 @@ class LLMTask(BaseTask):
             render_history_summarization_token_threshold
         )
         self._max_call_iteration = max_call_iteration
-        self._conversation_context = conversation_context
         self._yolo_mode = yolo_mode
         self._render_yolo_mode = render_yolo_mode
         self._attachment = attachment
@@ -362,7 +359,9 @@ class LLMTask(BaseTask):
                 rate_limitter=self._rate_limitter,
             )
             if agent_run and agent_run.result:
-                new_history_list = json.loads(agent_run.result.all_messages_json())
+                new_history_list = remove_system_prompt_and_instruction(
+                    json.loads(agent_run.result.all_messages_json())
+                )
                 conversation_history.history = new_history_list
                 xcom_usage_key = f"{self.name}-usage"
                 if xcom_usage_key not in ctx.xcom:

zrb/task/rsync_task.py

@@ -44,6 +44,7 @@ class RsyncTask(CmdTask):
         plain_print: bool = False,
         max_output_line: int = 1000,
         max_error_line: int = 1000,
+        execution_timeout: int = 3600,
         execute_condition: BoolAttr = True,
         retries: int = 2,
         retry_period: float = 0,
@@ -77,6 +78,7 @@ class RsyncTask(CmdTask):
             plain_print=plain_print,
             max_output_line=max_output_line,
             max_error_line=max_error_line,
+            execution_timeout=execution_timeout,
             execute_condition=execute_condition,
             retries=retries,
             retry_period=retry_period,

zrb/util/cmd/command.py

@@ -5,7 +5,7 @@ import signal
 import sys
 from collections import deque
 from collections.abc import Callable
-from typing import TextIO
+from typing import Any, TextIO
 
 import psutil
 
@@ -62,6 +62,8 @@ async def run_command(
     register_pid_method: Callable[[int], None] | None = None,
     max_output_line: int = 1000,
     max_error_line: int = 1000,
+    max_display_line: int | None = None,
+    timeout: int = 3600,
     is_interactive: bool = False,
 ) -> tuple[CmdResult, int]:
     """
@@ -77,6 +79,8 @@ async def run_command(
     actual_print_method = print_method if print_method is not None else print
     if cwd is None:
         cwd = os.getcwd()
+    if max_display_line is None:
+        max_display_line = max(max_output_line, max_error_line)
     # While environment variables alone weren't the fix, they are still
     # good practice for encouraging simpler output from tools.
     child_env = (env_map or os.environ).copy()
@@ -95,17 +99,33 @@ async def run_command(
     if register_pid_method is not None:
         register_pid_method(cmd_process.pid)
     # Use the new, simple, and correct stream reader.
+    display_lines = deque(maxlen=max_display_line if max_display_line > 0 else 0)
     stdout_task = asyncio.create_task(
-        __read_stream(cmd_process.stdout, actual_print_method, max_output_line)
+        __read_stream(
+            cmd_process.stdout, actual_print_method, max_output_line, display_lines
+        )
     )
     stderr_task = asyncio.create_task(
-        __read_stream(cmd_process.stderr, actual_print_method, max_error_line)
+        __read_stream(
+            cmd_process.stderr, actual_print_method, max_error_line, display_lines
+        )
+    )
+    timeout_task = (
+        asyncio.create_task(asyncio.sleep(timeout)) if timeout and timeout > 0 else None
     )
     try:
-        return_code = await cmd_process.wait()
+        wait_task = asyncio.create_task(cmd_process.wait())
+        done, pending = await asyncio.wait(
+            {wait_task, timeout_task} if timeout_task else {wait_task},
+            return_when=asyncio.FIRST_COMPLETED,
+        )
+        if timeout_task and timeout_task in done:
+            raise asyncio.TimeoutError()
+        return_code = wait_task.result()
         stdout, stderr = await asyncio.gather(stdout_task, stderr_task)
-        return CmdResult(stdout, stderr), return_code
-    except (KeyboardInterrupt, asyncio.CancelledError):
+        display = "\r\n".join(display_lines)
+        return CmdResult(stdout, stderr, display=display), return_code
+    except (KeyboardInterrupt, asyncio.CancelledError, asyncio.TimeoutError):
         try:
             os.killpg(cmd_process.pid, signal.SIGINT)
             await asyncio.wait_for(cmd_process.wait(), timeout=2.0)
@@ -133,13 +153,14 @@ def __get_cmd_stdin(is_interactive: bool) -> int | TextIO:
 async def __read_stream(
     stream: asyncio.StreamReader,
     print_method: Callable[..., None],
-    max_lines: int,
+    max_line: int,
+    display_queue: deque[Any],
 ) -> str:
     """
     Reads from the stream using the robust `readline()` and correctly
     interprets carriage returns (`\r`) as distinct print events.
     """
-    captured_lines = deque(maxlen=max_lines if max_lines > 0 else 0)
+    captured_lines = deque(maxlen=max_line if max_line > 0 else 0)
     while True:
         try:
             line_bytes = await stream.readline()
@@ -149,8 +170,9 @@ async def __read_stream(
             # Safety valve for the memory limit.
             error_msg = "[ERROR] A single line of output was too long to process."
             print_method(error_msg)
-            if max_lines > 0:
+            if max_line > 0:
                 captured_lines.append(error_msg)
+                display_queue.append(error_msg)
             break
         except (KeyboardInterrupt, asyncio.CancelledError):
             raise
@@ -165,8 +187,9 @@ async def __read_stream(
                     print_method(clean_part, end="\r\n")
                 except Exception:
                     print_method(clean_part)
-                if max_lines > 0:
+                if max_line > 0:
                     captured_lines.append(clean_part)
+                    display_queue.append(clean_part)
     return "\r\n".join(captured_lines)