zrb 1.8.15__py3-none-any.whl → 1.9.1__py3-none-any.whl

zrb/task/llm/print_node.py

@@ -19,11 +19,11 @@ async def print_node(print_func: Callable, agent_run: Any, node: Any):
 
     if Agent.is_user_prompt_node(node):
         # A user prompt node => The user has provided input
-        print_func(stylize_faint(f">> UserPromptNode: {node.user_prompt}"))
+        print_func(stylize_faint(f"    >> UserPromptNode: {node.user_prompt}"))
     elif Agent.is_model_request_node(node):
         # A model request node => We can stream tokens from the model's request
         print_func(
-            stylize_faint(">> ModelRequestNode: streaming partial request tokens")
+            stylize_faint("    >> ModelRequestNode: streaming partial request tokens")
         )
         async with node.stream(agent_run.ctx) as request_stream:
             is_streaming = False
@@ -33,7 +33,7 @@ async def print_node(print_func: Callable, agent_run: Any, node: Any):
                         print_func("")
                     print_func(
                         stylize_faint(
-                            f"[Request] Starting part {event.index}: {event.part!r}"
+                            f"    [Request] Starting part {event.index}: {event.part!r}"
                         ),
                     )
                     is_streaming = False
@@ -53,7 +53,7 @@ async def print_node(print_func: Callable, agent_run: Any, node: Any):
                     if is_streaming:
                         print_func("")
                     print_func(
-                        stylize_faint(f"[Result] tool_name={event.tool_name}"),
+                        stylize_faint(f"    [Result] tool_name={event.tool_name}"),
                     )
                     is_streaming = False
             if is_streaming:
@@ -61,7 +61,9 @@ async def print_node(print_func: Callable, agent_run: Any, node: Any):
     elif Agent.is_call_tools_node(node):
         # A handle-response node => The model returned some data, potentially calls a tool
         print_func(
-            stylize_faint(">> CallToolsNode: streaming partial response & tool usage")
+            stylize_faint(
+                "    >> CallToolsNode: streaming partial response & tool usage"
+            )
         )
         async with node.stream(agent_run.ctx) as handle_stream:
             async for event in handle_stream:
@@ -82,16 +84,16 @@ async def print_node(print_func: Callable, agent_run: Any, node: Any):
                         del event.part.args["_dummy"]
                     print_func(
                         stylize_faint(
-                            f"[Tools] The LLM calls tool={event.part.tool_name!r} with args={event.part.args} (tool_call_id={event.part.tool_call_id!r})"  # noqa
+                            f"    [Tools] The LLM calls tool={event.part.tool_name!r} with args={event.part.args} (tool_call_id={event.part.tool_call_id!r})"  # noqa
                         )
                     )
                 elif isinstance(event, FunctionToolResultEvent):
                     print_func(
                         stylize_faint(
-                            f"[Tools] Tool call {event.tool_call_id!r} returned => {event.result.content}"  # noqa
+                            f"    [Tools] Tool call {event.tool_call_id!r} returned => {event.result.content}"  # noqa
                         )
                     )
     elif Agent.is_end_node(node):
         # Once an End node is reached, the agent run is complete
-        print_func(stylize_faint("[End of Response]"))
+        print_func(stylize_faint("    [End of Response]"))
         # print_func(stylize_faint(f"{agent_run.result.data}"))

zrb/task/llm/prompt.py

@@ -7,14 +7,13 @@ from zrb.util.attr import get_attr, get_str_attr
 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,
+        auto_render=False,
     )
     if persona is not None:
         return persona
