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

zrb/task/llm/prompt.py

@@ -10,7 +10,7 @@ from zrb.context.any_context import AnyContext
 from zrb.task.llm.conversation_history_model import ConversationHistory
 from zrb.task.llm.workflow import LLMWorkflow, get_available_workflows
 from zrb.util.attr import get_attr, get_str_attr, get_str_list_attr
-from zrb.util.file import read_dir, read_file_with_line_numbers
+from zrb.util.file import read_dir, read_file, read_file_with_line_numbers
 from zrb.util.markdown import make_markdown_section
 
 if TYPE_CHECKING:
@@ -32,11 +32,8 @@ def get_system_and_user_prompt(
 ) -> tuple[str, str]:
     if conversation_history is None:
         conversation_history = ConversationHistory()
-    new_user_message_prompt, apendixes = _get_user_message_prompt(user_message)
     new_system_prompt = _construct_system_prompt(
         ctx=ctx,
-        user_message=user_message,
-        apendixes=apendixes,
         persona_attr=persona_attr,
         render_persona=render_persona,
         system_prompt_attr=system_prompt_attr,
@@ -47,13 +44,12 @@ def get_system_and_user_prompt(
         render_workflows=render_workflows,
         conversation_history=conversation_history,
     )
+    new_user_message_prompt = _get_user_message_prompt(user_message)
     return new_system_prompt, new_user_message_prompt
 
 
 def _construct_system_prompt(
     ctx: AnyContext,
-    user_message: str,
-    apendixes: str,
     persona_attr: StrAttr | None = None,
     render_persona: bool = False,
     system_prompt_attr: StrAttr | None = None,
@@ -71,6 +67,7 @@ def _construct_system_prompt(
     special_instruction_prompt = _get_special_instruction_prompt(
         ctx, special_instruction_prompt_attr, render_special_instruction_prompt
     )
+    project_instructions = _get_project_instructions()
     available_workflows = get_available_workflows()
     active_workflow_names = set(
         _get_active_workflow_names(ctx, workflows_attr, render_workflows)
@@ -98,6 +95,7 @@ def _construct_system_prompt(
                     ]
                 ),
             ),
+            make_markdown_section("📜 PROJECT INSTRUCTIONS", project_instructions),
             make_markdown_section("🛠️ AVAILABLE WORKFLOWS", inactive_workflow_prompt),
             make_markdown_section(
                 "📚 CONTEXT",
@@ -122,10 +120,6 @@ def _construct_system_prompt(
                             "📝 Contextual Note Content",
                             conversation_history.contextual_note,
                         ),
-                        make_markdown_section(
-                            "📄 Apendixes",
-                            apendixes,
-                        ),
                     ]
                 ),
             ),
@@ -133,21 +127,63 @@ def _construct_system_prompt(
     )
 
 
+def _get_project_instructions() -> str:
+    instructions = []
+    cwd = os.path.abspath(os.getcwd())
+    home = os.path.abspath(os.path.expanduser("~"))
+    search_dirs = []
+    if cwd == home or cwd.startswith(os.path.join(home, "")):
+        current_dir = cwd
+        while True:
+            search_dirs.append(current_dir)
+            if current_dir == home:
+                break
+            parent_dir = os.path.dirname(current_dir)
+            if parent_dir == current_dir:
+                break
+            current_dir = parent_dir
+    else:
+        search_dirs.append(cwd)
+    for file_name in ["AGENTS.md", "CLAUDE.md"]:
+        for dir_path in search_dirs:
+            abs_file_name = os.path.join(dir_path, file_name)
+            if os.path.isfile(abs_file_name):
+                content = read_file(abs_file_name)
+                instructions.append(
+                    make_markdown_section(
+                        f"Instruction from `{abs_file_name}`", content
+                    )
+                )
+                break
+    return "\n".join(instructions)
+
+
+def _get_prompt_attr(
+    ctx: AnyContext,
+    attr: StrAttr | None,
+    render: bool,
+    default: str | None,
+) -> str:
+    """Generic helper to get a prompt attribute, prioritizing task-specific then default."""
+    value = get_attr(
+        ctx,
+        attr,
+        None,
+        auto_render=render,
+    )
+    if value is not None:
+        return value
+    return default or ""
+
+
 def _get_persona(
     ctx: AnyContext,
     persona_attr: StrAttr | None,
     render_persona: bool,
 ) -> str:
