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

zrb/builtin/llm/chat_completion.py

@@ -11,16 +11,24 @@ from zrb.builtin.llm.chat_session_cmd import (
     CLEAR_SUB_CMD,
     HELP_CMD,
     HELP_CMD_DESC,
+    LOAD_CMD,
+    LOAD_CMD_DESC,
     MULTILINE_END_CMD,
     MULTILINE_END_CMD_DESC,
     MULTILINE_START_CMD,
     MULTILINE_START_CMD_DESC,
     QUIT_CMD,
     QUIT_CMD_DESC,
+    RESPONSE_CMD,
+    RESPONSE_CMD_DESC,
+    RESPONSE_SAVE_SUB_CMD_DESC,
     RUN_CLI_CMD,
     RUN_CLI_CMD_DESC,
     SAVE_CMD,
     SAVE_CMD_DESC,
+    SAVE_SUB_CMD,
+    SESSION_CMD,
+    SESSION_CMD_DESC,
     SET_SUB_CMD,
     WORKFLOW_ADD_SUB_CMD_DESC,
     WORKFLOW_CLEAR_SUB_CMD_DESC,
@@ -33,6 +41,7 @@ from zrb.builtin.llm.chat_session_cmd import (
     YOLO_SET_FALSE_CMD_DESC,
     YOLO_SET_TRUE_CMD_DESC,
 )
+from zrb.config.config import CFG
 from zrb.util.match import fuzzy_match
 
 if TYPE_CHECKING:
@@ -52,10 +61,39 @@ def get_chat_completer() -> "Completer":
                 yield completion
             for completion in self._complete_slash_file_command(document):
                 yield completion
+            for completion in self._complete_slash_session_load_command(document):
+                yield completion
             # Appendix
             for completion in self._complete_appendix(document):
                 yield completion
 
+        def _complete_slash_session_load_command(self, document: Document):
+            text = document.text_before_cursor
+            prefixes = []
+            for cmd in LOAD_CMD:
+                prefixes.append(f"{cmd} ")
+
+            for prefix in prefixes:
+                if text.startswith(prefix):
+                    pattern = text[len(prefix) :]
+                    # Use fuzzy_path_search but in LLM_HISTORY_DIR/save-point
+                    save_point_dir = os.path.join(CFG.LLM_HISTORY_DIR, "save-point")
+                    if not os.path.isdir(save_point_dir):
+                        return
+
+                    potential_options = self._fuzzy_path_search(
+                        pattern, root=save_point_dir, dirs=False, files=True
+                    )
+                    for option in potential_options:
+                        if option.startswith(save_point_dir):
+                            rel_option = os.path.relpath(option, save_point_dir)
+                        else:
+                            rel_option = option
+                        yield Completion(
+                            f"{prefix}{rel_option}",
+                            start_position=-len(text),
+                        )
+
         def _complete_slash_file_command(self, document: Document):
             text = document.text_before_cursor
             prefixes = []
@@ -118,8 +156,16 @@ def get_chat_completer() -> "Completer":
                     cmd_options[f"{cmd} {subcmd}"] = WORKFLOW_CLEAR_SUB_CMD_DESC
                 for subcmd in SET_SUB_CMD:
                     cmd_options[f"{cmd} {subcmd}"] = WORKFLOW_SET_SUB_CMD_DESC
+            for cmd in SESSION_CMD:
+                cmd_options[cmd] = SESSION_CMD_DESC
             for cmd in SAVE_CMD:
                 cmd_options[cmd] = SAVE_CMD_DESC
+            for cmd in LOAD_CMD:
+                cmd_options[cmd] = LOAD_CMD_DESC
+            for cmd in RESPONSE_CMD:
+                cmd_options[cmd] = RESPONSE_CMD_DESC
+                for subcmd in SAVE_SUB_CMD:
+                    cmd_options[f"{cmd} {subcmd}"] = RESPONSE_SAVE_SUB_CMD_DESC
             for cmd in ATTACHMENT_CMD:
                 cmd_options[cmd] = ATTACHMENT_CMD_DESC
                 for subcmd in ADD_SUB_CMD:

zrb/builtin/llm/chat_session.py

@@ -5,27 +5,39 @@ from typing import TYPE_CHECKING, Any
 from zrb.builtin.llm.chat_session_cmd import (
     ATTACHMENT_CMD,
     HELP_CMD,
+    LOAD_CMD,
     MULTILINE_END_CMD,
     MULTILINE_START_CMD,
     QUIT_CMD,
+    RESPONSE_CMD,
     RUN_CLI_CMD,
     SAVE_CMD,
+    SESSION_CMD,
     WORKFLOW_CMD,
     YOLO_CMD,
     get_new_attachments,
     get_new_workflows,
     get_new_yolo_mode,
+    handle_response_cmd,
+    handle_session,
     is_command_match,
     print_commands,
     print_current_attachments,
     print_current_workflows,
     print_current_yolo_mode,
     run_cli_command,
-    save_final_result,
 )
 from zrb.builtin.llm.chat_trigger import llm_chat_trigger
+from zrb.builtin.llm.history import get_last_session_name
+from zrb.builtin.llm.xcom_names import (
+    LLM_ASK_ERROR_XCOM_NAME,
+    LLM_ASK_RESULT_XCOM_NAME,
+    LLM_ASK_SESSION_XCOM_NAME,
+)
 from zrb.config.llm_config import llm_config
 from zrb.context.any_context import AnyContext
+from zrb.context.any_shared_context import AnySharedContext
+from zrb.task.llm.workflow import get_llm_loaded_workflow_xcom
 from zrb.util.cli.markdown import render_markdown
 
 if TYPE_CHECKING:
@@ -44,30 +56,39 @@ async def read_user_prompt(ctx: AnyContext) -> str:
     reader: PromptSession[Any] | StreamReader = await _setup_input_reader(is_tty)
     multiline_mode = False
     is_first_time = True
-    current_workflows: str = ctx.input.workflows
+    current_workflows: str = ctx.input.workflow
     current_yolo_mode: bool | str = ctx.input.yolo
     current_attachments: str = ctx.input.attach
     user_inputs: list[str] = []
     final_result: str = ""
     should_end = False
+    start_new: bool = ctx.input.start_new
+    if not start_new and ctx.input.previous_session == "":
+        session = ctx.session
+        if session is not None:
+            # Automatically inject last session name as previous session
+            last_session_name = get_last_session_name()
+            session.shared_ctx.input["previous_session"] = last_session_name
+            session.shared_ctx.input["previous-session"] = last_session_name
+    current_session_name: str | None = ctx.input.previous_session
     while not should_end:
-        await asyncio.sleep(0.01)
-        previous_session_name: str | None = (
-            ctx.input.previous_session if is_first_time else ""
-        )
-        start_new: bool = ctx.input.start_new if is_first_time else False
+        await asyncio.sleep(0)
         if is_first_time and ctx.input.message.strip() != "":
             user_input = ctx.input.message
         else:
             # Get user input based on mode
             if not multiline_mode:
                 ctx.print("💬 >>", plain=True)
-            user_input = await llm_chat_trigger.wait(reader, ctx)
+            user_input = await llm_chat_trigger.wait(
+                ctx, reader, current_session_name, is_first_time
+            )
             if not multiline_mode:
                 ctx.print("", plain=True)
         # At this point, is_first_time has to be False
         if is_first_time:
             is_first_time = False
+        # Add additional workflows activated by LLM in the previous session
+        current_workflows = _get_new_workflows_from_xcom(ctx, current_workflows)
         # Handle user input (including slash commands)
         if multiline_mode:
             if is_command_match(user_input, MULTILINE_END_CMD):
@@ -87,8 +108,8 @@ async def read_user_prompt(ctx: AnyContext) -> str:
                 current_workflows = get_new_workflows(current_workflows, user_input)
                 print_current_workflows(ctx, current_workflows)
                 continue
-            elif is_command_match(user_input, SAVE_CMD):
-                save_final_result(ctx, user_input, final_result)
+            elif is_command_match(user_input, RESPONSE_CMD):
+                handle_response_cmd(ctx, user_input, final_result)
                 continue
             elif is_command_match(user_input, ATTACHMENT_CMD):
                 current_attachments = get_new_attachments(
@@ -106,20 +127,30 @@ async def read_user_prompt(ctx: AnyContext) -> str:
             elif is_command_match(user_input, HELP_CMD):
                 print_commands(ctx)
                 continue
+            elif (
+                is_command_match(user_input, SESSION_CMD)
+                or is_command_match(user_input, SAVE_CMD)
+                or is_command_match(user_input, LOAD_CMD)
+            ):
+                current_session_name, start_new = handle_session(
+                    ctx, current_session_name, start_new, user_input
+                )
             else:
                 user_inputs.append(user_input)
         # Trigger LLM
         user_prompt = "\n".join(user_inputs)
         user_inputs = []
-        result = await _trigger_ask_and_wait_for_result(
+        result, current_session_name = await _trigger_ask_and_wait_for_result(
             ctx=ctx,
             user_prompt=user_prompt,
             attach=current_attachments,
             workflows=current_workflows,
             yolo_mode=current_yolo_mode,
-            previous_session_name=previous_session_name,
+            previous_session_name=current_session_name,
             start_new=start_new,
         )
+        # After the first trigger, we no longer need to force start_new
+        start_new = False
         current_attachments = ""
         final_result = final_result if result is None else result
         if ctx.is_web_mode or not is_tty:
@@ -127,6 +158,23 @@ async def read_user_prompt(ctx: AnyContext) -> str:
     return final_result
 
 
+def _get_new_workflows_from_xcom(ctx: AnyContext, current_workflows: str):
+    llm_loaded_workflow_xcom = get_llm_loaded_workflow_xcom(ctx)
+    new_workflow_names = [
+        workflow_name.strip()
+        for workflow_name in current_workflows.split(",")
+        if workflow_name.strip() != ""
+    ]
+    while len(llm_loaded_workflow_xcom) > 0:
+        additional_workflow_names = [
+            workflow_name
+            for workflow_name in llm_loaded_workflow_xcom.pop()
+            if workflow_name not in new_workflow_names
+        ]
+        new_workflow_names += additional_workflow_names
+    return ",".join(new_workflow_names)
+
+
 async def _setup_input_reader(
     is_interactive: bool,
 ) -> "PromptSession[Any] | StreamReader":
@@ -151,7 +199,7 @@ async def _trigger_ask_and_wait_for_result(
     yolo_mode: bool | str,
     previous_session_name: str | None = None,
     start_new: bool = False,
-) -> str | None:
+) -> tuple[str | None, str | None]:
     """
     Triggers the LLM ask task and waits for the result via XCom.
 
@@ -162,22 +210,27 @@ async def _trigger_ask_and_wait_for_result(
         start_new: Whether to start a new conversation (optional).
 
     Returns:
-        The result from the LLM task, or None if the user prompt is empty.
+        The result from the LLM task and the session name.
     """
     if user_prompt.strip() == "":
-        return None
+        return None, previous_session_name
     await _trigger_ask(
         ctx, user_prompt, attach, workflows, yolo_mode, previous_session_name, start_new
     )
     result = await _wait_ask_result(ctx)
+
+    resolved_session_name = previous_session_name
+    if result is not None:
+        resolved_session_name = await _wait_ask_session_name(ctx)
+
     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
+    return result, resolved_session_name
 
 
-def get_llm_ask_input_mapping(callback_ctx: AnyContext):
+def get_llm_ask_input_mapping(callback_ctx: AnyContext | AnySharedContext):
     """
     Generates the input mapping for the LLM ask task from the callback context.
 
@@ -200,7 +253,7 @@ def get_llm_ask_input_mapping(callback_ctx: AnyContext):
         "previous-session": data.get("previous_session_name"),
         "message": data.get("message"),
         "attach": data.get("attach"),
-        "workflows": data.get("workflows"),
+        "workflow": data.get("workflow"),
         "yolo": data.get("yolo"),
     }
 
@@ -223,15 +276,13 @@ async def _trigger_ask(
         previous_session_name: The name of the previous chat session (optional).
         start_new: Whether to start a new conversation (optional).
     """
-    if previous_session_name is None:
-        previous_session_name = await _wait_ask_session_name(ctx)
     ctx.xcom["ask_trigger"].push(
         {
             "previous_session_name": previous_session_name,
             "start_new": start_new,
             "message": user_prompt,
             "attach": attach,
-            "workflows": workflows,
+            "workflow": workflows,
             "yolo": yolo_mode,
         }
     )
@@ -247,12 +298,18 @@ async def _wait_ask_result(ctx: AnyContext) -> str | None:
     Returns:
         The result string from the LLM task.
     """
-    while "ask_result" not in ctx.xcom or len(ctx.xcom.ask_result) == 0:
-        await asyncio.sleep(0.1)
-        if "ask_error" in ctx.xcom and len(ctx.xcom.ask_error) > 0:
-            ctx.xcom.ask_error.pop()
+    while (
+        LLM_ASK_RESULT_XCOM_NAME not in ctx.xcom
+        or len(ctx.xcom[LLM_ASK_RESULT_XCOM_NAME]) == 0
+    ):
+        await asyncio.sleep(0)
+        if (
+            LLM_ASK_ERROR_XCOM_NAME in ctx.xcom
+            and len(ctx.xcom[LLM_ASK_ERROR_XCOM_NAME]) > 0
+        ):
+            ctx.xcom[LLM_ASK_ERROR_XCOM_NAME].pop()
             return None
-    return ctx.xcom.ask_result.pop()
+    return ctx.xcom[LLM_ASK_RESULT_XCOM_NAME].pop()
 
 
 async def _wait_ask_session_name(ctx: AnyContext) -> str:
@@ -265,6 +322,9 @@ async def _wait_ask_session_name(ctx: AnyContext) -> str:
     Returns:
         The session name string.
     """
-    while "ask_session_name" not in ctx.xcom or len(ctx.xcom.ask_session_name) == 0:
-        await asyncio.sleep(0.1)
-    return ctx.xcom.ask_session_name.pop()
+    while (
+        LLM_ASK_SESSION_XCOM_NAME not in ctx.xcom
+        or len(ctx.xcom[LLM_ASK_SESSION_XCOM_NAME]) == 0
+    ):
+        await asyncio.sleep(0)
+    return ctx.xcom[LLM_ASK_SESSION_XCOM_NAME].pop()

zrb/builtin/llm/chat_session_cmd.py

@@ -12,7 +12,7 @@ from zrb.util.cli.style import (
     stylize_faint,
 )
 from zrb.util.cmd.command import run_command
-from zrb.util.file import write_file
+from zrb.util.file import read_file, write_file
 from zrb.util.markdown import make_markdown_section
 from zrb.util.string.conversion import FALSE_STRS, TRUE_STRS, to_boolean
 
@@ -20,14 +20,20 @@ MULTILINE_START_CMD = ["/multi", "/multiline"]
 MULTILINE_END_CMD = ["/end"]
 QUIT_CMD = ["/bye", "/quit", "/q", "/exit"]
 WORKFLOW_CMD = ["/workflow", "/workflows", "/skill", "/skills", "/w"]
+RESPONSE_CMD = ["/response", "/res"]
 SAVE_CMD = ["/save", "/s"]
+LOAD_CMD = ["/load", "/l"]
 ATTACHMENT_CMD = ["/attachment", "/attachments", "/attach"]
 YOLO_CMD = ["/yolo"]
 HELP_CMD = ["/help", "/info"]
+RUN_CLI_CMD = ["/run", "/exec", "/execute", "/cmd", "/cli", "!"]
+SESSION_CMD = ["/session", "/conversation", "/convo"]
+
 ADD_SUB_CMD = ["add"]
 SET_SUB_CMD = ["set"]
 CLEAR_SUB_CMD = ["clear"]
-RUN_CLI_CMD = ["/run", "/exec", "/execute", "/cmd", "/cli", "!"]
+SAVE_SUB_CMD = ["save"]
+LOAD_SUB_CMD = ["load"]
 
 # Command display constants
 MULTILINE_START_CMD_DESC = "Start multiline input"
@@ -35,14 +41,20 @@ MULTILINE_END_CMD_DESC = "End multiline input"
 QUIT_CMD_DESC = "Quit from chat session"
 WORKFLOW_CMD_DESC = "Show active workflows"
 WORKFLOW_ADD_SUB_CMD_DESC = (
-    "Add active workflow "
-    f"(e.g., `{WORKFLOW_CMD[0]} {ADD_SUB_CMD[0]} coding,researching`)"
+    "Add active workflow " f"(e.g., `{WORKFLOW_CMD[0]} {ADD_SUB_CMD[0]} coding`)"
 )
 WORKFLOW_SET_SUB_CMD_DESC = (
-    "Set active workflows " f"(e.g., `{WORKFLOW_CMD[0]} {SET_SUB_CMD[0]} coding,`)"
+    "Set active workflows "
+    f"(e.g., `{WORKFLOW_CMD[0]} {SET_SUB_CMD[0]} coding,researching`)"
 )
 WORKFLOW_CLEAR_SUB_CMD_DESC = "Deactivate all workflows"
-SAVE_CMD_DESC = f"Save last response to a file (e.g., `{SAVE_CMD[0]} conclusion.md`)"
+RESPONSE_CMD_DESC = "Manage response"
+RESPONSE_SAVE_SUB_CMD_DESC = (
+    "Save last response to a file "
+    f"(e.g., `{RESPONSE_CMD[0]} {SAVE_SUB_CMD[0]} conclusion.md`)"
+)
+SAVE_CMD_DESC = "Save current session " f"(e.g., `{SAVE_CMD[0]} save-point`)"
+LOAD_CMD_DESC = "Load session " f"(e.g., `{LOAD_CMD[0]} save-point`)"
 ATTACHMENT_CMD_DESC = "Show current attachment"
 ATTACHMENT_ADD_SUB_CMD_DESC = (
     "Attach a file " f"(e.g., `{ATTACHMENT_CMD[0]} {ADD_SUB_CMD[0]} ./logo.png`)"
@@ -61,6 +73,7 @@ YOLO_SET_TRUE_CMD_DESC = "Activate YOLO mode for all tools"
 YOLO_SET_FALSE_CMD_DESC = "Deactivate YOLO mode for all tools"
 RUN_CLI_CMD_DESC = "Run a non-interactive CLI command"
 HELP_CMD_DESC = "Show info/help"
+SESSION_CMD_DESC = "Show current session"
 
 
 def print_current_yolo_mode(
@@ -75,7 +88,9 @@ def print_current_yolo_mode(
 
 def print_current_attachments(ctx: AnyContext, current_attachments_value: str) -> None:
     attachments_str = (
-        current_attachments_value if current_attachments_value != "" else "*Not Set*"
+        ", ".join(current_attachments_value.split(","))
+        if current_attachments_value != ""
+        else "*Not Set*"
     )
     ctx.print(render_markdown(f"📎 Current attachments: {attachments_str}"), plain=True)
     ctx.print("", plain=True)
@@ -89,7 +104,7 @@ def print_current_workflows(ctx: AnyContext, current_workflows_value: str) -> No
         else "*No Available Workflow*"
     )
     current_workflows_str = (
-        current_workflows_value
+        ", ".join(current_workflows_value.split(","))
         if current_workflows_value != ""
         else "*No Active Workflow*"
     )
@@ -107,8 +122,10 @@ def print_current_workflows(ctx: AnyContext, current_workflows_value: str) -> No
     ctx.print("", plain=True)
 
 
-def save_final_result(ctx: AnyContext, user_input: str, final_result: str) -> None:
-    save_path = get_command_param(user_input, SAVE_CMD)
+def handle_response_cmd(ctx: AnyContext, user_input: str, final_result: str) -> None:
+    if not is_command_match(user_input, RESPONSE_CMD, SAVE_SUB_CMD):
+        return
+    save_path = get_command_param(user_input, RESPONSE_CMD, SAVE_SUB_CMD)
     save_path = os.path.expanduser(save_path)
     if os.path.exists(save_path):
         ctx.print(
@@ -206,6 +223,59 @@ def get_new_workflows(old_workflow: str, user_input: str) -> str:
     return _normalize_comma_separated_str(old_workflow)
 
 
+def handle_session(
+    ctx: AnyContext,
+    current_session_name: str | None,
+    current_start_new: bool,
+    user_input: str,
+) -> tuple[str | None, bool]:
+    if is_command_match(user_input, SAVE_CMD):
+        save_point = get_command_param(user_input, SAVE_CMD)
+        if not save_point:
+            ctx.print(render_markdown("️⚠️ Save point name is required."), plain=True)
+            return current_session_name, current_start_new
+        if not current_session_name:
+            ctx.print(
+                render_markdown(
+                    "⚠️ No active session to save. Please start a conversation first."
+                ),
+                plain=True,
+            )
+            return current_session_name, current_start_new
+        save_point_path = os.path.join(CFG.LLM_HISTORY_DIR, "save-point", save_point)
+        write_file(save_point_path, current_session_name)
+        ctx.print(
+            render_markdown(
+                f"Session saved to save-point: {save_point} ({current_session_name})"
+            ),
+            plain=True,
+        )
+        return current_session_name, current_start_new
+    if is_command_match(user_input, LOAD_CMD):
+        save_point = get_command_param(user_input, LOAD_CMD)
+        if not save_point:
+            ctx.print(render_markdown("⚠️ Save point name is required."), plain=True)
+            return current_session_name, current_start_new
+        save_point_path = os.path.join(CFG.LLM_HISTORY_DIR, "save-point", save_point)
+        if not os.path.exists(save_point_path):
+            ctx.print(
+                render_markdown(f"⚠️ Save point '{save_point}' not found."), plain=True
+            )
+            return current_session_name, current_start_new
+        current_session_name = read_file(save_point_path).strip()
+        ctx.print(
+            render_markdown(f"Loaded session: {current_session_name}"), plain=True
+        )
+        # When loading a session, we shouldn't start a new one
+        return current_session_name, False
+    if is_command_match(user_input, SESSION_CMD):
+        ctx.print(
+            render_markdown(f"Current session: {current_session_name}"), plain=True
+        )
+        return current_session_name, current_start_new
+    return current_session_name, current_start_new
+
+
 def _normalize_comma_separated_str(comma_separated_str: str) -> str:
     return ",".join(
         [
@@ -269,7 +339,13 @@ def print_commands(ctx: AnyContext):
                     WORKFLOW_SET_SUB_CMD_DESC,
                 ),
                 _show_subcommand(CLEAR_SUB_CMD[0], "", WORKFLOW_CLEAR_SUB_CMD_DESC),
-                _show_command(f"{SAVE_CMD[0]}", SAVE_CMD_DESC),
+                _show_command(SESSION_CMD[0], SESSION_CMD_DESC),
+                _show_command(SAVE_CMD[0], SAVE_CMD_DESC),
+                _show_command(LOAD_CMD[0], LOAD_CMD_DESC),
+                _show_command(RESPONSE_CMD[0], RESPONSE_CMD_DESC),
+                _show_subcommand(
+                    SAVE_SUB_CMD[0], "<file-path>", RESPONSE_SAVE_SUB_CMD_DESC
+                ),
                 _show_command(YOLO_CMD[0], YOLO_CMD_DESC),
                 _show_subcommand(SET_SUB_CMD[0], "true", YOLO_SET_TRUE_CMD_DESC),
                 _show_subcommand(SET_SUB_CMD[0], "false", YOLO_SET_FALSE_CMD_DESC),

zrb/builtin/llm/chat_trigger.py

@@ -4,7 +4,9 @@ from asyncio import StreamReader
 from typing import TYPE_CHECKING, Any, Callable, Coroutine
 
 from zrb.builtin.llm.chat_completion import get_chat_completer
+from zrb.config.llm_config import llm_config
 from zrb.context.any_context import AnyContext
+from zrb.util.git import get_current_branch
 from zrb.util.run import run_async
 
 if TYPE_CHECKING:
@@ -27,10 +29,20 @@ class LLMChatTrigger:
             self._triggers.append(single_trigger)
 
     async def wait(
-        self, reader: "PromptSession[Any] | StreamReader", ctx: AnyContext
+        self,
+        ctx: AnyContext,
+        reader: "PromptSession[Any] | StreamReader",
+        current_session_name: str | None,
+        is_first_time: bool,
     ) -> str:
         trigger_tasks = [
-            asyncio.create_task(run_async(self._read_next_line(reader, ctx)))
+            asyncio.create_task(
+                run_async(
+                    self._read_next_line(
+                        ctx, reader, current_session_name, is_first_time
+                    )
+                )
+            )
         ] + [asyncio.create_task(run_async(trigger(ctx))) for trigger in self._triggers]
         final_result: str = ""
         try:
@@ -47,22 +59,33 @@ class LLMChatTrigger:
         except asyncio.CancelledError:
             ctx.print("Task cancelled.", plain=True)
             final_result = "/bye"
+            for task in trigger_tasks:
+                task.cancel()
         except KeyboardInterrupt:
             ctx.print("KeyboardInterrupt detected. Exiting...", plain=True)
             final_result = "/bye"
+            for task in trigger_tasks:
+                task.cancel()
         return final_result
 
     async def _read_next_line(
-        self, reader: "PromptSession[Any] | StreamReader", ctx: AnyContext
+        self,
+        ctx: AnyContext,
+        reader: "PromptSession[Any] | StreamReader",
+        current_session_name: str | None,
+        is_first_time: bool,
     ) -> str:
         """Reads one line of input using the provided reader."""
         from prompt_toolkit import PromptSession
 
         try:
             if isinstance(reader, PromptSession):
-                bottom_toolbar = f"📌 Current directory: {os.getcwd()}"
+                bottom_toolbar = await self._get_bottom_toolbar(
+                    ctx, current_session_name, is_first_time
+                )
                 return await reader.prompt_async(
-                    completer=get_chat_completer(), bottom_toolbar=bottom_toolbar
+                    completer=get_chat_completer(),
+                    bottom_toolbar=bottom_toolbar,
                 )
             line_bytes = await reader.readline()
             if not line_bytes:
@@ -74,5 +97,69 @@ class LLMChatTrigger:
             ctx.print("KeyboardInterrupt detected. Exiting...", plain=True)
             return "/bye"
 
+    async def _get_bottom_toolbar(
+        self, ctx: AnyContext, current_session_name: str | None, is_first_time: bool
+    ) -> str:
+        import shutil
+
+        terminal_width = shutil.get_terminal_size().columns
+        previous_session_name = self._get_previous_session_name(
+            ctx, current_session_name, is_first_time
+        )
+        current_branch = await self._get_current_branch()
+        current_model = self._get_current_model(ctx)
+        left_text = f"📌 {os.getcwd()} ({current_branch}) | 🧠 {current_model}"
+        right_text = f"📚 Previous Session: {previous_session_name}"
+        padding = (
+            terminal_width
+            - self._get_display_width(left_text)
+            - self._get_display_width(right_text)
+            - 1
+        )
+        if padding > 0:
+            return f"{left_text}{' ' * padding}{right_text}"
+        return f"{left_text} {right_text}"
+
+    def _get_display_width(self, text: str) -> int:
+        import unicodedata
+
+        width = 0
+        for char in text:
+            eaw = unicodedata.east_asian_width(char)
+            if eaw in ("F", "W"):  # Fullwidth or Wide
+                width += 2
+            elif eaw == "A":  # Ambiguous
+                width += 1  # Usually 1 in non-East Asian contexts
+            else:  # Narrow, Halfwidth, Neutral
+                width += 1
+        return width
+
+    def _get_current_model(self, ctx: AnyContext) -> str:
+        if "model" in ctx.input and ctx.input.model:
+            return ctx.input.model
+        return str(llm_config.default_model_name)
+
+    def _get_previous_session_name(
+        self, ctx: AnyContext, current_session_name: str | None, is_first_time: bool
+    ) -> str:
+        if is_first_time:
+            start_new: bool = ctx.input.start_new
+            if (
+                not start_new
+                and "previous_session" in ctx.input
+                and ctx.input.previous_session is not None
+            ):
+                return ctx.input.previous_session
+            return "<No Session>"
+        if not current_session_name:
+            return "<No Session>"
+        return current_session_name
+
+    async def _get_current_branch(self) -> str:
+        try:
+            return await get_current_branch(os.getcwd(), print_method=lambda x: x)
+        except Exception:
+            return "<Not a git repo>"
+
 
 llm_chat_trigger = LLMChatTrigger()