zrb 1.5.7__py3-none-any.whl → 1.5.8__py3-none-any.whl

zrb/task/llm_task.py

@@ -1,7 +1,5 @@
-import inspect
 import json
 from collections.abc import Callable
-from textwrap import dedent
 from typing import Any
 
 from pydantic_ai import Agent, Tool
@@ -14,22 +12,31 @@ 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.llm_config import LLMConfig
-from zrb.llm_config import llm_config as default_llm_config
 from zrb.task.any_task import AnyTask
 from zrb.task.base_task import BaseTask
-from zrb.task.llm.agent_runner import run_agent_iteration
-from zrb.task.llm.context_enricher import EnrichmentConfig, enrich_context
-from zrb.task.llm.default_context import get_default_context
-from zrb.task.llm.history import ConversationHistoryData, ListOfDict
-from zrb.task.llm.history_summarizer import SummarizationConfig, summarize_history
-from zrb.task.llm.tool_wrapper import wrap_tool
-from zrb.util.attr import get_attr, get_bool_attr, get_int_attr, get_str_attr
-from zrb.util.file import write_file
-from zrb.util.run import run_async
+from zrb.task.llm.agent import get_agent, run_agent_iteration
+from zrb.task.llm.config import (
+    get_model,
+    get_model_settings,
+)
+from zrb.task.llm.context import get_conversation_context
+from zrb.task.llm.context_enrichment import maybe_enrich_context
+from zrb.task.llm.history import (
+    ConversationHistoryData,
+    ListOfDict,
+    prepare_initial_state,
+    write_conversation_history,
+)
+from zrb.task.llm.history_summarization import maybe_summarize_history
+from zrb.task.llm.prompt import (
+    build_user_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
 
-# ListOfDict moved to history.py
-# Removed old ConversationHistoryData type alias
 ToolOrCallable = Tool | Callable
 
 
@@ -183,323 +190,131 @@ class LLMTask(BaseTask):
         self._history_summarization_threshold = summarization_threshold
 
     async def _exec_action(self, ctx: AnyContext) -> Any:
-        history_data: ConversationHistoryData = await self._read_conversation_history(
-            ctx
-        )
-        # Extract history list and conversation context
-        history_list = history_data.history
-        conversation_context = self._get_conversation_context(ctx)
-        # Merge history context without overwriting existing keys
-        for key, value in history_data.context.items():
-            if key not in conversation_context:
-                conversation_context[key] = value
-        # Enrich context based on history (if enabled)
-        if self._get_should_enrich_context(ctx, history_list):
-            conversation_context = await enrich_context(
-                ctx=ctx,
-                config=EnrichmentConfig(
-                    model=self._get_model(ctx),
-                    settings=self._get_model_settings(ctx),
-                    prompt=self._get_context_enrichment_prompt(ctx),
-                ),
-                conversation_context=conversation_context,
-                history_list=history_list,
-            )
-        # Get history handling parameters
-        if self._get_should_summarize_history(ctx, history_list):
-            ctx.log_info("Summarize previous conversation")
-            # Summarize the part to be removed and update context
-            conversation_context = await summarize_history(
-                ctx=ctx,
-                config=SummarizationConfig(
-                    model=self._get_model(ctx),
-                    settings=self._get_model_settings(ctx),
-                    prompt=self._get_summarization_prompt(ctx),
-                ),
-                conversation_context=conversation_context,
-                history_list=history_list,  # Pass the full list for context
-            )
-            # Truncate the history list after summarization
-            history_list = []
-        # Construct user prompt
-        user_prompt = self._get_user_prompt(ctx, conversation_context)
-        # Create and run agent
-        agent = self._get_agent(ctx)
-        try:
-            agent_run = await run_agent_iteration(
-                ctx=ctx,
-                agent=agent,
-                user_prompt=user_prompt,
-                history_list=history_list,
-            )
-            if agent_run:
-                new_history_list = json.loads(agent_run.result.all_messages_json())
-                data_to_write = ConversationHistoryData(
-                    context=conversation_context,
-                    history=new_history_list,
-                )
-                await self._write_conversation_history(
-                    ctx, data_to_write
-                )  # Pass the model instance
-                return agent_run.result.data
-        except Exception as e:
-            ctx.log_error(f"Error in agent execution: {str(e)}")
-            raise
-
-    async def _write_conversation_history(
-        self, ctx: AnyContext, history_data: ConversationHistoryData
-    ):
-        # Expects the model instance
-        if self._conversation_history_writer is not None:
-            # Pass the model instance directly to the writer
-            await run_async(self._conversation_history_writer(ctx, history_data))
-        history_file = self._get_history_file(ctx)
-        if history_file != "":
-            # Use model_dump_json for serialization
-            write_file(history_file, history_data.model_dump_json(indent=2))
-
-    def _get_model_settings(self, ctx: AnyContext) -> ModelSettings | None:
-        if callable(self._model_settings):
-            return self._model_settings(ctx)
-        return self._model_settings
-
-    def _get_agent(self, ctx: AnyContext) -> Agent:
-        if isinstance(self._agent, Agent):
-            return self._agent
-        if callable(self._agent):
-            return self._agent(ctx)
-        tools_or_callables = list(
-            self._tools(ctx) if callable(self._tools) else self._tools
-        )
-        tools_or_callables.extend(self._additional_tools)
-        tools = []
-        for tool_or_callable in tools_or_callables:
-            if isinstance(tool_or_callable, Tool):
-                tools.append(tool_or_callable)
-            else:
-                # Inspect original callable for 'ctx' parameter
-                # This ctx refer to pydantic AI's ctx, not task ctx.
-                original_sig = inspect.signature(tool_or_callable)
-                takes_ctx = "ctx" in original_sig.parameters
-                wrapped_tool = wrap_tool(tool_or_callable)
-                tools.append(Tool(wrapped_tool, takes_ctx=takes_ctx))
-        mcp_servers = list(
-            self._mcp_servers(ctx) if callable(self._mcp_servers) else self._mcp_servers
-        )
-        mcp_servers.extend(self._additional_mcp_servers)
-        return Agent(
-            self._get_model(ctx),
-            system_prompt=self._get_system_prompt(ctx),
-            tools=tools,
-            mcp_servers=mcp_servers,
-            model_settings=self._get_model_settings(ctx),
-            retries=3,
-        )
-
-    def _get_model(self, ctx: AnyContext) -> str | Model | None:
-        model = get_attr(ctx, self._model, None, auto_render=self._render_model)
-        if model is None:
-            return default_llm_config.get_default_model()
-        if isinstance(model, str):
-            model_base_url = self._get_model_base_url(ctx)
-            model_api_key = self._get_model_api_key(ctx)
-            llm_config = LLMConfig(
-                default_model_name=model,
-                default_base_url=model_base_url,
-                default_api_key=model_api_key,
-            )
-            if model_base_url is None and model_api_key is None:
-                default_model_provider = default_llm_config.get_default_model_provider()
-                if default_model_provider is not None:
-                    llm_config.set_default_provider(default_model_provider)
-            return llm_config.get_default_model()
-        raise ValueError(f"Invalid model: {model}")
-
-    def _get_model_base_url(self, ctx: AnyContext) -> str | None:
-        base_url = get_attr(
-            ctx, self._model_base_url, None, auto_render=self._render_model_base_url
+        # Get dependent configurations first
+        model_settings = get_model_settings(ctx, self._model_settings)
+        model = get_model(
+            ctx=ctx,
+            model_attr=self._model,
+            render_model=self._render_model,
+            model_base_url_attr=self._model_base_url,
+            render_model_base_url=self._render_model_base_url,
+            model_api_key_attr=self._model_api_key,
+            render_model_api_key=self._render_model_api_key,
         )
-        if isinstance(base_url, str) or base_url is None:
-            return base_url
-        raise ValueError(f"Invalid model base URL: {base_url}")
-
-    def _get_model_api_key(self, ctx: AnyContext) -> str | None:
-        api_key = get_attr(
-            ctx, self._model_api_key, None, auto_render=self._render_model_api_key
+        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,
         )
-        if isinstance(api_key, str) or api_key is None:
-            return api_key
-        raise ValueError(f"Invalid model API key: {api_key}")
-
-    def _get_system_prompt(self, ctx: AnyContext) -> str:
-        system_prompt = get_attr(
-            ctx,
-            self._system_prompt,
-            None,
-            auto_render=self._render_system_prompt,
+        summarization_prompt = get_summarization_prompt(
+            ctx=ctx,
+            summarization_prompt_attr=self._summarization_prompt,
+            render_summarization_prompt=self._render_summarization_prompt,
         )
-        if system_prompt is not None:
-            return system_prompt
-        return default_llm_config.get_default_system_prompt()
-
-    def _get_user_prompt(
-        self, ctx: AnyContext, conversation_context: dict[str, Any]
-    ) -> str:
-        user_message = self._get_user_message(ctx)
-        enriched_context = {**get_default_context(user_message), **conversation_context}
-        return dedent(
-            f"""
-            # Context
-            {json.dumps(enriched_context)}
-            # User Message
-            {user_message}
-            """.strip()
+        system_prompt = get_system_prompt(
+            ctx=ctx,
+            system_prompt_attr=self._system_prompt,
+            render_system_prompt=self._render_system_prompt,
         )
-
-    def _get_user_message(self, ctx: AnyContext) -> str:
-        return get_str_attr(ctx, self._message, "How are you?", auto_render=True)
-
-    def _get_summarization_prompt(self, ctx: AnyContext) -> str:
-        summarization_prompt = get_attr(
-            ctx,
-            self._summarization_prompt,
-            None,
-            auto_render=self._render_summarization_prompt,
+        # 1. Prepare initial state (read history, get initial context)
+        history_list, conversation_context = await prepare_initial_state(
+            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,
+            conversation_context_getter=lambda c: get_conversation_context(
+                c, self._conversation_context
+            ),
         )
-        if summarization_prompt is not None:
-            return summarization_prompt
-        return default_llm_config.get_default_summarization_prompt()
-
-    def _get_should_enrich_context(
-        self, ctx: AnyContext, history_list: ListOfDict
-    ) -> bool:
-        if len(history_list) == 0:
-            return False
-        return get_bool_attr(
-            ctx,
-            self._should_enrich_context,
-            True,  # Default to True if not specified
-            auto_render=self._render_enrich_context,
+        # 2. Enrich context (optional)
+        conversation_context = await maybe_enrich_context(
+            ctx=ctx,
+            history_list=history_list,
+            conversation_context=conversation_context,
+            should_enrich_context_attr=self._should_enrich_context,
+            render_enrich_context=self._render_enrich_context,
+            model=model,
+            model_settings=model_settings,
+            context_enrichment_prompt=context_enrichment_prompt,
         )
-
-    def _get_context_enrichment_prompt(self, ctx: AnyContext) -> str:
-        context_enrichment_prompt = get_attr(
-            ctx,
-            self._context_enrichment_prompt,
-            None,
-            auto_render=self._render_context_enrichment_prompt,
+        # 3. Summarize history (optional, modifies history_list and context)
+        history_list, conversation_context = await maybe_summarize_history(
+            ctx=ctx,
+            history_list=history_list,
+            conversation_context=conversation_context,
+            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
+            ),
+            model=model,
+            model_settings=model_settings,
+            summarization_prompt=summarization_prompt,
         )
-        if context_enrichment_prompt is not None:
-            return context_enrichment_prompt
-        return default_llm_config.get_default_context_enrichment_prompt()
-
-    async def _read_conversation_history(
-        self, ctx: AnyContext
-    ) -> ConversationHistoryData:  # Returns the model instance
-        """Reads conversation history from reader, file, or attribute, with validation."""
-        history_file = self._get_history_file(ctx)
-        # Priority 1 & 2: Reader and File (handled by ConversationHistoryData)
-        history_data = await ConversationHistoryData.read_from_sources(
+        # 4. Build the final user prompt
+        user_prompt = build_user_prompt(
             ctx=ctx,
-            reader=self._conversation_history_reader,
-            file_path=history_file,
+            message_attr=self._message,
+            conversation_context=conversation_context,
         )
-        if history_data:
-            return history_data
-        # Priority 3: Callable or direct conversation_history attribute
-        raw_data_attr: Any = None
-        if callable(self._conversation_history):
-            try:
-                raw_data_attr = await run_async(self._conversation_history(ctx))
-            except Exception as e:
-                ctx.log_warning(
-                    f"Error executing callable conversation_history attribute: {e}. "
-                    "Ignoring."
-                )
-        if raw_data_attr is None:
-            raw_data_attr = self._conversation_history
-        if raw_data_attr:
-            history_data = ConversationHistoryData.parse_and_validate(
-                ctx, raw_data_attr, "attribute"
-            )
-            if history_data:
-                return history_data
-        # Fallback: Return default value
-        return ConversationHistoryData()
-
-    def _get_history_file(self, ctx: AnyContext) -> str:
-        return get_str_attr(
-            ctx,
-            self._conversation_history_file,
-            "",
-            auto_render=self._render_history_file,
+        # 5. Get the agent instance
+        agent = get_agent(
+            ctx=ctx,
+            agent_attr=self._agent,
+            model=model,
+            system_prompt=system_prompt,
+            model_settings=model_settings,
+            tools_attr=self._tools,
+            additional_tools=self._additional_tools,
+            mcp_servers_attr=self._mcp_servers,
+            additional_mcp_servers=self._additional_mcp_servers,
         )
-
-    def _get_should_summarize_history(
-        self, ctx: AnyContext, history_list: ListOfDict
-    ) -> bool:
-        history_len = len(history_list)
-        if history_len == 0:
-            return False
-        summarization_threshold = self._get_history_summarization_threshold(ctx)
-        if summarization_threshold == -1:
-            return False
-        if summarization_threshold > history_len:
-            return False
-        return get_bool_attr(
-            ctx,
-            self._should_summarize_history,
-            False,
-            auto_render=self._render_summarize_history,
+        # 6. Run the agent iteration and save the results/history
+        return await self._run_agent_and_save_history(
+            ctx, agent, user_prompt, history_list, conversation_context
         )
 
-    def _get_history_summarization_threshold(self, ctx: AnyContext) -> int:
-        # Use get_int_attr with -1 as default (no limit)
+    async def _run_agent_and_save_history(
+        self,
+        ctx: AnyContext,
+        agent: Agent,
+        user_prompt: str,
+        history_list: ListOfDict,
+        conversation_context: dict[str, Any],
+    ) -> Any:
+        """Executes the agent, processes results, and saves history."""
         try:
-            return get_int_attr(
-                ctx,
-                self._history_summarization_threshold,
-                -1,
-                auto_render=self._render_history_summarization_threshold,
-            )
-        except ValueError as e:
-            ctx.log_warning(
-                f"Could not convert history_summarization_threshold to int: {e}. "
-                "Defaulting to -1 (no threshold)."
-            )
-            return -1
-
-    def _get_conversation_context(self, ctx: AnyContext) -> dict[str, Any]:
-        """
-        Retrieves the conversation context.
-        If a value in the context dict is callable, it executes it with ctx.
-        """
-        raw_context = get_attr(
-            ctx, self._conversation_context, {}, auto_render=False
-        )  # Context usually shouldn't be rendered
-        if not isinstance(raw_context, dict):
-            ctx.log_warning(
-                f"Conversation context resolved to type {type(raw_context)}, "
-                "expected dict. Returning empty context."
+            agent_run = await run_agent_iteration(
+                ctx=ctx,
+                agent=agent,
+                user_prompt=user_prompt,
+                history_list=history_list,
             )
-            return {}
-        # If conversation_context contains callable value, execute them.
-        processed_context: dict[str, Any] = {}
-        for key, value in raw_context.items():
-            if callable(value):
-                try:
-                    # Check if the callable expects 'ctx'
-                    sig = inspect.signature(value)
-                    if "ctx" in sig.parameters:
-                        processed_context[key] = value(ctx)
-                    else:
-                        processed_context[key] = value()
-                except Exception as e:
-                    ctx.log_warning(
-                        f"Error executing callable for context key '{key}': {e}. "
-                        "Skipping."
-                    )
-                    processed_context[key] = None
+            if agent_run:
+                new_history_list = json.loads(agent_run.result.all_messages_json())
+                data_to_write = ConversationHistoryData(
+                    context=conversation_context,  # Save the final context state
+                    history=new_history_list,
+                )
+                await write_conversation_history(
+                    ctx=ctx,
+                    history_data=data_to_write,
+                    conversation_history_writer=self._conversation_history_writer,
+                    conversation_history_file_attr=self._conversation_history_file,
+                    render_history_file=self._render_history_file,
+                )
+                xcom_usage_key = f"{self.name}-usage"
+                if xcom_usage_key not in ctx.xcom:
+                    ctx.xcom[xcom_usage_key] = Xcom([])
+                usage = agent_run.result.usage()
+                ctx.xcom.get(xcom_usage_key).push(usage)
+                ctx.print(stylize_faint(f"[USAGE] {usage}"))
+                return agent_run.result.data
             else:
-                processed_context[key] = value
-        return processed_context
+                ctx.log_warning("Agent run did not produce a result.")
+                return None  # Or handle as appropriate
+        except Exception as e:
+            ctx.log_error(f"Error during agent execution or history saving: {str(e)}")
+            raise  # Re-raise the exception after logging

{zrb-1.5.7.dist-info → zrb-1.5.8.dist-info}/METADATA

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

{zrb-1.5.7.dist-info → zrb-1.5.8.dist-info}/RECORD

@@ -14,7 +14,7 @@ zrb/builtin/llm/previous-session.js,sha256=xMKZvJoAbrwiyHS0OoPrWuaKxWYLoyR5sgueP
 zrb/builtin/llm/tool/api.py,sha256=yR9I0ZsI96OeQl9pgwORMASVuXsAL0a89D_iPS4C8Dc,1699
 zrb/builtin/llm/tool/cli.py,sha256=_CNEmEc6K2Z0i9ppYeM7jGpqaEdT3uxaWQatmxP3jKE,858
 zrb/builtin/llm/tool/file.py,sha256=ecFBmbMaqCIfqNGTmvd-Yt3vLtKuQ15KbjXlnIMWdho,19269
-zrb/builtin/llm/tool/rag.py,sha256=tw4MW5VW_3hezGufS0nICHe28eg5hPLMO4SsiDp4srQ,7500
+zrb/builtin/llm/tool/rag.py,sha256=45t0o88l7F62oq2P61NnC1hsZJ4h72dZsVQfcsOIUc8,7521
 zrb/builtin/llm/tool/web.py,sha256=4qzom9xX-JxztIaTWneNfyTRlgweHIxzC1uSEAxJ00A,5507
 zrb/builtin/md5.py,sha256=0pNlrfZA0wlZlHvFHLgyqN0JZJWGKQIF5oXxO44_OJk,949
 zrb/builtin/project/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -300,18 +300,21 @@ zrb/task/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 zrb/task/any_task.py,sha256=9rCdKe-Sayr34Han9AsbhRxFpkbk6Rteg1DOyETulwQ,4917
 zrb/task/base_task.py,sha256=H1D2KyJ9qK0GIPJ4kYyvfRe7fseJibmLVGjj8iRuLs4,21320
 zrb/task/base_trigger.py,sha256=jC722rDvodaBLeNaFghkTyv1u0QXrK6BLZUUqcmBJ7Q,4581
-zrb/task/cmd_task.py,sha256=pUKRSR4DZKjbmluB6vi7cxqyhxOLfJ2czSpYeQbiDvo,10705
+zrb/task/cmd_task.py,sha256=f1OWajOBmdtx2QcXBr_8s6o82Fp4UTLqCXJqp2gxwzU,10750
 zrb/task/http_check.py,sha256=Gf5rOB2Se2EdizuN9rp65HpGmfZkGc-clIAlHmPVehs,2565
 zrb/task/llm/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-zrb/task/llm/agent_runner.py,sha256=-6i351_AViek2xXpqPHa0LdwhhRDPLpcnKeyr-pAGyI,1848
-zrb/task/llm/context_enricher.py,sha256=eNjyHkL2g5X1jMtYR711-N_x7EtkoP6d577uT3anOYA,3016
-zrb/task/llm/default_context.py,sha256=IgHpmlGsBXILJcWC4Fn9dr52UG-puMXlQ-AHoXd6Oh0,1460
+zrb/task/llm/agent.py,sha256=2u1zlX41oBzMKozXWXD3gDEOzOsHNsFpedRcJXbUNHI,5105
+zrb/task/llm/config.py,sha256=fXasnGb_DVTJIeY--HZ8bf1jd7iCUNttfUDJB5PvHRk,3071
+zrb/task/llm/context.py,sha256=JAI1DqqiXlDkyL4aEXVyeutU8K5YfdSsWMbzx1rxMZU,3281
+zrb/task/llm/context_enrichment.py,sha256=nnALfQ_jnRpQZJad0pgOY8JkOb9Au4LoH_NNhw4rTMQ,4442
 zrb/task/llm/error.py,sha256=YOwnEdFMtqOlaiA83tDHpC6uh2_9r5NeS-inrlb5a8E,3622
-zrb/task/llm/history.py,sha256=qQtp-8a71sYL0A9YWo94KRy9o9J5ZCCJlMk4jM-t_rI,3572
-zrb/task/llm/history_summarizer.py,sha256=WZRyVRh1eGOmZKHypaxEidzruDYEM-Gcmdy2Z_XJ4Ro,2572
+zrb/task/llm/history.py,sha256=LnrJdXLyo2qz-bNCwLorhoqGmgSiPTUU0bzY63w67-E,9257
+zrb/task/llm/history_summarization.py,sha256=MW9wg6m0y2Vjcdyvh-NCOCyYWUZeqamlL3z3LCkn1J0,5996
 zrb/task/llm/print_node.py,sha256=Dkb0xFyEXpNRKFRCM4Md0lfg6K3nI0t8yH3Abh20PjE,4430
+zrb/task/llm/prompt.py,sha256=PmzeSeUBoqZqqHox1Kq8FkikvmB2lNA3hus-pybXAQg,2719
 zrb/task/llm/tool_wrapper.py,sha256=gZgoxcuOCgAVDPnLqfJ3ps57ZCVQi7q68z_KnS5Mx1U,3350
-zrb/task/llm_task.py,sha256=VH96eDL51MnMiYq91jPA4ONTXTuL5hYH_Uas0Fd_608,21211
+zrb/task/llm/typing.py,sha256=c8VAuPBw_4A3DxfYdydkgedaP-LU61W9_wj3m3CAX1E,58
+zrb/task/llm_task.py,sha256=mrv7AVZd2LEz_z6CqC2gN6iqg27riUyrpTH99HdqpX0,13731
 zrb/task/make_task.py,sha256=PD3b_aYazthS8LHeJsLAhwKDEgdurQZpymJDKeN60u0,2265
 zrb/task/rsync_task.py,sha256=GSL9144bmp6F0EckT6m-2a1xG25AzrrWYzH4k3SVUKM,6370
 zrb/task/scaffolder.py,sha256=rME18w1HJUHXgi9eTYXx_T2G4JdqDYzBoNOkdOOo5-o,6806
@@ -352,7 +355,7 @@ zrb/util/string/name.py,sha256=8picJfUBXNpdh64GNaHv3om23QHhUZux7DguFLrXHp8,1163
 zrb/util/todo.py,sha256=1nDdwPc22oFoK_1ZTXyf3638Bg6sqE2yp_U4_-frHoc,16015
 zrb/xcom/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 zrb/xcom/xcom.py,sha256=o79rxR9wphnShrcIushA0Qt71d_p3ZTxjNf7x9hJB78,1571
-zrb-1.5.7.dist-info/METADATA,sha256=jnJmD2uvg38nJvh5kYyMM77rWT4HEIEjnOCIgI8IhJY,8470
-zrb-1.5.7.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-zrb-1.5.7.dist-info/entry_points.txt,sha256=-Pg3ElWPfnaSM-XvXqCxEAa-wfVI6BEgcs386s8C8v8,46
-zrb-1.5.7.dist-info/RECORD,,
+zrb-1.5.8.dist-info/METADATA,sha256=Av7ZK7PbcYfMR6KUZ0IjN39HKabpxoWNUdAxP7yli_E,8470
+zrb-1.5.8.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+zrb-1.5.8.dist-info/entry_points.txt,sha256=-Pg3ElWPfnaSM-XvXqCxEAa-wfVI6BEgcs386s8C8v8,46
+zrb-1.5.8.dist-info/RECORD,,

zrb/task/llm/agent_runner.py

@@ -1,53 +0,0 @@
-from typing import Any
-
-from openai import APIError
-from pydantic_ai import Agent
-from pydantic_ai.messages import ModelMessagesTypeAdapter
-
-from zrb.context.any_context import AnyContext
-from zrb.task.llm.error import extract_api_error_details
-from zrb.task.llm.history import ListOfDict
-from zrb.task.llm.print_node import print_node
-
-
-async def run_agent_iteration(
-    ctx: AnyContext,
-    agent: Agent,
-    user_prompt: str,
-    history_list: ListOfDict,
-) -> Any:
-    """
-    Runs a single iteration of the agent execution loop.
-
-    Args:
-        ctx: The task context.
-        agent: The Pydantic AI agent instance.
-        user_prompt: The user's input prompt.
-        history_list: The current conversation history.
-
-    Returns:
-        The agent run result object.
-
-    Raises:
-        Exception: If any error occurs during agent execution.
-    """
-    async with agent.run_mcp_servers():
-        async with agent.iter(
-            user_prompt=user_prompt,
-            message_history=ModelMessagesTypeAdapter.validate_python(history_list),
-        ) as agent_run:
-            async for node in agent_run:
-                # Each node represents a step in the agent's execution
-                # Reference: https://ai.pydantic.dev/agents/#streaming
-                try:
-                    await print_node(ctx.print, agent_run, node)
-                except APIError as e:
-                    # Extract detailed error information from the response
-                    error_details = extract_api_error_details(e)
-                    ctx.log_error(f"API Error: {error_details}")
-                    raise
-                except Exception as e:
-                    ctx.log_error(f"Error processing node: {str(e)}")
-                    ctx.log_error(f"Error type: {type(e).__name__}")
-                    raise
-            return agent_run

zrb/task/llm/default_context.py

@@ -1,45 +0,0 @@
-import datetime
-import os
-import platform
-import re
-from typing import Any
-
-from zrb.util.file import read_dir, read_file_with_line_numbers
-
-
-def get_default_context(user_message: str) -> dict[str, Any]:
-    references = re.findall(r"@(\S+)", user_message)
-    current_references = []
-
-    for ref in references:
-        resource_path = os.path.abspath(os.path.expanduser(ref))
-        if os.path.isfile(resource_path):
-            content = read_file_with_line_numbers(resource_path)
-            current_references.append(
-                {
-                    "reference": ref,
-                    "name": resource_path,
-                    "type": "file",
-                    "note": "line numbers are included in the content",
-                    "content": content,
-                }
-            )
-        elif os.path.isdir(resource_path):
-            content = read_dir(resource_path)
-            current_references.append(
-                {
-                    "reference": ref,
-                    "name": resource_path,
-                    "type": "directory",
-                    "content": content,
-                }
-            )
-
-    return {
-        "current_time": datetime.datetime.now().isoformat(),
-        "current_working_directory": os.getcwd(),
-        "current_os": platform.system(),
-        "os_version": platform.version(),
-        "python_version": platform.python_version(),
-        "current_references": current_references,
-    }