-    """Gets the persona, prioritizing task-specific, then default."""
-    persona = get_attr(
-        ctx,
-        persona_attr,
-        None,
-        auto_render=render_persona,
+    return _get_prompt_attr(
+        ctx, persona_attr, render_persona, llm_config.default_persona
     )
-    if persona is not None:
-        return persona
-    return llm_config.default_persona or ""
 
 
 def _get_base_system_prompt(
@@ -155,16 +191,9 @@ def _get_base_system_prompt(
     system_prompt_attr: StrAttr | None,
     render_system_prompt: bool,
 ) -> str:
-    """Gets the base system prompt, prioritizing task-specific, then default."""
-    system_prompt = get_attr(
-        ctx,
-        system_prompt_attr,
-        None,
-        auto_render=render_system_prompt,
+    return _get_prompt_attr(
+        ctx, system_prompt_attr, render_system_prompt, llm_config.default_system_prompt
     )
-    if system_prompt is not None:
-        return system_prompt
-    return llm_config.default_system_prompt or ""
 
 
 def _get_special_instruction_prompt(
@@ -172,16 +201,12 @@ def _get_special_instruction_prompt(
     special_instruction_prompt_attr: StrAttr | None,
     render_spcecial_instruction_prompt: bool,
 ) -> str:
-    """Gets the special instruction prompt, prioritizing task-specific, then default."""
-    special_instruction = get_attr(
+    return _get_prompt_attr(
         ctx,
         special_instruction_prompt_attr,
-        None,
-        auto_render=render_spcecial_instruction_prompt,
+        render_spcecial_instruction_prompt,
+        llm_config.default_special_instruction_prompt,
     )
-    if special_instruction is not None:
-        return special_instruction
-    return llm_config.default_special_instruction_prompt
 
 
 def _get_active_workflow_names(
@@ -229,7 +254,8 @@ def _get_workflow_prompt(
     )
 
 
-def _get_user_message_prompt(user_message: str) -> tuple[str, str]:
+def _get_user_message_prompt(user_message: str) -> str:
+    current_directory = os.getcwd()
     processed_user_message = user_message
     # Match “@” + any non-space/comma sequence that contains at least one “/”
     pattern = r"(?<!\w)@(?=[^,\s]*\/)([^,\?\!\s]+)"
@@ -247,19 +273,19 @@ def _get_user_message_prompt(user_message: str) -> tuple[str, str]:
             ref_type = "directory"
         if content != "":
             # Replace the @-reference in the user message with the placeholder
-            placeholder = f"[Reference {i+1}: `{os.path.basename(ref)}`]"
+            rel_path = os.path.relpath(resource_path, current_directory)
+            placeholder = f"`{rel_path}`"
             processed_user_message = processed_user_message.replace(
                 f"@{ref}", placeholder, 1
             )
             apendix_list.append(
                 make_markdown_section(
-                    f"Content of {placeholder} ({ref_type} path: `{resource_path}`)",
+                    f"{placeholder} {ref_type}",
                     "\n".join(content) if isinstance(content, list) else content,
                     as_code=True,
                 )
             )
     apendixes = "\n".join(apendix_list)
-    current_directory = os.getcwd()
     iso_date = datetime.now(timezone.utc).astimezone().isoformat()
     modified_user_message = make_markdown_section(
         "User Request",
@@ -269,10 +295,14 @@ def _get_user_message_prompt(user_message: str) -> tuple[str, str]:
                 f"- Current Time: {iso_date}",
                 "---",
                 processed_user_message,
+                make_markdown_section(
+                    "📄 Apendixes",
+                    apendixes,
+                ),
             ]
         ),
     )
-    return modified_user_message, apendixes
+    return modified_user_message
 
 
 def get_user_message(

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

@@ -3,9 +3,13 @@ import os
 from zrb.config.config import CFG
 from zrb.config.llm_context.config import llm_context_config
 from zrb.config.llm_context.workflow import LLMWorkflow
+from zrb.context.any_context import AnyContext
+from zrb.xcom.xcom import Xcom
 
+LLM_LOADED_WORKFLOW_XCOM_NAME = "_llm_loaded_workflow_name"
 
-def load_workflow(workflow_name: str | list[str]) -> str:
+
+def load_workflow(ctx: AnyContext, workflow_name: str | list[str]) -> str:
     """
     Loads and formats one or more workflow documents for LLM consumption.
 
@@ -36,34 +40,56 @@ def load_workflow(workflow_name: str | list[str]) -> str:
                 ]
             )
         )
+    llm_loaded_workflow_xcom = get_llm_loaded_workflow_xcom(ctx)
+    llm_loaded_workflow_xcom.push(names)
     return "\n".join(contents)
 
 
+def get_llm_loaded_workflow_xcom(ctx: AnyContext) -> Xcom:
+    if LLM_LOADED_WORKFLOW_XCOM_NAME not in ctx.xcom:
+        ctx.xcom[LLM_LOADED_WORKFLOW_XCOM_NAME] = Xcom([])
+    return ctx.xcom[LLM_LOADED_WORKFLOW_XCOM_NAME]
+
+
 def get_available_workflows() -> dict[str, LLMWorkflow]:
     available_workflows = {
         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 +100,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,
@@ -81,7 +82,7 @@ class LLMTask(BaseTask):
         render_system_prompt: bool = False,
         special_instruction_prompt: "Callable[[AnyContext], str | None] | str | None" = None,
         render_special_instruction_prompt: bool = False,
-        workflows: StrListAttr | None = None,
+        workflows: "Callable[[AnyContext], list[str] | None] | list[str] | None" = None,
         render_workflows: bool = True,
         message: StrAttr | None = None,
         attachment: "UserContent | list[UserContent] | Callable[[AnyContext], UserContent | list[UserContent]] | None" = None,  # noqa
@@ -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
@@ -238,7 +235,58 @@ class LLMTask(BaseTask):
         self._yolo_mode = yolo_mode
 
     async def _exec_action(self, ctx: AnyContext) -> Any:
-        # Get dependent configurations first
+        # 1. Get dependent configurations
+        (
+            model_settings,
+            model,
+            yolo_mode,
+            summarization_prompt,
+            user_message,
+            attachments,
+        ) = self._get_llm_config(ctx)
+
+        # 2. Prepare initial state (read history from previous session)
+        conversation_history = await read_conversation_history(
+            ctx=ctx,
+            conversation_history_reader=self._conversation_history_reader,
+            conversation_history_file_attr=self._conversation_history_file,
+            render_history_file=self._render_history_file,
+            conversation_history_attr=self._conversation_history,
+        )
+        inject_conversation_history_notes(conversation_history)
+        inject_subagent_conversation_history_into_ctx(ctx, conversation_history)
+
+        # 3. Get system prompt and user prompt
+        system_prompt, user_prompt = self._get_prompts(
+            ctx, user_message, conversation_history
+        )
+
+        # 4. Get the agent instance
+        ctx.log_info(f"SYSTEM PROMPT:\n{system_prompt}")
+        ctx.log_info(f"USER PROMPT:\n{user_prompt}")
+        agent = self._create_agent(
+            ctx,
+            model,
+            system_prompt,
+            model_settings,
+            yolo_mode,
+            summarization_prompt,
+        )
+
+        # 5. Run the agent iteration
+        result = await self._execute_agent(
+            ctx=ctx,
+            agent=agent,
+            user_prompt=user_prompt,
+            attachments=attachments,
+            conversation_history=conversation_history,
+        )
+
+        # 6. Save history and usage
+        await self._save_history_and_usage(ctx, conversation_history)
+        return result
+
+    def _get_llm_config(self, ctx: AnyContext):
         model_settings = get_model_settings(ctx, self._model_settings)
         model = get_model(
             ctx=ctx,
@@ -261,18 +309,22 @@ class LLMTask(BaseTask):
         )
         user_message = get_user_message(ctx, self._message, self._render_message)
         attachments = get_attachments(ctx, self._attachment)
-        # 1. Prepare initial state (read history from previous session)
-        conversation_history = await read_conversation_history(
-            ctx=ctx,
-            conversation_history_reader=self._conversation_history_reader,
-            conversation_history_file_attr=self._conversation_history_file,
-            render_history_file=self._render_history_file,
-            conversation_history_attr=self._conversation_history,
+        return (
+            model_settings,
+            model,
+            yolo_mode,
+            summarization_prompt,
+            user_message,
+            attachments,
         )
-        inject_conversation_history_notes(conversation_history)
-        inject_subagent_conversation_history_into_ctx(ctx, conversation_history)
-        # 2. Get system prompt and user prompt
-        system_prompt, user_prompt = get_system_and_user_prompt(
+
+    def _get_prompts(
+        self,
+        ctx: AnyContext,
+        user_message: str,
+        conversation_history: ConversationHistory,
+    ):
+        return get_system_and_user_prompt(
             ctx=ctx,
             user_message=user_message,
             persona_attr=self._persona,
@@ -285,7 +337,16 @@ class LLMTask(BaseTask):
             render_workflows=self._render_workflows,
             conversation_history=conversation_history,
         )
-        # 3. Summarization
+
+    def _create_agent(
+        self,
+        ctx: AnyContext,
+        model,
+        system_prompt,
+        model_settings,
+        yolo_mode,
+        summarization_prompt,
+    ):
         small_model = get_model(
             ctx=ctx,
             model_attr=self._small_model,
@@ -301,10 +362,7 @@ class LLMTask(BaseTask):
             self._history_summarization_token_threshold,
             self._render_history_summarization_token_threshold,
         )
-        # 4. Get the agent instance
-        ctx.log_info(f"SYSTEM PROMPT:\n{system_prompt}")
-        ctx.log_info(f"USER PROMPT:\n{user_prompt}")
-        agent = get_agent(
+        return get_agent(
             ctx=ctx,
             model=model,
             rate_limitter=self._rate_limitter,
@@ -322,15 +380,10 @@ class LLMTask(BaseTask):
             summarization_token_threshold=summarization_token_threshold,
             history_processors=[],  # TODO: make this a property
         )
-        # 5. Run the agent iteration and save the results/history
-        result = await self._execute_agent(
-            ctx=ctx,
-            agent=agent,
-            user_prompt=user_prompt,
-            attachments=attachments,
-            conversation_history=conversation_history,
-        )
-        # 6. Write conversation history
+
+    async def _save_history_and_usage(
+        self, ctx: AnyContext, conversation_history: ConversationHistory
+    ):
         conversation_history.subagent_history = (
             extract_subagent_conversation_history_from_ctx(ctx)
         )
@@ -341,7 +394,6 @@ class LLMTask(BaseTask):
             conversation_history_file_attr=self._conversation_history_file,
             render_history_file=self._render_history_file,
         )
-        return result
 
     async def _execute_agent(
         self,
@@ -362,7 +414,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)