@@ -24,14 +23,13 @@ def get_persona(
 def get_base_system_prompt(
     ctx: AnyContext,
     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,
+        auto_render=False,
     )
     if system_prompt is not None:
         return system_prompt
@@ -41,14 +39,13 @@ def get_base_system_prompt(
 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,
+        auto_render=False,
     )
     if special_instruction is not None:
         return special_instruction
@@ -58,19 +55,14 @@ def get_special_instruction_prompt(
 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
-    )
+    persona = get_persona(ctx, persona_attr)
+    base_system_prompt = get_base_system_prompt(ctx, system_prompt_attr)
     special_instruction = get_special_instruction_prompt(
-        ctx, special_instruction_prompt_attr, render_special_instruction_prompt
+        ctx, special_instruction_prompt_attr
     )
     parts = []
     if persona:
@@ -85,22 +77,24 @@ def get_combined_system_prompt(
 def get_user_message(
     ctx: AnyContext,
     message_attr: StrAttr | None,
+    render_user_message: bool,
 ) -> str:
     """Gets the user message, rendering and providing a default."""
-    return get_str_attr(ctx, message_attr, "How are you?", auto_render=True)
+    return get_str_attr(
+        ctx, message_attr, "How are you?", auto_render=render_user_message
+    )
 
 
 def get_summarization_prompt(
     ctx: AnyContext,
     summarization_prompt_attr: StrAttr | None,
-    render_summarization_prompt: bool,
 ) -> str:
     """Gets the summarization prompt, rendering if configured and handling defaults."""
     summarization_prompt = get_attr(
         ctx,
         summarization_prompt_attr,
         None,
-        auto_render=render_summarization_prompt,
+        auto_render=False,
     )
     if summarization_prompt is not None:
         return summarization_prompt
@@ -110,14 +104,13 @@ def get_summarization_prompt(
 def get_context_enrichment_prompt(
     ctx: AnyContext,
     context_enrichment_prompt_attr: StrAttr | None,
-    render_context_enrichment_prompt: bool,
 ) -> str:
     """Gets the context enrichment prompt, rendering if configured and handling defaults."""
     context_enrichment_prompt = get_attr(
         ctx,
         context_enrichment_prompt_attr,
         None,
-        auto_render=render_context_enrichment_prompt,
+        auto_render=False,
     )
     if context_enrichment_prompt is not None:
         return context_enrichment_prompt

zrb/task/llm/tool_wrapper.py

@@ -3,7 +3,7 @@ import inspect
 import traceback
 import typing
 from collections.abc import Callable
-from typing import TYPE_CHECKING, Any
+from typing import TYPE_CHECKING
 
 from zrb.context.any_context import AnyContext
 from zrb.task.llm.error import ToolExecutionError
@@ -11,11 +11,9 @@ from zrb.util.run import run_async
 
 if TYPE_CHECKING:
     from pydantic_ai import Tool
-else:
-    Tool = Any
 
 
-def wrap_tool(func: Callable, ctx: AnyContext) -> Tool:
+def wrap_tool(func: Callable, ctx: AnyContext) -> "Tool":
     """Wraps a tool function to handle exceptions and context propagation."""
     from pydantic_ai import RunContext, Tool
 

zrb/task/llm_task.py

@@ -2,18 +2,6 @@ import json
 from collections.abc import Callable
 from typing import TYPE_CHECKING, Any
 
-if TYPE_CHECKING:
-    from pydantic_ai import Agent, Tool
-    from pydantic_ai.mcp import MCPServer
-    from pydantic_ai.models import Model
-    from pydantic_ai.settings import ModelSettings
-else:
-    Agent = Any
-    Tool = Any
-    MCPServer = Any
-    Model = Any
-    ModelSettings = Any
-
 from zrb.attr.type import BoolAttr, IntAttr, StrAttr, fstring
 from zrb.context.any_context import AnyContext
 from zrb.context.any_shared_context import AnySharedContext
@@ -27,7 +15,7 @@ from zrb.task.llm.config import (
     get_model,
     get_model_settings,
 )
-from zrb.task.llm.context import extract_default_context, get_conversation_context
+from zrb.task.llm.context import extract_default_context
 from zrb.task.llm.context_enrichment import maybe_enrich_context
 from zrb.task.llm.history import (
     ConversationHistoryData,
@@ -46,6 +34,11 @@ from zrb.util.cli.style import stylize_faint
 from zrb.xcom.xcom import Xcom
 
 if TYPE_CHECKING:
+    from pydantic_ai import Agent, Tool
+    from pydantic_ai.mcp import MCPServer
+    from pydantic_ai.models import Model
+    from pydantic_ai.settings import ModelSettings
+
     ToolOrCallable = Tool | Callable
 else:
     ToolOrCallable = Any
@@ -62,7 +55,7 @@ class LLMTask(BaseTask):
         input: list[AnyInput | None] | AnyInput | None = None,
         env: list[AnyEnv | None] | AnyEnv | None = None,
         model: (
-            Callable[[AnySharedContext], Model | str | fstring] | Model | None
+            "Callable[[AnySharedContext], Model | str | fstring] | Model | None"
         ) = None,
         render_model: bool = True,
         model_base_url: StrAttr | None = None,
@@ -70,24 +63,20 @@ class LLMTask(BaseTask):
         model_api_key: StrAttr | None = None,
         render_model_api_key: bool = True,
         model_settings: (
-            ModelSettings | Callable[[AnySharedContext], ModelSettings] | None
+            "ModelSettings | Callable[[AnySharedContext], ModelSettings] | None"
         ) = None,
-        agent: Agent | Callable[[AnySharedContext], Agent] | 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,
+        render_message: bool = True,
         enrich_context: BoolAttr | None = None,
         render_enrich_context: bool = True,
         context_enrichment_prompt: StrAttr | None = None,
         render_context_enrichment_prompt: bool = True,
-        context_enrichment_threshold: IntAttr | None = None,
-        render_context_enrichment_threshold: bool = True,
+        context_enrichment_token_threshold: IntAttr | None = None,
+        render_context_enrichment_token_threshold: bool = True,
         tools: (
             list["ToolOrCallable"]
             | Callable[[AnySharedContext], list["ToolOrCallable"]]
@@ -112,8 +101,9 @@ class LLMTask(BaseTask):
         render_history_file: bool = True,
         summarize_history: BoolAttr | None = None,
         render_summarize_history: bool = True,
-        history_summarization_threshold: IntAttr | None = None,
-        render_history_summarization_threshold: bool = True,
+        summarization_prompt: StrAttr | None = None,
+        history_summarization_token_threshold: IntAttr | None = None,
+        render_history_summarization_token_threshold: bool = True,
         rate_limitter: LLMRateLimiter | None = None,
         execute_condition: bool | str | Callable[[AnySharedContext], bool] = True,
         retries: int = 2,
@@ -162,20 +152,19 @@ class LLMTask(BaseTask):
         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._render_message = render_message
         self._summarization_prompt = summarization_prompt
-        self._render_summarization_prompt = render_summarization_prompt
         self._should_enrich_context = enrich_context
         self._render_enrich_context = render_enrich_context
         self._context_enrichment_prompt = context_enrichment_prompt
         self._render_context_enrichment_prompt = render_context_enrichment_prompt
-        self._context_enrichment_threshold = context_enrichment_threshold
-        self._render_context_enrichment_threshold = render_context_enrichment_threshold
+        self._context_enrichment_token_threshold = context_enrichment_token_threshold
+        self._render_context_enrichment_token_threshold = (
+            render_context_enrichment_token_threshold
+        )
         self._tools = tools
         self._rate_limitter = rate_limitter
         self._additional_tools: list["ToolOrCallable"] = []
@@ -188,9 +177,11 @@ class LLMTask(BaseTask):
         self._render_history_file = render_history_file
         self._should_summarize_history = summarize_history
         self._render_summarize_history = render_summarize_history
-        self._history_summarization_threshold = history_summarization_threshold
-        self._render_history_summarization_threshold = (
-            render_history_summarization_threshold
+        self._history_summarization_token_threshold = (
+            history_summarization_token_threshold
+        )
+        self._render_history_summarization_token_threshold = (
+            render_history_summarization_token_threshold
         )
         self._max_call_iteration = max_call_iteration
         self._conversation_context = conversation_context
@@ -202,24 +193,26 @@ class LLMTask(BaseTask):
         for single_tool in tool:
             self._additional_tools.append(single_tool)
 
-    def add_mcp_server(self, *mcp_server: MCPServer):
+    def add_mcp_server(self, *mcp_server: "MCPServer"):
         self.append_mcp_server(*mcp_server)
 
-    def append_mcp_server(self, *mcp_server: MCPServer):
+    def append_mcp_server(self, *mcp_server: "MCPServer"):
         for single_mcp_server in mcp_server:
             self._additional_mcp_servers.append(single_mcp_server)
 
     def set_should_enrich_context(self, enrich_context: bool):
         self._should_enrich_context = enrich_context
 
-    def set_context_enrichment_threshold(self, enrichment_threshold: int):
-        self._context_enrichment_threshold = enrichment_threshold
+    def set_context_enrichment_token_threshold(self, enrichment_token_threshold: int):
+        self._context_enrichment_token_threshold = enrichment_token_threshold
 
     def set_should_summarize_history(self, summarize_history: bool):
         self._should_summarize_history = summarize_history
 
-    def set_history_summarization_threshold(self, summarization_threshold: int):
-        self._history_summarization_threshold = summarization_threshold
+    def set_history_summarization_token_threshold(
+        self, summarization_token_threshold: int
+    ):
+        self._history_summarization_token_threshold = summarization_token_threshold
 
     async def _exec_action(self, ctx: AnyContext) -> Any:
         # Get dependent configurations first
@@ -236,77 +229,75 @@ class LLMTask(BaseTask):
         context_enrichment_prompt = get_context_enrichment_prompt(
             ctx=ctx,
             context_enrichment_prompt_attr=self._context_enrichment_prompt,
-            render_context_enrichment_prompt=self._render_context_enrichment_prompt,
         )
         summarization_prompt = get_summarization_prompt(
             ctx=ctx,
             summarization_prompt_attr=self._summarization_prompt,
-            render_summarization_prompt=self._render_summarization_prompt,
         )
-        user_message = get_user_message(ctx, self._message)
+        user_message = get_user_message(ctx, self._message, self._render_message)
         # 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 from previous session)
-        conversation_history = await read_conversation_history(
+        history_data = 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,
         )
-        history_list = conversation_history.history
-        conversation_context = {
-            **conversation_history.context,
-            **get_conversation_context(ctx, self._conversation_context),
-        }
-        # 2. Enrich context (optional)
-        conversation_context = await maybe_enrich_context(
+        history_list = history_data.history
+        long_term_context = history_data.long_term_context
+        conversation_summary = history_data.conversation_summary
+
+        # 2. Enrich context and summarize history sequentially
+        new_long_term_context = await maybe_enrich_context(
             ctx=ctx,
             history_list=history_list,
-            conversation_context=conversation_context,
+            long_term_context=long_term_context,
             should_enrich_context_attr=self._should_enrich_context,
             render_enrich_context=self._render_enrich_context,
-            context_enrichment_threshold_attr=self._context_enrichment_threshold,
-            render_context_enrichment_threshold=self._render_context_enrichment_threshold,
+            context_enrichment_token_threshold_attr=self._context_enrichment_token_threshold,
+            render_context_enrichment_token_threshold=self._render_context_enrichment_token_threshold,
             model=model,
             model_settings=model_settings,
             context_enrichment_prompt=context_enrichment_prompt,
             rate_limitter=self._rate_limitter,
         )
-        # 3. Summarize history (optional, modifies history_list and context)
-        history_list, conversation_context = await maybe_summarize_history(
+        new_history_list, new_conversation_summary = await maybe_summarize_history(
             ctx=ctx,
             history_list=history_list,
-            conversation_context=conversation_context,
+            conversation_summary=conversation_summary,
             should_summarize_history_attr=self._should_summarize_history,
             render_summarize_history=self._render_summarize_history,
-            history_summarization_threshold_attr=self._history_summarization_threshold,
-            render_history_summarization_threshold=(
-                self._render_history_summarization_threshold
+            history_summarization_token_threshold_attr=self._history_summarization_token_threshold,
+            render_history_summarization_token_threshold=(
+                self._render_history_summarization_token_threshold
             ),
             model=model,
             model_settings=model_settings,
             summarization_prompt=summarization_prompt,
             rate_limitter=self._rate_limitter,
         )
-        # 4. Build the final user prompt and system prompt
-        final_user_prompt, default_context = extract_default_context(user_message)
-        final_system_prompt = "\n".join(
-            [
-                system_prompt,
-                "# Context",
-                json.dumps({**default_context, **conversation_context}),
-            ]
+
+        # 3. Build the final user prompt and system prompt
+        final_user_prompt, system_info = extract_default_context(user_message)
+        context_parts = [
+            f"## System Information\n{json.dumps(system_info, indent=2)}",
+        ]
+        if new_long_term_context:
+            context_parts.append(new_long_term_context)
+        if new_conversation_summary:
+            context_parts.append(new_conversation_summary)
+
+        final_system_prompt = "\n\n".join(
+            [system_prompt, "# Context", "\n\n---\n\n".join(context_parts)]
         )
-        # 5. Get the agent instance
+        # 4. Get the agent instance
         agent = get_agent(
             ctx=ctx,
             agent_attr=self._agent,
@@ -318,18 +309,24 @@ class LLMTask(BaseTask):
             mcp_servers_attr=self._mcp_servers,
             additional_mcp_servers=self._additional_mcp_servers,
         )
-        # 6. Run the agent iteration and save the results/history
+        # 5. Run the agent iteration and save the results/history
         return await self._run_agent_and_save_history(
-            ctx, agent, final_user_prompt, history_list, conversation_context
+            ctx,
+            agent,
+            final_user_prompt,
+            new_history_list,
+            new_long_term_context,
+            new_conversation_summary,
         )
 
     async def _run_agent_and_save_history(
         self,
         ctx: AnyContext,
-        agent: Agent,
+        agent: "Agent",
         user_prompt: str,
         history_list: ListOfDict,
-        conversation_context: dict[str, Any],
+        long_term_context: str,
+        conversation_summary: str,
     ) -> Any:
         """Executes the agent, processes results, and saves history."""
         try:
@@ -343,7 +340,8 @@ class LLMTask(BaseTask):
             if agent_run and agent_run.result:
                 new_history_list = json.loads(agent_run.result.all_messages_json())
                 data_to_write = ConversationHistoryData(
-                    context=conversation_context,  # Save the final context state
+                    long_term_context=long_term_context,
+                    conversation_summary=conversation_summary,
                     history=new_history_list,
                 )
                 await write_conversation_history(
@@ -358,7 +356,7 @@ class LLMTask(BaseTask):
                     ctx.xcom[xcom_usage_key] = Xcom([])
                 usage = agent_run.result.usage()
                 ctx.xcom[xcom_usage_key].push(usage)
-                ctx.print(stylize_faint(f"[Token Usage] {usage}"), plain=True)
+                ctx.print(stylize_faint(f"    Token: {usage}"), plain=True)
                 return agent_run.result.output
             else:
                 ctx.log_warning("Agent run did not produce a result.")
@@ -366,3 +364,134 @@ class LLMTask(BaseTask):
         except Exception as e:
             ctx.log_error(f"Error during agent execution or history saving: {str(e)}")
             raise  # Re-raise the exception after logging
+
+
+def llm_task(
+    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: "Callable[[AnySharedContext], Model | str | fstring] | Model | None" = None,
+    render_model: bool = True,
+    model_base_url: StrAttr | None = None,
+    render_model_base_url: bool = True,
+    model_api_key: StrAttr | None = None,
+    render_model_api_key: bool = True,
+    model_settings: "ModelSettings | Callable[[AnySharedContext], ModelSettings] | None" = None,
+    agent: "Agent | Callable[[AnySharedContext], Agent] | None" = None,
+    persona: StrAttr | None = None,
+    system_prompt: StrAttr | None = None,
+    special_instruction_prompt: StrAttr | None = None,
+    message: StrAttr | None = None,
+    render_message: bool = True,
+    enrich_context: BoolAttr | None = None,
+    render_enrich_context: bool = True,
+    context_enrichment_prompt: StrAttr | None = None,
+    render_context_enrichment_prompt: bool = True,
+    context_enrichment_token_threshold: IntAttr | None = None,
+    render_context_enrichment_token_threshold: bool = True,
+    tools: (
+        list["ToolOrCallable"] | Callable[[AnySharedContext], list["ToolOrCallable"]]
+    ) = [],
+    mcp_servers: (
+        list["MCPServer"] | Callable[[AnySharedContext], list["MCPServer"]]
+    ) = [],
+    conversation_history: (
+        ConversationHistoryData
+        | Callable[[AnySharedContext], ConversationHistoryData | dict | list]
+        | dict
+        | list
+    ) = ConversationHistoryData(),
+    conversation_history_reader: (
+        Callable[[AnySharedContext], ConversationHistoryData | dict | list | None]
+        | None
+    ) = None,
+    conversation_history_writer: (
+        Callable[[AnySharedContext, ConversationHistoryData], None] | None
+    ) = None,
+    conversation_history_file: StrAttr | None = None,
+    render_history_file: bool = True,
+    summarize_history: BoolAttr | None = None,
+    render_summarize_history: bool = True,
+    summarization_prompt: StrAttr | None = None,
+    history_summarization_token_threshold: IntAttr | None = None,
+    render_history_summarization_token_threshold: bool = True,
+    rate_limitter: LLMRateLimiter | None = None,
+    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,
+    max_call_iteration: int = 20,
+    upstream: list[AnyTask] | AnyTask | None = None,
+    fallback: list[AnyTask] | AnyTask | None = None,
+    successor: list[AnyTask] | AnyTask | None = None,
+    conversation_context: (
+        dict[str, Any] | Callable[[AnySharedContext], dict[str, Any]] | None
+    ) = None,
+) -> LLMTask:
+    """
+    Create a new LLM task.
+    """
+    return LLMTask(
+        name=name,
+        color=color,
+        icon=icon,
+        description=description,
+        cli_only=cli_only,
+        input=input,
+        env=env,
+        model=model,
+        render_model=render_model,
+        model_base_url=model_base_url,
+        render_model_base_url=render_model_base_url,
+        model_api_key=model_api_key,
+        render_model_api_key=render_model_api_key,
+        model_settings=model_settings,
+        agent=agent,
+        persona=persona,
+        system_prompt=system_prompt,
+        special_instruction_prompt=special_instruction_prompt,
+        message=message,
+        render_message=render_message,
+        enrich_context=enrich_context,
+        render_enrich_context=render_enrich_context,
+        context_enrichment_prompt=context_enrichment_prompt,
+        render_context_enrichment_prompt=render_context_enrichment_prompt,
+        context_enrichment_token_threshold=context_enrichment_token_threshold,
+        render_context_enrichment_token_threshold=render_context_enrichment_token_threshold,
+        tools=tools,
+        mcp_servers=mcp_servers,
+        conversation_history=conversation_history,
+        conversation_history_reader=conversation_history_reader,
+        conversation_history_writer=conversation_history_writer,
+        conversation_history_file=conversation_history_file,
+        render_history_file=render_history_file,
+        summarize_history=summarize_history,
+        render_summarize_history=render_summarize_history,
+        summarization_prompt=summarization_prompt,
+        history_summarization_token_threshold=history_summarization_token_threshold,
+        render_history_summarization_token_threshold=render_history_summarization_token_threshold,
+        rate_limitter=rate_limitter,
+        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,
+        max_call_iteration=max_call_iteration,
+        upstream=upstream,
+        fallback=fallback,
+        successor=successor,
+        conversation_context=conversation_context,
+    )

zrb/util/file.py

@@ -31,9 +31,10 @@ def _read_text_file_content(file_path: str) -> str:
 
 
 def _read_pdf_file_content(file_path: str) -> str:
-    from pdfplumber.pdf import PDF, open
+    import pdfplumber
+    from pdfplumber.pdf import PDF
 
-    with open(file_path) as pdf:
+    with pdfplumber.open(file_path) as pdf:
         pdf: PDF
         return "\n".join(
             page.extract_text() for page in pdf.pages if page.extract_text()

{zrb-1.8.15.dist-info → zrb-1.9.1.dist-info}/METADATA

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