zrb 1.0.0a1__py3-none-any.whl → 1.0.0a3__py3-none-any.whl

zrb/session_state_logger/file_session_state_logger.py

@@ -1,9 +1,8 @@
 import datetime
-import json
 import os
 
-from ..session_state_log.session_state_log import SessionStateLog, SessionStateLogList
-from .any_session_state_logger import AnySessionStateLogger
+from zrb.session_state_log.session_state_log import SessionStateLog, SessionStateLogList
+from zrb.session_state_logger.any_session_state_logger import AnySessionStateLogger
 
 
 class FileSessionStateLogger(AnySessionStateLogger):
@@ -12,21 +11,24 @@ class FileSessionStateLogger(AnySessionStateLogger):
         self._session_log_dir = session_log_dir
 
     def write(self, session_log: SessionStateLog):
-        session_file_path = self._get_session_file_path(session_log["name"])
+        session_file_path = self._get_session_file_path(session_log.name)
+        session_dir_path = os.path.dirname(session_file_path)
+        if not os.path.isdir(session_dir_path):
+            os.makedirs(session_dir_path, exist_ok=True)
         with open(session_file_path, "w") as f:
-            f.write(json.dumps(session_log))
-        start_time = self._get_start_time(session_log)
-        if start_time is None:
+            f.write(session_log.model_dump_json())
+        start_time = session_log.start_time
+        if start_time == "":
             return
-        timeline_dir_path = self._get_timeline_dir_path(session_log, start_time)
+        timeline_dir_path = self._get_timeline_dir_path(session_log)
         os.makedirs(timeline_dir_path, exist_ok=True)
-        with open(os.path.join(timeline_dir_path, session_log["name"]), "w"):
+        with open(os.path.join(timeline_dir_path, session_log.name), "w"):
             pass
 
     def read(self, session_name: str) -> SessionStateLog:
         session_file_path = self._get_session_file_path(session_name)
         with open(session_file_path, "r") as f:
-            return json.loads(f.read())
+            return SessionStateLog.model_validate_json(f.read())
 
     def list(
         self,
@@ -59,21 +61,20 @@ class FileSessionStateLogger(AnySessionStateLogger):
         paginated_sessions = matching_sessions[start_index:end_index]
         # Extract session logs from the sorted list of tuples
         data = [session_log for _, session_log in paginated_sessions]
-        return {"total": total, "data": data}
+        return SessionStateLogList(total=total, data=data)
 
     def _get_session_file_path(self, session_name: str) -> str:
         return os.path.join(self._session_log_dir, f"{session_name}.json")
 
-    def _get_timeline_dir_path(
-        self, session_log: SessionStateLog, start_time: datetime.datetime
-    ) -> str:
+    def _get_timeline_dir_path(self, session_log: SessionStateLog) -> str:
+        start_time = self._get_start_time(session_log)
         year = start_time.year
         month = start_time.month
         day = start_time.day
         hour = start_time.hour
         minute = start_time.minute
         second = start_time.second
-        paths = session_log["path"] + [
+        paths = session_log.path + [
             f"{year}",
             f"{month}",
             f"{day}",
@@ -84,15 +85,6 @@ class FileSessionStateLogger(AnySessionStateLogger):
         return os.path.join(self._session_log_dir, "_timeline", *paths)
 
     def _get_start_time(self, session_log: SessionStateLog) -> datetime.datetime:
-        result: datetime.datetime | None = None
-        for task_status in session_log["task_status"].values():
-            histories = task_status["history"]
-            if len(histories) == 0:
-                continue
-            first_history = histories[0]
-            first_time = datetime.datetime.strptime(
-                first_history["time"], "%Y-%m-%d %H:%M:%S.%f"
-            )
-            if result is None or first_time < result:
-                result = first_time
-        return result
+        return datetime.datetime.strptime(
+            session_log.start_time, "%Y-%m-%d %H:%M:%S.%f"
+        )

zrb/task/any_task.py

@@ -3,11 +3,12 @@ from __future__ import annotations  # Enables forward references
 from abc import ABC, abstractmethod
 from typing import TYPE_CHECKING, Any
 
-from ..env.any_env import AnyEnv
-from ..input.any_input import AnyInput
+from zrb.env.any_env import AnyEnv
+from zrb.input.any_input import AnyInput
 
 if TYPE_CHECKING:
-    from ..session import session
+    from zrb.context import any_context
+    from zrb.session import session
 
 
 class AnyTask(ABC):
@@ -89,6 +90,10 @@ class AnyTask(ABC):
         """
         pass
 
+    @abstractmethod
+    def get_ctx(self, session: session.AnySession) -> any_context.AnyContext:
+        pass
+
     @abstractmethod
     def run(
         self, session: session.AnySession | None = None, str_kwargs: dict[str, str] = {}

zrb/task/base_task.py

@@ -3,17 +3,17 @@ import os
 from collections.abc import Callable
 from typing import Any
 
-from ..attr.type import BoolAttr, fstring
-from ..context.any_context import AnyContext
-from ..context.shared_context import AnySharedContext, SharedContext
-from ..env.any_env import AnyEnv
-from ..input.any_input import AnyInput
-from ..session.any_session import AnySession
-from ..session.session import Session
-from ..util.attr import get_bool_attr
-from ..util.run import run_async
-from ..xcom.xcom import Xcom
-from .any_task import AnyTask
+from zrb.attr.type import BoolAttr, fstring
+from zrb.context.any_context import AnyContext
+from zrb.context.shared_context import AnySharedContext, SharedContext
+from zrb.env.any_env import AnyEnv
+from zrb.input.any_input import AnyInput
+from zrb.session.any_session import AnySession
+from zrb.session.session import Session
+from zrb.task.any_task import AnyTask
+from zrb.util.attr import get_bool_attr
+from zrb.util.run import run_async
+from zrb.xcom.xcom import Xcom
 
 
 class BaseTask(AnyTask):
@@ -24,8 +24,8 @@ class BaseTask(AnyTask):
         icon: str | None = None,
         description: str | None = None,
         cli_only: bool = False,
-        input: list[AnyInput] | AnyInput | None = None,
-        env: list[AnyEnv] | AnyEnv | None = None,
+        input: list[AnyInput | None] | AnyInput | None = None,
+        env: list[AnyEnv | None] | AnyEnv | None = None,
         action: fstring | Callable[[AnyContext], Any] | None = None,
         execute_condition: BoolAttr = True,
         retries: int = 2,
@@ -63,16 +63,22 @@ class BaseTask(AnyTask):
         return f"<{self.__class__.__name__} name={self._name}>"
 
     def __rshift__(self, other: AnyTask | list[AnyTask]) -> AnyTask:
-        if isinstance(other, AnyTask):
-            other.append_upstreams(self)
-        elif isinstance(other, list):
-            for task in other:
-                task.append_upstreams(self)
-        return other
+        try:
+            if isinstance(other, AnyTask):
+                other.append_upstreams(self)
+            elif isinstance(other, list):
+                for task in other:
+                    task.append_upstreams(self)
+            return other
+        except Exception as e:
+            raise ValueError(f"Invalid operation {self} >> {other}: {e}")
 
     def __lshift__(self, other: AnyTask | list[AnyTask]) -> AnyTask:
-        self.append_upstreams(other)
-        return self
+        try:
+            self.append_upstreams(other)
+            return self
+        except Exception as e:
+            raise ValueError(f"Invalid operation {self} << {other}: {e}")
 
     @property
     def name(self) -> str:
@@ -103,7 +109,7 @@ class BaseTask(AnyTask):
             envs.append(self._envs)
         elif self._envs is not None:
             envs += self._envs
-        return envs
+        return [env for env in envs if env is not None]
 
     @property
     def inputs(self) -> list[AnyInput]:
@@ -112,7 +118,7 @@ class BaseTask(AnyTask):
             self.__combine_inputs(inputs, upstream.inputs)
         if self._inputs is not None:
             self.__combine_inputs(inputs, self._inputs)
-        return inputs
+        return [task_input for task_input in inputs if task_input is not None]
 
     def __combine_inputs(
         self, inputs: list[AnyInput], other_inputs: list[AnyInput] | AnyInput
@@ -120,7 +126,11 @@ class BaseTask(AnyTask):
         input_names = [task_input.name for task_input in inputs]
         if isinstance(other_inputs, AnyInput):
             other_inputs = [other_inputs]
+        elif other_inputs is None:
+            other_inputs = []
         for task_input in other_inputs:
+            if task_input is None:
+                continue
             if task_input.name not in input_names:
                 inputs.append(task_input)
 
@@ -163,6 +173,13 @@ class BaseTask(AnyTask):
         if upstream not in self._upstreams:
             self._upstreams.append(upstream)
 
+    def get_ctx(self, session: AnySession) -> AnyContext:
+        ctx = session.get_ctx(self)
+        # Enhance session ctx with current task env
+        for env in self.envs:
+            env.update_context(ctx)
+        return ctx
+
     def run(
         self, session: AnySession | None = None, str_kwargs: dict[str, str] = {}
     ) -> Any:
@@ -194,9 +211,6 @@ class BaseTask(AnyTask):
             if key not in shared_context._env
         }
         shared_context._env.update(os_env_map)
-        # Inject environment from task's envs
-        for env in self.envs:
-            env.update_shared_context(shared_context)
 
     async def exec_root_tasks(self, session: AnySession):
         session.set_main_task(self)
@@ -219,12 +233,12 @@ class BaseTask(AnyTask):
         except IndexError:
             return None
         except asyncio.CancelledError:
-            ctx = session.get_ctx(self)
+            ctx = self.get_ctx(session)
             ctx.log_info("Session terminated")
         finally:
             session.terminate()
             session.state_logger.write(session.as_state_log())
-            ctx = session.get_ctx(self)
+            ctx = self.get_ctx(session)
             ctx.log_debug(session)
 
     async def _log_session_state(self, session: AnySession):
@@ -247,7 +261,7 @@ class BaseTask(AnyTask):
         return await asyncio.gather(*next_coros)
 
     async def exec(self, session: AnySession):
-        ctx = session.get_ctx(self)
+        ctx = self.get_ctx(session)
         if not session.is_allowed_to_run(self):
             # Task is not allowed to run, skip it for now.
             # This will be triggered later
@@ -262,11 +276,11 @@ class BaseTask(AnyTask):
         await run_async(self.__exec_action_until_ready(session))
 
     def __get_execute_condition(self, session: Session) -> bool:
-        ctx = session.get_ctx(self)
+        ctx = self.get_ctx(session)
         return get_bool_attr(ctx, self._execute_condition, True, auto_render=True)
 
     async def __exec_action_until_ready(self, session: AnySession):
-        ctx = session.get_ctx(self)
+        ctx = self.get_ctx(session)
         readiness_checks = self.readiness_checks
         if len(readiness_checks) == 0:
             ctx.log_info("No readiness checks")
@@ -301,7 +315,7 @@ class BaseTask(AnyTask):
     async def __exec_monitoring(self, session: AnySession, action_coro: asyncio.Task):
         readiness_checks = self.readiness_checks
         failure_count = 0
-        ctx = session.get_ctx(self)
+        ctx = self.get_ctx(session)
         while not session.is_terminated:
             await asyncio.sleep(self._readiness_check_period)
             if failure_count < self._readiness_failure_threshold:
@@ -343,7 +357,7 @@ class BaseTask(AnyTask):
             ctx.log_info("Continue monitoring")
 
     async def __exec_action_and_retry(self, session: AnySession) -> Any:
-        ctx = session.get_ctx(self)
+        ctx = self.get_ctx(session)
         max_attempt = self._retries + 1
         ctx.set_max_attempt(max_attempt)
         for attempt in range(max_attempt):

zrb/task/base_trigger.py

@@ -2,21 +2,20 @@ import asyncio
 from collections.abc import Callable
 from typing import Any
 
+from zrb.attr.type import fstring
+from zrb.callback.any_callback import AnyCallback
 from zrb.context.any_context import AnyContext
 from zrb.context.any_shared_context import AnySharedContext
+from zrb.context.shared_context import SharedContext
+from zrb.dot_dict.dot_dict import DotDict
 from zrb.env.any_env import AnyEnv
 from zrb.input.any_input import AnyInput
+from zrb.session.any_session import AnySession
+from zrb.session.session import Session
 from zrb.task.any_task import AnyTask
-
-from ..attr.type import fstring
-from ..callback.any_callback import AnyCallback
-from ..context.shared_context import SharedContext
-from ..dot_dict.dot_dict import DotDict
-from ..session.any_session import AnySession
-from ..session.session import Session
-from ..util.cli.style import CYAN
-from ..xcom.xcom import Xcom
-from .base_task import BaseTask
+from zrb.task.base_task import BaseTask
+from zrb.util.cli.style import CYAN
+from zrb.xcom.xcom import Xcom
 
 
 class BaseTrigger(BaseTask):
@@ -28,8 +27,8 @@ class BaseTrigger(BaseTask):
         icon: str | None = None,
         description: str | None = None,
         cli_only: bool = False,
-        input: list[AnyInput] | AnyInput | None = None,
-        env: list[AnyEnv] | AnyEnv | None = None,
+        input: list[AnyInput | None] | AnyInput | None = None,
+        env: list[AnyEnv | None] | AnyEnv | None = None,
         action: fstring | Callable[[AnyContext], Any] | None = None,
         execute_condition: bool | str | Callable[[AnySharedContext], bool] = True,
         queue_name: fstring | None = None,

zrb/task/cmd_task.py

@@ -2,17 +2,17 @@ import asyncio
 import os
 import sys
 
-from ..attr.type import BoolAttr, IntAttr, StrAttr
-from ..cmd.cmd_result import CmdResult
-from ..cmd.cmd_val import AnyCmdVal, CmdVal, SingleCmdVal
-from ..config import DEFAULT_SHELL
-from ..context.any_context import AnyContext
-from ..env.any_env import AnyEnv
-from ..input.any_input import AnyInput
-from ..util.attr import get_int_attr, get_str_attr
-from ..util.cmd.remote import get_remote_cmd_script
-from .any_task import AnyTask
-from .base_task import BaseTask
+from zrb.attr.type import BoolAttr, IntAttr, StrAttr
+from zrb.cmd.cmd_result import CmdResult
+from zrb.cmd.cmd_val import AnyCmdVal, CmdVal, SingleCmdVal
+from zrb.config import DEFAULT_SHELL
+from zrb.context.any_context import AnyContext
+from zrb.env.any_env import AnyEnv
+from zrb.input.any_input import AnyInput
+from zrb.task.any_task import AnyTask
+from zrb.task.base_task import BaseTask
+from zrb.util.attr import get_int_attr, get_str_attr
+from zrb.util.cmd.remote import get_remote_cmd_script
 
 
 class CmdTask(BaseTask):
@@ -23,8 +23,8 @@ class CmdTask(BaseTask):
         icon: str | None = None,
         description: str | None = None,
         cli_only: bool = False,
-        input: list[AnyInput] | AnyInput | None = None,
-        env: list[AnyEnv] | AnyEnv | None = None,
+        input: list[AnyInput | None] | AnyInput | None = None,
+        env: list[AnyEnv | None] | AnyEnv | None = None,
         shell: StrAttr | None = None,
         auto_render_shell: bool = True,
         shell_flag: StrAttr | None = None,
@@ -105,44 +105,56 @@ class CmdTask(BaseTask):
         Returns:
             Any: The result of the action execution.
         """
+        ctx.log_info("Running script")
         cmd_script = self._get_cmd_script(ctx)
-        cwd = self._get_cwd(ctx)
+        ctx.log_debug(f"Script: {self.__get_multiline_repr(cmd_script)}")
         shell = self._get_shell(ctx)
-        shell_flag = self._get_shell_flag(ctx)
-        ctx.log_info("Running script")
         ctx.log_debug(f"Shell: {shell}")
-        ctx.log_debug(f"Script: {self.__get_multiline_repr(cmd_script)}")
+        shell_flag = self._get_shell_flag(ctx)
+        cwd = self._get_cwd(ctx)
         ctx.log_debug(f"Working directory: {cwd}")
-        cmd_process = await asyncio.create_subprocess_exec(
-            shell,
-            shell_flag,
-            cmd_script,
-            cwd=cwd,
-            stdin=sys.stdin if sys.stdin.isatty() else None,
-            stdout=asyncio.subprocess.PIPE,
-            stderr=asyncio.subprocess.PIPE,
-            env=self.__get_env_map(ctx),
-            bufsize=0,
-        )
-        stdout_task = asyncio.create_task(
-            self.__read_stream(cmd_process.stdout, ctx.print, self._max_output_line)
-        )
-        stderr_task = asyncio.create_task(
-            self.__read_stream(cmd_process.stderr, ctx.print, self._max_error_line)
-        )
-        # Wait for process to complete and gather stdout/stderr
-        return_code = await cmd_process.wait()
-        stdout = await stdout_task
-        stderr = await stderr_task
-        # Check for errors
-        if return_code != 0:
-            ctx.log_error(f"Exit status: {return_code}")
-            raise Exception(f"Process {self._name} exited ({return_code}): {stderr}")
-        return CmdResult(stdout, stderr)
+        env_map = self.__get_env_map(ctx)
+        ctx.log_debug(f"Environment map: {env_map}")
+        cmd_process = None
+        try:
+            cmd_process = await asyncio.create_subprocess_exec(
+                shell,
+                shell_flag,
+                cmd_script,
+                cwd=cwd,
+                stdin=sys.stdin if sys.stdin.isatty() else None,
+                stdout=asyncio.subprocess.PIPE,
+                stderr=asyncio.subprocess.PIPE,
+                env=env_map,
+                bufsize=0,
+            )
+            stdout_task = asyncio.create_task(
+                self.__read_stream(cmd_process.stdout, ctx.print, self._max_output_line)
+            )
+            stderr_task = asyncio.create_task(
+                self.__read_stream(cmd_process.stderr, ctx.print, self._max_error_line)
+            )
+            # Wait for process to complete and gather stdout/stderr
+            return_code = await cmd_process.wait()
+            stdout = await stdout_task
+            stderr = await stderr_task
+            # Check for errors
+            if return_code != 0:
+                ctx.log_error(f"Exit status: {return_code}")
+                raise Exception(
+                    f"Process {self._name} exited ({return_code}): {stderr}"
+                )
+            ctx.log_info(f"Exit status: {return_code}")
+            return CmdResult(stdout, stderr)
+        finally:
+            if cmd_process is not None and cmd_process.returncode is None:
+                cmd_process.terminate()
 
     def __get_env_map(self, ctx: AnyContext) -> dict[str, str]:
         envs = {key: val for key, val in ctx.env.items()}
         envs["_ZRB_SSH_PASSWORD"] = self._get_remote_password(ctx)
+        envs["PYTHONBUFFERED"] = "1"
+        return envs
 
     async def __read_stream(self, stream, log_method, max_lines):
         lines = []

zrb/task/http_check.py

@@ -3,14 +3,14 @@ from collections.abc import Callable
 
 import requests
 
-from ..attr.type import StrAttr
-from ..context.any_context import AnyContext
-from ..context.context import Context
-from ..env.any_env import AnyEnv
-from ..input.any_input import AnyInput
-from ..util.attr import get_str_attr
-from .any_task import AnyTask
-from .base_task import BaseTask
+from zrb.attr.type import StrAttr
+from zrb.context.any_context import AnyContext
+from zrb.context.context import Context
+from zrb.env.any_env import AnyEnv
+from zrb.input.any_input import AnyInput
+from zrb.task.any_task import AnyTask
+from zrb.task.base_task import BaseTask
+from zrb.util.attr import get_str_attr
 
 
 class HttpCheck(BaseTask):

zrb/task/llm_task.py

@@ -0,0 +1,160 @@
+import json
+from collections.abc import Callable
+from typing import Any
+
+from zrb.attr.type import StrAttr
+from zrb.config import LLM_MODEL, LLM_SYSTEM_PROMPT
+from zrb.context.any_context import AnyContext
+from zrb.context.any_shared_context import AnySharedContext
+from zrb.env.any_env import AnyEnv
+from zrb.input.any_input import AnyInput
+from zrb.task.any_task import AnyTask
+from zrb.task.base_task import BaseTask
+from zrb.util.attr import get_str_attr
+from zrb.util.llm.tool import callable_to_tool_schema
+
+DictList = list[dict[str, Any]]
+
+
+def scratchpad(thought: str) -> str:
+    """Use this tool to note your thought and planning"""
+    return thought
+
+
+class LLMTask(BaseTask):
+
+    def __init__(
+        self,
+        name: str,
+        color: int | None = None,
+        icon: str | None = None,
+        description: str | None = None,
+        cli_only: bool = False,
+        input: list[AnyInput | None] | AnyInput | None = None,
+        env: list[AnyEnv | None] | AnyEnv | None = None,
+        model: StrAttr | None = LLM_MODEL,
+        system_prompt: StrAttr | None = LLM_SYSTEM_PROMPT,
+        message: StrAttr | None = None,
+        tools: (
+            dict[str, Callable] | Callable[[AnySharedContext], dict[str, Callable]]
+        ) = {},
+        tool_schema: DictList | Callable[[AnySharedContext], DictList] = [],
+        history: DictList | Callable[[AnySharedContext], DictList] = [],
+        execute_condition: bool | str | Callable[[AnySharedContext], bool] = True,
+        retries: int = 2,
+        retry_period: float = 0,
+        readiness_check: list[AnyTask] | AnyTask | None = None,
+        readiness_check_delay: float = 0.5,
+        readiness_check_period: float = 5,
+        readiness_failure_threshold: int = 1,
+        readiness_timeout: int = 60,
+        monitor_readiness: bool = False,
+        upstream: list[AnyTask] | AnyTask | None = None,
+        fallback: list[AnyTask] | AnyTask | None = None,
+    ):
+        super().__init__(
+            name=name,
+            color=color,
+            icon=icon,
+            description=description,
+            cli_only=cli_only,
+            input=input,
+            env=env,
+            execute_condition=execute_condition,
+            retries=retries,
+            retry_period=retry_period,
+            readiness_check=readiness_check,
+            readiness_check_delay=readiness_check_delay,
+            readiness_check_period=readiness_check_period,
+            readiness_failure_threshold=readiness_failure_threshold,
+            readiness_timeout=readiness_timeout,
+            monitor_readiness=monitor_readiness,
+            upstream=upstream,
+            fallback=fallback,
+        )
+        self._model = model
+        self._system_prompt = system_prompt
+        self._message = message
+        self._tools = tools
+        self._tool_schema = tool_schema
+        self._history = history
+
+    async def _exec_action(self, ctx: AnyContext) -> Any:
+        from litellm import completion
+
+        system_prompt = self._get_system_prompt(ctx)
+        ctx.log_debug("SYSTEM PROMPT", system_prompt)
+        history = self._get_history(ctx)
+        ctx.log_debug("HISTORY PROMPT", history)
+        user_message = self._get_message(ctx)
+        ctx.log_debug("USER MESSAGE", user_message)
+        messages = (
+            [{"role": "system", "content": system_prompt}]
+            + history
+            + [{"role": "user", "content": user_message}]
+        )
+        available_tools = self._get_tools(ctx)
+        available_tools["scratchpad"] = scratchpad
+        tool_schema = self._get_tool_schema(ctx)
+        for tool_name, tool in available_tools.items():
+            matched_tool_schema = [
+                schema
+                for schema in tool_schema
+                if "function" in schema
+                and "name" in schema["function"]
+                and schema["function"]["name"] == tool_name
+            ]
+            if len(matched_tool_schema) == 0:
+                tool_schema.append(callable_to_tool_schema(tool))
+        ctx.log_debug("TOOL SCHEMA", tool_schema)
+        while True:
+            response = completion(
+                model=self._get_model(ctx), messages=messages, tools=tool_schema
+            )
+            response_message = response.choices[0].message
+            ctx.print(response_message)
+            messages.append(response_message)
+            tool_calls = response_message.tool_calls
+            if tool_calls:
+                # noqa Reference: https://docs.litellm.ai/docs/completion/function_call#full-code---parallel-function-calling-with-gpt-35-turbo-1106
+                for tool_call in tool_calls:
+                    function_name = tool_call.function.name
+                    function_to_call = available_tools[function_name]
+                    function_kwargs = json.loads(tool_call.function.arguments)
+                    function_response = function_to_call(**function_kwargs)
+                    tool_call_message = {
+                        "tool_call_id": tool_call.id,
+                        "role": "tool",
+                        "name": function_name,
+                        "content": function_response,
+                    }
+                    ctx.print(tool_call_message)
+                    messages.append(tool_call_message)
+                continue
+            return response_message.content
+
+    def _get_model(self, ctx: AnyContext) -> str:
+        return get_str_attr(ctx, self._model, "ollama_chat/llama3.1", auto_render=True)
+
+    def _get_system_prompt(self, ctx: AnyContext) -> str:
+        return get_str_attr(
+            ctx, self._system_prompt, "You are a helpful assistant", auto_render=True
+        )
+
+    def _get_message(self, ctx: AnyContext) -> str:
+        return get_str_attr(ctx, self._message, "How are you?", auto_render=True)
+
+    def _get_tools(self, ctx: AnyContext) -> dict[str, Callable]:
+        if callable(self._tools):
+            return self._tools(ctx)
+        return self._tools
+
+    def _get_tool_schema(self, ctx: AnyContext) -> DictList:
+        if callable(self._tool_schema):
+            return self._tool_schema(ctx)
+        return self._tool_schema
+
+    def _get_history(self, ctx: AnyContext) -> DictList:
+        if callable(self._history):
+            return self._history(ctx)
+        return self._history