zrb 1.5.9__tar.gz → 1.5.10__tar.gz

{zrb-1.5.9 → zrb-1.5.10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: zrb
-Version: 1.5.9
+Version: 1.5.10
 Summary: Your Automation Powerhouse
 Home-page: https://github.com/state-alchemists/zrb
 License: AGPL-3.0-or-later

{zrb-1.5.9 → zrb-1.5.10}/pyproject.toml

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

{zrb-1.5.9 → zrb-1.5.10}/src/zrb/builtin/llm/tool/file.py

@@ -132,9 +132,7 @@ def list_files(
                     all_files.append(full_path)
         # Return paths relative to the original path requested
         try:
-            rel_files = [
-                os.path.relpath(f, os.path.dirname(abs_path)) for f in all_files
-            ]
+            rel_files = [os.path.relpath(f, abs_path) for f in all_files]
             return json.dumps({"files": sorted(rel_files)})
         except (
             ValueError

{zrb-1.5.9 → zrb-1.5.10}/src/zrb/llm_config.py

@@ -5,62 +5,45 @@ from pydantic_ai.models.openai import OpenAIModel
 from pydantic_ai.providers import Provider
 from pydantic_ai.providers.openai import OpenAIProvider
 
+from zrb.util.string.conversion import to_boolean
+
 DEFAULT_SYSTEM_PROMPT = """
-You are a highly capable AI assistant with access to tools. Your primary goal is to
-provide accurate, reliable, and helpful responses.
-
-Key Instructions:
-1.  **Prioritize Tool Use:** Always attempt to use available tools to find
-    information or perform actions before asking the user.
-2.  **Correct Tool Invocation:** Use tools precisely as defined. Provide arguments
-    in valid JSON where required. Do not pass arguments to tools that don't accept
-    them. Handle tool errors gracefully and retry or adapt your strategy if necessary.
-3.  **Accuracy is Paramount:** Ensure all information, code, or outputs provided are
-    correct and reliable. Verify facts and generate executable code when requested.
-4.  **Clarity and Conciseness:** Respond clearly and directly to the user's query
-    after gathering the necessary information. Avoid unnecessary conversation.
-5.  **Context Awareness:** Understand the user's request fully to provide the most
-    relevant and effective assistance.
+You have access to tools.
+Your goal is to complete the user's task efficiently.
+Analyze the request and use the available tools proactively to achieve the goal.
+Infer parameters and actions from the context.
+Do not ask for confirmation unless strictly necessary due to ambiguity or
+missing critical information.
+Apply relevant domain knowledge and best practices.
+Respond directly and concisely upon task completion or when clarification is essential.
 """.strip()
 
 DEFAULT_PERSONA = """
 You are an expert in various fields including technology, science, history, and more.
 """.strip()
 
+# Concise summarization focused on preserving critical context for continuity.
 DEFAULT_SUMMARIZATION_PROMPT = """
-You are a summarization assistant. Your task is to synthesize the provided 
-conversation history and the existing context (which might contain a
-previous 'history_summary') into a comprehensive, updated summary
-Carefully review the '# Current Context' which includes any previous summary
-('history_summary').
-Then, review the '# Conversation History to Summarize'.
-Combine the information from both the existing context/summary and the new
-history. Create a single, coherent summary that captures ALL essential
-information, including:
-- Key decisions made
-- Actions taken (including tool usage and their results)
-- Important facts or data points mentioned
-- Outcomes of discussions or actions
-- Any unresolved questions or pending items
-The goal is to provide a complete yet concise background so that the main
-assistant can seamlessly continue the conversation without losing critical
-context from the summarized parts.
-Output *only* the updated summary text."
+You are a summarization assistant. Create an updated, concise summary integrating
+the previous summary (if any) with the new conversation history.
+Your primary goal is to preserve ALL critical context needed for the main assistant
+to continue the task effectively. This includes key facts, decisions, tool usage
+results, and essential background. Do not omit details that would force the main
+assistant to re-gather information.
+Output *only* the updated summary text.
 """.strip()
 
 DEFAULT_CONTEXT_ENRICHMENT_PROMPT = """
 You are an information extraction assistant.
-Analyze the conversation history and current context to extract key facts such as:
-  - user_name
-  - user_roles
-  - preferences
-  - goals
-  - etc
-Return only a JSON object containing a single key "response",
-whose value is another JSON object with these details.
+Analyze the conversation history and current context to extract key facts like
+user_name, user_roles, preferences, goals, etc.
+Return only a JSON object containing a single key "response", whose value is
+another JSON object with these details.
 If nothing is found, output {"response": {}}.
 """.strip()
 
+DEFAULT_SPECIAL_INSTRUCTION_PROMPT = ""  # Default to empty
+
 
 class LLMConfig:
 
@@ -71,6 +54,7 @@ class LLMConfig:
         default_api_key: str | None = None,
         default_persona: str | None = None,
         default_system_prompt: str | None = None,
+        default_special_instruction_prompt: str | None = None,
         default_summarization_prompt: str | None = None,
         default_context_enrichment_prompt: str | None = None,
         default_summarize_history: bool | None = None,
@@ -102,6 +86,11 @@ class LLMConfig:
             if default_persona is not None
             else os.getenv("ZRB_LLM_PERSONA", None)
         )
+        self._default_special_instruction_prompt = (
+            default_special_instruction_prompt
+            if default_special_instruction_prompt is not None
+            else os.getenv("ZRB_LLM_SPECIAL_INSTRUCTION_PROMPT", None)
+        )
         self._default_summarization_prompt = (
             default_summarization_prompt
             if default_summarization_prompt is not None
@@ -125,7 +114,7 @@ class LLMConfig:
         self._default_enrich_context = (
             default_enrich_context
             if default_enrich_context is not None
-            else os.getenv("ZRB_LLM_ENRICH_CONTEXT", "false").lower() == "true"
+            else to_boolean(os.getenv("ZRB_LLM_ENRICH_CONTEXT", "0"))
         )
         self._default_provider = None
         self._default_model = None
@@ -145,17 +134,23 @@ class LLMConfig:
         )
 
     def get_default_system_prompt(self) -> str:
-        system_prompt = (
+        return (
             DEFAULT_SYSTEM_PROMPT
             if self._default_system_prompt is None
             else self._default_system_prompt
         )
-        persona = (
+
+    def get_default_persona(self) -> str:
+        return (
             DEFAULT_PERSONA if self._default_persona is None else self._default_persona
         )
-        if persona is not None:
-            return f"{persona}\n{system_prompt}"
-        return system_prompt
+
+    def get_default_special_instruction_prompt(self) -> str:
+        return (
+            DEFAULT_SPECIAL_INSTRUCTION_PROMPT
+            if self._default_special_instruction_prompt is None
+            else self._default_special_instruction_prompt
+        )
 
     def get_default_summarization_prompt(self) -> str:
         return (
@@ -197,6 +192,9 @@ class LLMConfig:
     def set_default_system_prompt(self, system_prompt: str):
         self._default_system_prompt = system_prompt
 
+    def set_default_special_instruction_prompt(self, special_instruction_prompt: str):
+        self._default_special_instruction_prompt = special_instruction_prompt
+
     def set_default_summarization_prompt(self, summarization_prompt: str):
         self._default_summarization_prompt = summarization_prompt
 

{zrb-1.5.9 → zrb-1.5.10}/src/zrb/task/base/lifecycle.py

@@ -77,7 +77,7 @@ async def run_task_async(
     fill_shared_context_envs(session.shared_ctx)  # Inject OS env vars
 
     # Start the execution chain from the root tasks
-    result = await run_async(execute_root_tasks(task, session))
+    result = await task.exec_root_tasks(session)
     return result
 
 

{zrb-1.5.9 → zrb-1.5.10}/src/zrb/task/base_task.py

@@ -194,6 +194,22 @@ class BaseTask(AnyTask):
     def run(
         self, session: AnySession | None = None, str_kwargs: dict[str, str] = {}
     ) -> Any:
+        """
+        Synchronously runs the task and its dependencies, handling async setup and cleanup.
+
+        Uses `asyncio.run()` internally, which creates a new event loop.
+        WARNING: Do not call this method from within an already running asyncio
+        event loop, as it will raise a RuntimeError. Use `async_run` instead
+        if you are in an async context.
+
+        Args:
+            session (AnySession | None): The session to use. If None, a new one
+                might be created implicitly.
+            str_kwargs (dict[str, str]): String-based key-value arguments for inputs.
+
+        Returns:
+            Any: The final result of the main task execution.
+        """
         # Use asyncio.run() to execute the async cleanup wrapper
         return asyncio.run(run_and_cleanup(self, session, str_kwargs))
 

{zrb-1.5.9 → zrb-1.5.10}/src/zrb/task/llm/prompt.py

@@ -9,12 +9,29 @@ from zrb.task.llm.context import get_default_context  # Updated import
 from zrb.util.attr import get_attr, get_str_attr
 
 
-def get_system_prompt(
+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,
+    )
+    if persona is not None:
+        return persona
+    return default_llm_config.get_default_persona() or ""
+
+
+def get_base_system_prompt(
     ctx: AnyContext,
     system_prompt_attr: StrAttr | None,
     render_system_prompt: bool,
 ) -> str:
-    """Gets the system prompt, rendering if configured and handling defaults."""
+    """Gets the base system prompt, prioritizing task-specific, then default."""
     system_prompt = get_attr(
         ctx,
         system_prompt_attr,
@@ -23,7 +40,51 @@ def get_system_prompt(
     )
     if system_prompt is not None:
         return system_prompt
-    return default_llm_config.get_default_system_prompt()
+    return default_llm_config.get_default_system_prompt() or ""
+
+
+def get_special_instruction_prompt(
+    ctx: AnyContext,
+    special_instruction_prompt_attr: StrAttr | None,
+    render_special_instruction_prompt: bool,
+) -> str:
+    """Gets the special instruction prompt, prioritizing task-specific, then default."""
+    special_instruction = get_attr(
+        ctx,
+        special_instruction_prompt_attr,
+        None,
+        auto_render=render_special_instruction_prompt,
+    )
+    if special_instruction is not None:
+        return special_instruction
+    return default_llm_config.get_default_special_instruction_prompt() or ""
+
+
+def get_combined_system_prompt(
+    ctx: AnyContext,
+    persona_attr: StrAttr | None,
+    render_persona: bool,
+    system_prompt_attr: StrAttr | None,
+    render_system_prompt: bool,
+    special_instruction_prompt_attr: StrAttr | None,
+    render_special_instruction_prompt: bool,
+) -> str:
+    """Combines persona, base system prompt, and special instructions."""
+    persona = get_persona(ctx, persona_attr, render_persona)
+    base_system_prompt = get_base_system_prompt(
+        ctx, system_prompt_attr, render_system_prompt
+    )
+    special_instruction = get_special_instruction_prompt(
+        ctx, special_instruction_prompt_attr, render_special_instruction_prompt
+    )
+    parts = []
+    if persona:
+        parts.append(persona)
+    if base_system_prompt:
+        parts.append(base_system_prompt)
+    if special_instruction:
+        parts.append(special_instruction)
+    return "\n\n".join(parts).strip()
 
 
 def get_user_message(

{zrb-1.5.9 → zrb-1.5.10}/src/zrb/task/llm_task.py

@@ -32,9 +32,9 @@ from zrb.task.llm.history import (
 from zrb.task.llm.history_summarization import maybe_summarize_history
 from zrb.task.llm.prompt import (
     build_user_prompt,
+    get_combined_system_prompt,
     get_context_enrichment_prompt,
     get_summarization_prompt,
-    get_system_prompt,
 )
 from zrb.util.cli.style import stylize_faint
 from zrb.xcom.xcom import Xcom
@@ -64,12 +64,16 @@ class LLMTask(BaseTask):
             ModelSettings | Callable[[AnySharedContext], ModelSettings] | None
         ) = None,
         agent: Agent | Callable[[AnySharedContext], Agent] | None = None,
+        persona: StrAttr | None = None,
+        render_persona: bool = True,
         system_prompt: StrAttr | None = None,
         render_system_prompt: bool = True,
+        special_instruction_prompt: StrAttr | None = None,
+        render_special_instruction_prompt: bool = True,
         message: StrAttr | None = None,
         summarization_prompt: StrAttr | None = None,
         render_summarization_prompt: bool = True,
-        enrich_context: BoolAttr | None = None,  # Default to None
+        enrich_context: BoolAttr | None = None,
         render_enrich_context: bool = True,
         context_enrichment_prompt: StrAttr | None = None,
         render_context_enrichment_prompt: bool = True,
@@ -80,28 +84,23 @@ class LLMTask(BaseTask):
             list[MCPServer] | Callable[[AnySharedContext], list[MCPServer]]
         ) = [],
         conversation_history: (
-            ConversationHistoryData  # Use the new BaseModel
-            | Callable[
-                [AnySharedContext], ConversationHistoryData | dict | list
-            ]  # Allow returning raw dict/list too
-            | dict  # Allow raw dict
-            | list  # Allow raw list (old format)
-        ) = ConversationHistoryData(),  # Default to an empty model instance
+            ConversationHistoryData
+            | Callable[[AnySharedContext], ConversationHistoryData | dict | list]
+            | dict
+            | list
+        ) = ConversationHistoryData(),
         conversation_history_reader: (
             Callable[[AnySharedContext], ConversationHistoryData | dict | list | None]
             | None
-            # Allow returning raw dict/list or None
         ) = None,
         conversation_history_writer: (
-            Callable[[AnySharedContext, ConversationHistoryData], None]
-            | None
-            # Writer expects the model instance
+            Callable[[AnySharedContext, ConversationHistoryData], None] | None
         ) = None,
         conversation_history_file: StrAttr | None = None,
         render_history_file: bool = True,
-        summarize_history: BoolAttr | None = None,  # Default to None
+        summarize_history: BoolAttr | None = None,
         render_summarize_history: bool = True,
-        history_summarization_threshold: IntAttr | None = None,  # Default to None
+        history_summarization_threshold: IntAttr | None = None,
         render_history_summarization_threshold: bool = True,
         execute_condition: bool | str | Callable[[AnySharedContext], bool] = True,
         retries: int = 2,
@@ -149,8 +148,12 @@ class LLMTask(BaseTask):
         self._render_model_api_key = render_model_api_key
         self._model_settings = model_settings
         self._agent = agent
+        self._persona = persona
+        self._render_persona = render_persona
         self._system_prompt = system_prompt
         self._render_system_prompt = render_system_prompt
+        self._special_instruction_prompt = special_instruction_prompt
+        self._render_special_instruction_prompt = render_special_instruction_prompt
         self._message = message
         self._summarization_prompt = summarization_prompt
         self._render_summarization_prompt = render_summarization_prompt
@@ -213,10 +216,15 @@ class LLMTask(BaseTask):
             summarization_prompt_attr=self._summarization_prompt,
             render_summarization_prompt=self._render_summarization_prompt,
         )
-        system_prompt = get_system_prompt(
+        # Get the combined system prompt using the new getter
+        system_prompt = get_combined_system_prompt(
             ctx=ctx,
+            persona_attr=self._persona,
+            render_persona=self._render_persona,
             system_prompt_attr=self._system_prompt,
             render_system_prompt=self._render_system_prompt,
+            special_instruction_prompt_attr=self._special_instruction_prompt,
+            render_special_instruction_prompt=self._render_special_instruction_prompt,
         )
         # 1. Prepare initial state (read history, get initial context)
         history_list, conversation_context = await prepare_initial_state(

{zrb-1.5.9 → zrb-1.5.10}/src/zrb/task/scheduler.py

@@ -12,7 +12,6 @@ from zrb.task.any_task import AnyTask
 from zrb.task.base_trigger import BaseTrigger
 from zrb.util.attr import get_str_attr
 from zrb.util.cron import match_cron
-from zrb.xcom.xcom import Xcom
 
 
 class Scheduler(BaseTrigger):
@@ -77,6 +76,6 @@ class Scheduler(BaseTrigger):
             ctx.print(f"Current time: {now}")
             if match_cron(cron_pattern, now):
                 ctx.print(f"Matching {now} with pattern: {cron_pattern}")
-                xcom: Xcom = ctx.xcom[self.queue_name]
+                xcom = self.get_exchange_xcom(ctx.session)
                 xcom.push(now)
             await asyncio.sleep(60)