zrb 1.0.0b3__py3-none-any.whl → 1.0.0b5__py3-none-any.whl

zrb/builtin/llm/llm_chat.py

@@ -1,17 +1,76 @@
+import json
+import os
+from typing import Any
+
 from zrb.builtin.group import llm_group
+from zrb.builtin.llm.tool.api import get_current_location, get_current_weather
 from zrb.builtin.llm.tool.cli import run_shell_command
-from zrb.builtin.llm.tool.rag import create_rag_from_directory
 from zrb.builtin.llm.tool.web import open_web_route, query_internet
 from zrb.config import (
+    LLM_ALLOW_ACCESS_INTERNET,
     LLM_ALLOW_ACCESS_SHELL,
-    LLM_ALLOW_ACCESS_WEB,
-    LLM_HISTORY_FILE,
+    LLM_HISTORY_DIR,
     LLM_MODEL,
     LLM_SYSTEM_PROMPT,
 )
+from zrb.context.any_shared_context import AnySharedContext
+from zrb.input.bool_input import BoolInput
 from zrb.input.str_input import StrInput
 from zrb.input.text_input import TextInput
 from zrb.task.llm_task import LLMTask
+from zrb.util.file import read_file, write_file
+from zrb.util.string.conversion import to_pascal_case
+
+
+class PreviousSessionInput(StrInput):
+
+    def to_html(self, ctx: AnySharedContext) -> str:
+        name = self.name
+        description = self.description
+        default = self.get_default_str(ctx)
+        script = read_file(
+            file_path=os.path.join(os.path.dirname(__file__), "previous-session.js"),
+            replace_map={
+                "CURRENT_INPUT_NAME": name,
+                "CurrentPascalInputName": to_pascal_case(name),
+            },
+        )
+        return "\n".join(
+            [
+                f'<input name="{name}" placeholder="{description}" value="{default}" />',
+                f"<script>{script}</script>",
+            ]
+        )
+
+
+def _read_chat_conversation(ctx: AnySharedContext) -> list[dict[str, Any]]:
+    if ctx.input.start_new:
+        return []
+    previous_session_name = ctx.input.previous_session
+    if previous_session_name == "" or previous_session_name is None:
+        last_session_file_path = os.path.join(LLM_HISTORY_DIR, "last-session")
+        if os.path.isfile(last_session_file_path):
+            previous_session_name = read_file(last_session_file_path).strip()
+    conversation_file_path = os.path.join(
+        LLM_HISTORY_DIR, f"{previous_session_name}.json"
+    )
+    if not os.path.isfile(conversation_file_path):
+        return []
+    return json.loads(read_file(conversation_file_path))
+
+
+def _write_chat_conversation(
+    ctx: AnySharedContext, conversations: list[dict[str, Any]]
+):
+    os.makedirs(LLM_HISTORY_DIR, exist_ok=True)
+    current_session_name = ctx.session.name
+    conversation_file_path = os.path.join(
+        LLM_HISTORY_DIR, f"{current_session_name}.json"
+    )
+    write_file(conversation_file_path, json.dumps(conversations, indent=2))
+    last_session_file_path = os.path.join(LLM_HISTORY_DIR, "last-session")
+    write_file(last_session_file_path, current_session_name)
+
 
 llm_chat: LLMTask = llm_group.add_task(
     LLMTask(
@@ -22,16 +81,33 @@ llm_chat: LLMTask = llm_group.add_task(
                 description="LLM Model",
                 prompt="LLM Model",
                 default_str=LLM_MODEL,
+                allow_positional_parsing=False,
             ),
             TextInput(
                 "system-prompt",
                 description="System prompt",
                 prompt="System prompt",
                 default_str=LLM_SYSTEM_PROMPT,
+                allow_positional_parsing=False,
+            ),
+            BoolInput(
+                "start-new",
+                description="Start new conversation (LLM will forget everything)",
+                prompt="Start new conversation (LLM will forget everything)",
+                default_str="false",
+                allow_positional_parsing=False,
             ),
             TextInput("message", description="User message", prompt="Your message"),
+            PreviousSessionInput(
+                "previous-session",
+                description="Previous conversation session",
+                prompt="Previous conversation session (can be empty)",
+                allow_positional_parsing=False,
+                allow_empty=True,
+            ),
         ],
-        history_file=LLM_HISTORY_FILE,
+        conversation_history_reader=_read_chat_conversation,
+        conversation_history_writer=_write_chat_conversation,
         description="Chat with LLM",
         model="{ctx.input.model}",
         system_prompt="{ctx.input['system-prompt']}",
@@ -44,6 +120,8 @@ llm_chat: LLMTask = llm_group.add_task(
 if LLM_ALLOW_ACCESS_SHELL:
     llm_chat.add_tool(run_shell_command)
 
-if LLM_ALLOW_ACCESS_WEB:
+if LLM_ALLOW_ACCESS_INTERNET:
     llm_chat.add_tool(open_web_route)
     llm_chat.add_tool(query_internet)
+    llm_chat.add_tool(get_current_location)
+    llm_chat.add_tool(get_current_weather)

zrb/builtin/llm/previous-session.js

@@ -0,0 +1,21 @@
+async function updatePreviousSession(event) {
+    const currentInput = event.target;
+    if (currentInput.name === "CURRENT_INPUT_NAME") {
+        return
+    }
+    const previousSessionInput = submitTaskForm.querySelector('[name="CURRENT_INPUT_NAME"]');
+    if (previousSessionInput) {
+        const currentSessionName = cfg.SESSION_NAME
+        previousSessionInput.value = currentSessionName;
+    }
+}
+
+document.getElementById("submit-task-form").querySelectorAll("input[name], textarea[name]").forEach((element) => {
+    element.addEventListener("input", updatePreviousSession);
+    element.addEventListener("keyup", updatePreviousSession);
+});
+
+document.getElementById("submit-task-form").querySelectorAll("select[name]").forEach((element) => {
+    element.addEventListener("change", updatePreviousSession);
+});
+

zrb/builtin/llm/tool/api.py

@@ -0,0 +1,29 @@
+import json
+from typing import Annotated, Literal
+
+import requests
+
+
+def get_current_location() -> (
+    Annotated[str, "JSON string representing latitude and longitude"]
+):  # noqa
+    """Get the user's current location."""
+    return json.dumps(requests.get("http://ip-api.com/json?fields=lat,lon").json())
+
+
+def get_current_weather(
+    latitude: float,
+    longitude: float,
+    temperature_unit: Literal["celsius", "fahrenheit"],
+) -> str:
+    """Get the current weather in a given location."""
+    resp = requests.get(
+        "https://api.open-meteo.com/v1/forecast",
+        params={
+            "latitude": latitude,
+            "longitude": longitude,
+            "temperature_unit": temperature_unit,
+            "current_weather": True,
+        },
+    )
+    return json.dumps(resp.json())

zrb/builtin/todo.py

@@ -294,6 +294,7 @@ def _get_default_stop_work_time_str() -> str:
             description="Todo.txt content",
             prompt="Todo.txt content (will override existing)",
             default_str=lambda _: _get_todo_txt_content(),
+            allow_positional_parsing=False,
         ),
     ],
     description="📝 Edit todo",

zrb/config.py

@@ -78,25 +78,23 @@ WEB_AUTH_REFRESH_TOKEN_EXPIRE_MINUTES = int(
 )
 LLM_MODEL = os.getenv("ZRB_LLM_MODEL", "ollama_chat/llama3.1")
 
-_DEFAULT_PROMPT = """
-You are a reliable assistant focused on providing accurate, helpful, and factual information.
-
-Key guidelines:
-1. Prioritize correctness and clarity.
-2. Avoid guessing—clearly state if more information is needed.
-3. Distinguish facts from opinions.
-4. Use phrases like "to the best of my knowledge" when appropriate.
-
-If unsure or lacking current data, inform the user and suggest verification.
-Accuracy always takes precedence over completeness.
-""".strip()
+_DEFAULT_PROMPT = (
+    "You are a helpful AI assistant capable of using various tools to answer user queries. When solving a problem:\n"
+    "1. Carefully analyze the user's request and identify what information is needed to provide a complete answer.\n"
+    "2. Determine which available tools can help you gather the necessary information.\n"
+    "3. Call tools strategically and in a logical sequence to collect required data.\n"
+    "4. If a tool provides incomplete information, intelligently decide which additional tool or approach to use.\n"
+    "5. Always aim to provide the most accurate and helpful response possible."
+)
 LLM_SYSTEM_PROMPT = os.getenv("ZRB_LLM_SYSTEM_PROMPT", _DEFAULT_PROMPT)
+LLM_HISTORY_DIR = os.getenv(
+    "ZRB_LLM_HISTORY_DIR", os.path.expanduser(os.path.join("~", ".zrb-llm-history"))
+)
 LLM_HISTORY_FILE = os.getenv(
-    "ZRB_LLM_HISTORY_FILE",
-    os.path.expanduser(os.path.join("~", ".zrb-llm-history.json")),
+    "ZRB_LLM_HISTORY_FILE", os.path.join(LLM_HISTORY_DIR, "history.json")
 )
 LLM_ALLOW_ACCESS_SHELL = to_boolean(os.getenv("ZRB_LLM_ACCESS_FILE", "1"))
-LLM_ALLOW_ACCESS_WEB = to_boolean(os.getenv("ZRB_LLM_ACCESS_WEB", "1"))
+LLM_ALLOW_ACCESS_INTERNET = to_boolean(os.getenv("ZRB_LLM_ACCESS_INTERNET", "1"))
 RAG_EMBEDDING_MODEL = os.getenv("ZRB_RAG_EMBEDDING_MODEL", "ollama/nomic-embed-text")
 RAG_CHUNK_SIZE = int(os.getenv("ZRB_RAG_CHUNK_SIZE", "1024"))
 RAG_OVERLAP = int(os.getenv("ZRB_RAG_OVERLAP", "128"))

zrb/input/any_input.py

@@ -19,6 +19,11 @@ class AnyInput(ABC):
     def prompt_message(self) -> str:
         pass
 
+    @property
+    @abstractmethod
+    def allow_positional_parsing(self) -> bool:
+        pass
+
     @abstractmethod
     def to_html(self, shared_ctx: AnySharedContext) -> str:
         pass

zrb/input/base_input.py

@@ -16,6 +16,7 @@ class BaseInput(AnyInput):
         default_str: StrAttr = "",
         auto_render: bool = True,
         allow_empty: bool = False,
+        allow_positional_parsing: bool = True,
     ):
         self._name = name
         self._description = description
@@ -23,6 +24,7 @@ class BaseInput(AnyInput):
         self._default_str = default_str
         self._auto_render = auto_render
         self._allow_empty = allow_empty
+        self._allow_positional_parsing = allow_positional_parsing
 
     def __repr__(self):
         return f"<{self.__class__.__name__} name={self._name}>"
@@ -39,6 +41,10 @@ class BaseInput(AnyInput):
     def prompt_message(self) -> str:
         return self._prompt if self._prompt is not None else self.name
 
+    @property
+    def allow_positional_parsing(self) -> bool:
+        return self._allow_positional_parsing
+
     def to_html(self, ctx: AnySharedContext) -> str:
         name = self.name
         description = self.description

zrb/input/bool_input.py

@@ -13,6 +13,7 @@ class BoolInput(BaseInput):
         default_str: StrAttr = "False",
         auto_render: bool = True,
         allow_empty: bool = False,
+        allow_positional_parsing: bool = True,
     ):
         super().__init__(
             name=name,
@@ -21,6 +22,7 @@ class BoolInput(BaseInput):
             default_str=default_str,
             auto_render=auto_render,
             allow_empty=allow_empty,
+            allow_positional_parsing=allow_positional_parsing,
         )
 
     def to_html(self, ctx: AnySharedContext) -> str:

zrb/input/float_input.py

@@ -12,6 +12,7 @@ class FloatInput(BaseInput):
         default_str: StrAttr = "0.0",
         auto_render: bool = True,
         allow_empty: bool = False,
+        allow_positional_parsing: bool = True,
     ):
         super().__init__(
             name=name,
@@ -20,6 +21,7 @@ class FloatInput(BaseInput):
             default_str=default_str,
             auto_render=auto_render,
             allow_empty=allow_empty,
+            allow_positional_parsing=allow_positional_parsing,
         )
 
     def to_html(self, ctx: AnySharedContext) -> str:

zrb/input/int_input.py

@@ -12,6 +12,7 @@ class IntInput(BaseInput):
         default_str: StrAttr = "0",
         auto_render: bool = True,
         allow_empty: bool = False,
+        allow_positional_parsing: bool = True,
     ):
         super().__init__(
             name=name,
@@ -20,6 +21,7 @@ class IntInput(BaseInput):
             default_str=default_str,
             auto_render=auto_render,
             allow_empty=allow_empty,
+            allow_positional_parsing=allow_positional_parsing,
         )
 
     def to_html(self, ctx: AnySharedContext) -> str:

zrb/input/option_input.py

@@ -14,6 +14,7 @@ class OptionInput(BaseInput):
         default_str: StrAttr = "",
         auto_render: bool = True,
         allow_empty: bool = False,
+        allow_positional_parsing: bool = True,
     ):
         super().__init__(
             name=name,
@@ -22,6 +23,7 @@ class OptionInput(BaseInput):
             default_str=default_str,
             auto_render=auto_render,
             allow_empty=allow_empty,
+            allow_positional_parsing=allow_positional_parsing,
         )
         self._options = options
 

zrb/input/password_input.py

@@ -14,6 +14,7 @@ class PasswordInput(BaseInput):
         default_str: str | Callable[[AnySharedContext], str] = "",
         auto_render: bool = True,
         allow_empty: bool = False,
+        allow_positional_parsing: bool = True,
     ):
         super().__init__(
             name=name,
@@ -22,6 +23,7 @@ class PasswordInput(BaseInput):
             default_str=default_str,
             auto_render=auto_render,
             allow_empty=allow_empty,
+            allow_positional_parsing=allow_positional_parsing,
         )
         self._is_secret = True
 

zrb/input/text_input.py

@@ -18,6 +18,7 @@ class TextInput(BaseInput):
         default_str: str | Callable[[AnySharedContext], str] = "",
         auto_render: bool = True,
         allow_empty: bool = False,
+        allow_positional_parsing: bool = True,
         editor: str = DEFAULT_EDITOR,
         extension: str = ".txt",
         comment_start: str | None = None,
@@ -30,6 +31,7 @@ class TextInput(BaseInput):
             default_str=default_str,
             auto_render=auto_render,
             allow_empty=allow_empty,
+            allow_positional_parsing=allow_positional_parsing,
         )
         self._editor = editor
         self._extension = extension

zrb/runner/common_util.py

@@ -15,7 +15,7 @@ def get_run_kwargs(
         if task_input.name in str_kwargs:
             # Update shared context for next input default value
             task_input.update_shared_context(shared_ctx, str_kwargs[task_input.name])
-        elif arg_index < len(args):
+        elif arg_index < len(args) and task_input.allow_positional_parsing:
             run_kwargs[task_input.name] = args[arg_index]
             # Update shared context for next input default value
             task_input.update_shared_context(shared_ctx, run_kwargs[task_input.name])

zrb/runner/web_route/node_page/task/view.html

@@ -63,7 +63,7 @@
             <article>
                 <form id="submit-task-form" onsubmit="submitNewSessionForm(event)">
                     {task_inputs}
-                    <button>🚀 Run</button>
+                    <button>🚀 Run New Session</button>
                 </form>
             </article>
             <article>

zrb/runner/web_route/static/resources/session/current-session.js

@@ -4,18 +4,22 @@ const CURRENT_SESSION = {
         const logTextarea = document.getElementById("log-textarea");
         const submitTaskForm = document.getElementById("submit-task-form");
         let isFinished = false;
+        let isInputUpdated = false;
         let errorCount = 0;
         while (!isFinished) {
             try {
                 const data = await this.getCurrentSession();
                 // update inputs
-                const dataInputs = data.input;
-                for (const inputName in dataInputs) {
-                    const inputValue = dataInputs[inputName];
-                    const input = submitTaskForm.querySelector(`[name="${inputName}"]`);
-                    if (input) {
-                        input.value = inputValue;
+                if (!isInputUpdated) {
+                    const dataInputs = data.input;
+                    for (const inputName in dataInputs) {
+                        const inputValue = dataInputs[inputName];
+                        const input = submitTaskForm.querySelector(`[name="${inputName}"]`);
+                        if (input) {
+                            input.value = inputValue;
+                        }
                     }
+                    isInputUpdated = true;
                 }
                 resultLineCount = data.final_result.split("\n").length;
                 resultTextarea.rows = resultLineCount <= 5 ? resultLineCount : 5;
@@ -51,7 +55,6 @@ const CURRENT_SESSION = {
                     "Content-Type": "application/json"
                 },
             });
-            console.log("RESPONSE", response);
             return await response.json();
         } catch (error) {
             console.error("Error:", error);

zrb/runner/web_route/static/resources/session/event.js

@@ -20,9 +20,9 @@ window.addEventListener("load", async function () {
 
 
 const submitTaskForm = document.getElementById("submit-task-form");
-submitTaskForm.addEventListener("change", async function(event) {
+async function handleInputUpdate(event) {
     const currentInput = event.target;
-    const inputs = Array.from(submitTaskForm.querySelectorAll("input[name], textarea[name]"));
+    const inputs = Array.from(submitTaskForm.querySelectorAll("input[name], textarea[name], select[name]"));
     const inputMap = {};
     const fixedInputNames = [];
     for (const input of inputs) {
@@ -56,6 +56,10 @@ submitTaskForm.addEventListener("change", async function(event) {
                 if (input === currentInput) {
                     return;
                 }
+                if (value === "") {
+                    return;
+                }
+                console.log(input, data);
                 input.value = value;
             });
         } else {
@@ -64,6 +68,14 @@ submitTaskForm.addEventListener("change", async function(event) {
     } catch (error) {
         console.error("Error during fetch:", error);
     }
+}
+
+submitTaskForm.querySelectorAll("input[name], textarea[name]").forEach((element) => {
+    element.addEventListener("input", handleInputUpdate);
+    element.addEventListener("keyup", handleInputUpdate);
+});
+submitTaskForm.querySelectorAll("select[name]").forEach((element) => {
+    element.addEventListener("change", handleInputUpdate);
 });
 
 

zrb/task/llm_task.py

@@ -3,7 +3,9 @@ import os
 from collections.abc import Callable
 from typing import Any
 
-from pydantic import BaseModel
+from pydantic_ai import Agent, Tool
+from pydantic_ai.messages import ModelMessagesTypeAdapter
+from pydantic_ai.settings import ModelSettings
 
 from zrb.attr.type import StrAttr
 from zrb.config import LLM_MODEL, LLM_SYSTEM_PROMPT
@@ -16,25 +18,10 @@ from zrb.task.base_task import BaseTask
 from zrb.util.attr import get_str_attr
 from zrb.util.cli.style import stylize_faint
 from zrb.util.file import read_file, write_file
-from zrb.util.llm.tool import callable_to_tool_schema
 from zrb.util.run import run_async
 
 ListOfDict = list[dict[str, Any]]
-
-
-class AdditionalTool(BaseModel):
-    fn: Callable
-    name: str | None
-
-
-def scratchpad(thought: str) -> str:
-    """Use this tool to note your thought and planning"""
-    return thought
-
-
-def end_conversation(final_answer: str) -> str:
-    """End conversation with a final answer containing all necessary information"""
-    return final_answer
+ToolOrCallable = Tool | Callable
 
 
 class LLMTask(BaseTask):
@@ -48,17 +35,28 @@ class LLMTask(BaseTask):
         input: list[AnyInput | None] | AnyInput | None = None,
         env: list[AnyEnv | None] | AnyEnv | None = None,
         model: StrAttr | None = LLM_MODEL,
+        model_settings: (
+            ModelSettings | Callable[[AnySharedContext], ModelSettings] | None
+        ) = None,
         render_model: bool = True,
+        agent: Agent | Callable[[AnySharedContext], Agent] | None = None,
         system_prompt: StrAttr | None = LLM_SYSTEM_PROMPT,
         render_system_prompt: bool = True,
         message: StrAttr | None = None,
-        tools: list[Callable] | Callable[[AnySharedContext], list[Callable]] = [],
-        history: ListOfDict | Callable[[AnySharedContext], ListOfDict] = [],
-        history_file: StrAttr | None = None,
+        tools: (
+            list[ToolOrCallable] | Callable[[AnySharedContext], list[ToolOrCallable]]
+        ) = [],
+        conversation_history: (
+            ListOfDict | Callable[[AnySharedContext], ListOfDict]
+        ) = [],
+        conversation_history_reader: (
+            Callable[[AnySharedContext], ListOfDict] | None
+        ) = None,
+        conversation_history_writer: (
+            Callable[[AnySharedContext, ListOfDict], None] | None
+        ) = None,
+        conversation_history_file: StrAttr | None = None,
         render_history_file: bool = True,
-        model_kwargs: (
-            dict[str, Any] | Callable[[AnySharedContext], dict[str, Any]]
-        ) = {},
         execute_condition: bool | str | Callable[[AnySharedContext], bool] = True,
         retries: int = 2,
         retry_period: float = 0,
@@ -68,6 +66,7 @@ class LLMTask(BaseTask):
         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,
@@ -94,166 +93,75 @@ class LLMTask(BaseTask):
             successor=successor,
         )
         self._model = model
+        self._model_settings = (model_settings,)
+        self._agent = agent
         self._render_model = render_model
-        self._model_kwargs = model_kwargs
         self._system_prompt = system_prompt
         self._render_system_prompt = render_system_prompt
         self._message = message
         self._tools = tools
-        self._history = history
-        self._history_file = history_file
+        self._additional_tools: list[ToolOrCallable] = []
+        self._conversation_history = conversation_history
+        self._conversation_history_reader = conversation_history_reader
+        self._conversation_history_writer = conversation_history_writer
+        self._conversation_history_file = conversation_history_file
         self._render_history_file = render_history_file
+        self._max_call_iteration = max_call_iteration
 
-    def add_tool(self, tool: Callable):
-        self._tools.append(tool)
+    def add_tool(self, tool: ToolOrCallable):
+        self._additional_tools.append(tool)
 
     async def _exec_action(self, ctx: AnyContext) -> Any:
-        import litellm
-        from litellm.utils import supports_function_calling
-
-        user_message = {"role": "user", "content": self._get_message(ctx)}
-        ctx.print(stylize_faint(f"{user_message}"))
-        model = self._get_model(ctx)
-        try:
-            is_function_call_supported = supports_function_calling(model=model)
-        except Exception:
-            is_function_call_supported = False
-            litellm.add_function_to_prompt = True
-        if not is_function_call_supported:
-            ctx.log_warning(f"Model {model} doesn't support function call")
-        available_tools = self._get_available_tools(
-            ctx, include_end_conversation=not is_function_call_supported
+        history = await self._read_conversation_history(ctx)
+        user_prompt = self._get_message(ctx)
+        agent = self._get_agent(ctx)
+        result = await agent.run(
+            user_prompt=user_prompt,
+            message_history=ModelMessagesTypeAdapter.validate_python(history),
         )
-        model_kwargs = self._get_model_kwargs(ctx, available_tools)
-        ctx.log_debug("MODEL KWARGS", model_kwargs)
-        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)
-        conversations = history + [user_message]
-        history_file = self._get_history_file(ctx)
-        while True:
-            llm_response = await self._get_llm_response(
-                model, system_prompt, conversations, model_kwargs
-            )
-            llm_response_dict = llm_response.to_dict()
-            ctx.print(stylize_faint(f"{llm_response_dict}"))
-            conversations.append(llm_response_dict)
-            ctx.log_debug("RESPONSE MESSAGE", llm_response)
-            if is_function_call_supported:
-                if not llm_response.tool_calls:
-                    # No tool call, end conversation
-                    self._save_conversation(history_file, conversations)
-                    return llm_response.content
-                await self._handle_tool_calls(
-                    ctx, available_tools, conversations, llm_response
-                )
-            if not is_function_call_supported:
-                try:
-                    json_payload = json.loads(llm_response.content)
-                    function_name = _get_fallback_function_name(json_payload)
-                    function_kwargs = _get_fallback_function_kwargs(json_payload)
-                    tool_execution_message = (
-                        await self._create_fallback_tool_exec_message(
-                            available_tools, function_name, function_kwargs
-                        )
-                    )
-                    ctx.print(stylize_faint(f"{tool_execution_message}"))
-                    conversations.append(tool_execution_message)
-                    if function_name == "end_conversation":
-                        self._save_conversation(history_file, conversations)
-                        return function_kwargs.get("final_answer", "")
-                except Exception as e:
-                    ctx.log_error(e)
-                    tool_execution_message = self._create_exec_scratchpad_message(
-                        f"{e}"
-                    )
-                    conversations.append(tool_execution_message)
-
-    async def _handle_tool_calls(
-        self,
-        ctx: AnyContext,
-        available_tools: dict[str, Callable],
-        conversations: list[dict[str, Any]],
-        llm_response: Any,
+        new_history = json.loads(result.all_messages_json())
+        for history in new_history:
+            ctx.print(stylize_faint(json.dumps(history)))
+        await self._write_conversation_history(ctx, new_history)
+        return result.data
+
+    async def _write_conversation_history(
+        self, ctx: AnyContext, conversations: list[Any]
     ):
-        # noqa Reference: https://docs.litellm.ai/docs/completion/function_call#full-code---parallel-function-calling-with-gpt-35-turbo-1106
-        for tool_call in llm_response.tool_calls:
-            tool_execution_message = await self._create_tool_exec_message(
-                available_tools, tool_call
-            )
-            ctx.print(stylize_faint(f"{tool_execution_message}"))
-            conversations.append(tool_execution_message)
-
-    def _save_conversation(self, history_file: str, conversations: list[Any]):
+        if self._conversation_history_writer is not None:
+            await run_async(self._conversation_history_writer(ctx, conversations))
+        history_file = self._get_history_file(ctx)
         if history_file != "":
             write_file(history_file, json.dumps(conversations, indent=2))
 
-    async def _get_llm_response(
-        self,
-        model: str,
-        system_prompt: str,
-        conversations: list[Any],
-        model_kwargs: dict[str, Any],
-    ) -> Any:
-        from litellm import acompletion
-
-        llm_response = await acompletion(
-            model=model,
-            messages=[{"role": "system", "content": system_prompt}] + conversations,
-            **model_kwargs,
+    def _get_model_settings(self, ctx: AnyContext) -> ModelSettings | None:
+        if isinstance(self._model_settings, ModelSettings):
+            return self._model_settings
+        if callable(self._model_settings):
+            return self._model_settings(ctx)
+        return None
+
+    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
         )
-        return llm_response.choices[0].message
-
-    async def _create_tool_exec_message(
-        self, available_tools: dict[str, Callable], tool_call: Any
-    ) -> dict[str, Any]:
-        function_name = tool_call.function.name
-        function_kwargs = json.loads(tool_call.function.arguments)
-        return {
-            "tool_call_id": tool_call.id,
-            "role": "tool",
-            "name": function_name,
-            "content": await self._get_exec_tool_result(
-                available_tools, function_name, function_kwargs
-            ),
-        }
-
-    async def _create_fallback_tool_exec_message(
-        self,
-        available_tools: dict[str, Callable],
-        function_name: str,
-        function_kwargs: dict[str, Any],
-    ) -> dict[str, Any]:
-        result = await self._get_exec_tool_result(
-            available_tools, function_name, function_kwargs
-        )
-        return self._create_exec_scratchpad_message(
-            f"Result of {function_name} call: {result}"
+        tools_or_callables.extend(self._additional_tools)
+        tools = [
+            tool if isinstance(tool, Tool) else Tool(tool, takes_ctx=False)
+            for tool in tools_or_callables
+        ]
+        for tool in tools:
+            print("tool", tool)
+        return Agent(
+            self._get_model(ctx),
+            system_prompt=self._get_system_prompt(ctx),
+            tools=tools,
         )
 
-    def _create_exec_scratchpad_message(self, message: str) -> dict[str, Any]:
-        return {
-            "role": "assistant",
-            "content": json.dumps(
-                {"name": "scratchpad", "arguments": {"thought": message}}
-            ),
-        }
-
-    async def _get_exec_tool_result(
-        self,
-        available_tools: dict[str, Callable],
-        function_name: str,
-        function_kwargs: dict[str, Any],
-    ) -> str:
-        if function_name not in available_tools:
-            return f"[ERROR] Invalid tool: {function_name}"
-        function_to_call = available_tools[function_name]
-        try:
-            return await run_async(function_to_call(**function_kwargs))
-        except Exception as e:
-            return f"[ERROR] {e}"
-
     def _get_model(self, ctx: AnyContext) -> str:
         return get_str_attr(
             ctx, self._model, "ollama_chat/llama3.1", auto_render=self._render_model
@@ -270,62 +178,24 @@ class LLMTask(BaseTask):
     def _get_message(self, ctx: AnyContext) -> str:
         return get_str_attr(ctx, self._message, "How are you?", auto_render=True)
 
-    def _get_model_kwargs(
-        self, ctx: AnyContext, available_tools: dict[str, Callable]
-    ) -> dict[str, Any]:
-        model_kwargs = {}
-        if callable(self._model_kwargs):
-            model_kwargs = self._model_kwargs(ctx)
-        else:
-            model_kwargs = self._model_kwargs
-        model_kwargs["tools"] = [
-            callable_to_tool_schema(tool) for tool in available_tools.values()
-        ]
-        return model_kwargs
-
-    def _get_available_tools(
-        self, ctx: AnyContext, include_end_conversation: bool
-    ) -> dict[str, Callable]:
-        tools = {"scratchpad": scratchpad}
-        if include_end_conversation:
-            tools["end_conversation"] = end_conversation
-        tool_list = self._tools(ctx) if callable(self._tools) else self._tools
-        for tool in tool_list:
-            tools[tool.__name__] = tool
-        return tools
-
-    def _get_history(self, ctx: AnyContext) -> ListOfDict:
-        if callable(self._history):
-            return self._history(ctx)
+    async def _read_conversation_history(self, ctx: AnyContext) -> ListOfDict:
+        if self._conversation_history_reader is not None:
+            return await run_async(self._conversation_history_reader(ctx))
+        if callable(self._conversation_history):
+            return self._conversation_history(ctx)
         history_file = self._get_history_file(ctx)
         if (
-            len(self._history) == 0
+            len(self._conversation_history) == 0
             and history_file != ""
             and os.path.isfile(history_file)
         ):
             return json.loads(read_file(history_file))
-        return self._history
+        return self._conversation_history
 
     def _get_history_file(self, ctx: AnyContext) -> str:
         return get_str_attr(
-            ctx, self._history_file, "", auto_render=self._render_history_file
+            ctx,
+            self._conversation_history_file,
+            "",
+            auto_render=self._render_history_file,
         )
-
-
-def _get_fallback_function_name(json_payload: dict[str, Any]) -> str:
-    for key in ("name",):
-        if key in json_payload:
-            return json_payload[key]
-    raise ValueError("Function name not provided")
-
-
-def _get_fallback_function_kwargs(json_payload: dict[str, Any]) -> str:
-    for key in (
-        "arguments",
-        "args",
-        "parameters",
-        "params",
-    ):
-        if key in json_payload:
-            return json_payload[key]
-    raise ValueError("Function arguments not provided")

zrb/util/llm/tool.py

@@ -1,6 +1,6 @@
 import inspect
 from collections.abc import Callable
-from typing import Any, get_type_hints
+from typing import Annotated, Any, Literal, get_type_hints
 
 
 def callable_to_tool_schema(callable_obj: Callable) -> dict[str, Any]:
@@ -21,10 +21,14 @@ def callable_to_tool_schema(callable_obj: Callable) -> dict[str, Any]:
     # Build parameter schema
     param_schema = {"type": "object", "properties": {}, "required": []}
     for param_name, param in sig.parameters.items():
-        param_type = hints.get(param_name, str)  # Default type is string
-        param_schema["properties"][param_name] = {
-            "type": _python_type_to_json_type(param_type)
-        }
+        # Get the type hint or default to str
+        param_type = hints.get(param_name, str)
+
+        # Handle annotated types (e.g., Annotated[str, "description"])
+        json_type, param_metadata = _process_type_annotation(param_type)
+        param_schema["properties"][param_name] = param_metadata
+
+        # Mark required parameters
         if param.default is inspect.Parameter.empty:
             param_schema["required"].append(param_name)
     return {
@@ -37,6 +41,30 @@ def callable_to_tool_schema(callable_obj: Callable) -> dict[str, Any]:
     }
 
 
+def _process_type_annotation(py_type: Any) -> tuple[str, dict]:
+    """
+    Process type annotations and return the JSON Schema type and metadata.
+
+    :param py_type: The type annotation.
+    :return: A tuple of (JSON type, parameter metadata).
+    """
+    if hasattr(py_type, "__origin__") and py_type.__origin__ is Literal:
+        # Handle Literal (enum)
+        enum_values = list(py_type.__args__)
+        return "string", {"type": "string", "enum": enum_values}
+
+    if hasattr(py_type, "__origin__") and py_type.__origin__ is Annotated:
+        # Handle Annotated types
+        base_type = py_type.__args__[0]
+        description = py_type.__args__[1]
+        json_type = _python_type_to_json_type(base_type)
+        return json_type, {"type": json_type, "description": description}
+
+    # Fallback to basic type conversion
+    json_type = _python_type_to_json_type(py_type)
+    return json_type, {"type": json_type}
+
+
 def _python_type_to_json_type(py_type):
     """
     Map Python types to JSON Schema types.

{zrb-1.0.0b3.dist-info → zrb-1.0.0b5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: zrb
-Version: 1.0.0b3
+Version: 1.0.0b5
 Summary: Your Automation Powerhouse
 Home-page: https://github.com/state-alchemists/zrb
 License: AGPL-3.0-or-later
@@ -21,8 +21,8 @@ Requires-Dist: chromadb (>=0.5.20,<0.6.0) ; extra == "rag"
 Requires-Dist: fastapi[standard] (>=0.115.6,<0.116.0)
 Requires-Dist: isort (>=5.13.2,<5.14.0)
 Requires-Dist: libcst (>=1.5.0,<2.0.0)
-Requires-Dist: litellm (>=1.52.12,<2.0.0)
 Requires-Dist: pdfplumber (>=0.11.4,<0.12.0) ; extra == "rag"
+Requires-Dist: pydantic-ai (>=0.0.19,<0.0.20)
 Requires-Dist: python-dotenv (>=1.0.1,<2.0.0)
 Requires-Dist: python-jose[cryptography] (>=3.3.0,<4.0.0)
 Requires-Dist: requests (>=2.32.3,<3.0.0)

{zrb-1.0.0b3.dist-info → zrb-1.0.0b5.dist-info}/RECORD

@@ -7,7 +7,9 @@ zrb/builtin/base64.py,sha256=1YnSwASp7OEAvQcsnHZGpJEvYoI1Z2zTIJ1bCDHfcPQ,921
 zrb/builtin/git.py,sha256=xHzg0srhp1uOSXWvwA--Fo8idkt0G9010iJ8uIndzg4,5463
 zrb/builtin/git_subtree.py,sha256=GwI8befmvXEoX1xyZ4jkeG8nsyCkuRG1lzPiGss3yqw,3493
 zrb/builtin/group.py,sha256=-phJfVpTX3_gUwS1u8-RbZUHe-X41kxDBSmrVh4rq8E,1682
-zrb/builtin/llm/llm_chat.py,sha256=-aTCawOfJZHa7OSKPcNl-OiSqqcYb-ZAY_nkqPdvRfo,1482
+zrb/builtin/llm/llm_chat.py,sha256=vUUchYKJuHr-N_HarpKRFsV0EdQDAFZzAfbK4C0vx88,4508
+zrb/builtin/llm/previous-session.js,sha256=xMKZvJoAbrwiyHS0OoPrWuaKxWYLoyR5sguePIoCjTY,816
+zrb/builtin/llm/tool/api.py,sha256=yQ3XV8O7Fx7hHssLSOcmiHDnevPhz9ktWi44HK7zTls,801
 zrb/builtin/llm/tool/cli.py,sha256=to_IjkfrMGs6eLfG0cpVN9oyADWYsJQCtyluUhUdBww,253
 zrb/builtin/llm/tool/rag.py,sha256=jJRLERW6824JeEzEQ_OqLMaaa3mjuNqsRcRWoL1wVx0,5192
 zrb/builtin/llm/tool/web.py,sha256=N2HYuXbKPUpjVAq_UnQMbUrTIE8u0Ut3TeQadZ7_NJc,2217
@@ -162,14 +164,14 @@ zrb/builtin/shell/autocomplete/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5
 zrb/builtin/shell/autocomplete/bash.py,sha256=-7YDVV7txgJH9mAYSYN0jmvUEeDIzWFvVNY-cY0myF8,1181
 zrb/builtin/shell/autocomplete/subcmd.py,sha256=WZI6cGWJcn80zSyxOHG7sCMO3Ucix3mZf4xm_xyB_Y0,606
 zrb/builtin/shell/autocomplete/zsh.py,sha256=9hlq0Wt3fhRz326mAQTypEd4_4lZdrbBx_3A-Ti3mvw,1022
-zrb/builtin/todo.py,sha256=Tnt_XhXMGaZGtA5Cn6XwWG26s3NNvfpJFlXnuMcwI7U,10796
+zrb/builtin/todo.py,sha256=8swb5i9KWqaLfKKcKSQhu5K1QtW3RAYR1vFqsBjw-GY,10840
 zrb/callback/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 zrb/callback/any_callback.py,sha256=Yhdv5UWHAZSVzj5K2JdxcVQx8x8VX8aZJEivj3NTfZc,247
 zrb/callback/callback.py,sha256=hKefB_Jd1XGjPSLQdMKDsGLHPzEGO2dqrIArLl_EmD0,848
 zrb/cmd/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 zrb/cmd/cmd_result.py,sha256=L8bQJzWCpcYexIxHBNsXj2pT3BtLmWex0iJSMkvimOA,597
 zrb/cmd/cmd_val.py,sha256=7Doowyg6BK3ISSGBLt-PmlhzaEkBjWWm51cED6fAUOQ,1014
-zrb/config.py,sha256=TFPIA5afdJr_XvNCJWtAKFaQjoLFGjzGPZOTMBok-zU,4302
+zrb/config.py,sha256=vBBhSZ5xQV5S_20PQS54ShFgV-ko3Zbzxw23wDDJnbQ,4556
 zrb/content_transformer/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 zrb/content_transformer/any_content_transformer.py,sha256=v8ZUbcix1GGeDQwB6OKX_1TjpY__ksxWVeqibwa_iZA,850
 zrb/content_transformer/content_transformer.py,sha256=YU6Xr3G_IaCWKQGsf9z9YlCclbiwcJ7ytQv3wKpPIiI,2125
@@ -189,18 +191,18 @@ zrb/group/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 zrb/group/any_group.py,sha256=1rNcsi5eu_86JAx_6Jy46SK4BTeppcb89MORynJd-4o,1115
 zrb/group/group.py,sha256=JFmWVEQ9PVy2WCf5pUG74iwL2xcGxXaAjT-NArAeloM,1861
 zrb/input/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-zrb/input/any_input.py,sha256=0YxEaXvWyG3mWmBgUf3Z0HqtFag-JSoFuBSnfdqvWWI,803
-zrb/input/base_input.py,sha256=AiSCxxYqJd5rlYsuzO1zqXQQ_ZuJsSONvR7t_m9Kj-I,3161
-zrb/input/bool_input.py,sha256=zI1fea1k--r57vX61YVRog9sL_O7XX3gS7J3MGE8654,1383
-zrb/input/float_input.py,sha256=W_FGgnL26l6iaNkWGHDXeu20B9QHAlyHonOVR2evin0,1015
-zrb/input/int_input.py,sha256=tOgjhR8KYyahcmEto05lLzYtBowBUckwpcX4v-5sJlM,1005
-zrb/input/option_input.py,sha256=S9IjGNzjPBexMb6BEuyyrPOcb10xjkFwVH02k2v7C2A,1939
-zrb/input/password_input.py,sha256=C2alr0hgO_YLWf9MDF2H8w0NIIf_DZlDJSdKQwEyM0E,1311
+zrb/input/any_input.py,sha256=tvls3uJBVPLW5Oawxof9qWCX-lH1h_RErxjYNu1bwtY,899
+zrb/input/base_input.py,sha256=uHOZeU4OyO05e-kMXDo5MLC76ZWJXzhdhB6akaBzhtU,3383
+zrb/input/bool_input.py,sha256=mqD1c7RT683Aui2IsdJUoNiSo7iU3iYrm53e2SjaOrQ,1493
+zrb/input/float_input.py,sha256=8HhVWZsyqw1WaN3CysIgvGXkHfVsuLChUEggHODxOTk,1125
+zrb/input/int_input.py,sha256=e5F049nwe_Iaiymuh41dZtBOY-DG1AhVP-8gF0IO0n4,1115
+zrb/input/option_input.py,sha256=8K0fn5joYeiAA8GevckVrGghbrIcD9GPShDfhAU67cw,2049
+zrb/input/password_input.py,sha256=6TW3J7K3ilcstv681PIXL_Mgd6pkNDTCMH8exlqDOiM,1421
 zrb/input/str_input.py,sha256=NevZHX9rf1g8eMatPyy-kUX3DglrVAQpzvVpKAzf7bA,81
-zrb/input/text_input.py,sha256=7i0lvWYw79ILp0NEOBn-Twwnv7sBEgxJsqVaai6LzAA,3033
+zrb/input/text_input.py,sha256=cVmuNBTFl7oulwG6VVWI-QTECLSdP_0xwIaCZpkkaM8,3143
 zrb/runner/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 zrb/runner/cli.py,sha256=G_ILZCFzpV-kRE3dm1kq6BorB51TLJ34Qmhgy5SIMlU,6734
-zrb/runner/common_util.py,sha256=JYBgNPSGyJHZo0X-Qp9sDi4B14NdcTi20n1fJP4SW3M,1298
+zrb/runner/common_util.py,sha256=mjEBSmfdY2Sun2U5-8y8gGwF82OiRM8sgiYDOdW9NA4,1338
 zrb/runner/web_app.py,sha256=Ji2AWeFpJu5guXmur7mAAbjMToyjgmPDdfYu8047FFI,2616
 zrb/runner/web_config/config.py,sha256=0wR58KreAmawGGfamm0GLZY344HaXs7qfDgHLavBDwo,3125
 zrb/runner/web_config/config_factory.py,sha256=GNByKviNhQF5qG2ypmC_mV2xglzWHLVQC0x2SQJjrbA,894
@@ -223,7 +225,7 @@ zrb/runner/web_route/node_page/group/view.html,sha256=wISun627ciFZcvGpxANG0pr1zg
 zrb/runner/web_route/node_page/node_page_route.py,sha256=LYi60eZ5ZGgykTIeSQk5Hn9OYjh3ocYgBIAue7Bznvw,2268
 zrb/runner/web_route/node_page/task/partial/input.html,sha256=X2jy0q7TLQGP853exZMed0lqPezL3gzn6mnhB5QKfkc,178
 zrb/runner/web_route/node_page/task/show_task_page.py,sha256=0HIFEuy5DLOKqff4Wib5WaMe5Om0B4C7BH63pPIA-OU,2639
-zrb/runner/web_route/node_page/task/view.html,sha256=CwrIiPJAwHEEIVNp_wkTzW7kQJjTh41FSDamCswI3S8,3593
+zrb/runner/web_route/node_page/task/view.html,sha256=T6kXNYKGhHsY5A74vQt_tj68WrULmPRaSuMqI1ygD1o,3605
 zrb/runner/web_route/refresh_token_api_route.py,sha256=JOuzhQUtRA62w3l27mq-jXgpaV7Rbj20jzxpQacssio,1478
 zrb/runner/web_route/static/refresh-token.template.js,sha256=v_nF7nU1AXp-KtsHNNzamhciEi7NCSTPEDT5hCxn29g,735
 zrb/runner/web_route/static/resources/common.css,sha256=u5rGLsPx2943z324iQ2X81krM3z-kc-8e1SkBdYAvKU,157
@@ -232,8 +234,8 @@ zrb/runner/web_route/static/resources/login/event.js,sha256=1-NxaUwU-X7Tu2RAwVkz
 zrb/runner/web_route/static/resources/logout/event.js,sha256=MfZxrTa2yL49Lbh7cCZDdqsIcf9e1q3W8-WjmZXV5pA,692
 zrb/runner/web_route/static/resources/pico.min.css,sha256=_Esfkjs_U_igYn-tXBUaK3AEKb7d4l9DlmaOiw9bXfI,82214
 zrb/runner/web_route/static/resources/session/common-util.js,sha256=t7_s5DXgMyZlT8L8LYZTkzOT6vWVeZvmCKjt-bflQY0,2117
-zrb/runner/web_route/static/resources/session/current-session.js,sha256=kMpDOuXG3_mt1M6hB4hrRdzEO31sqQVGGOiOGOVrdt4,6618
-zrb/runner/web_route/static/resources/session/event.js,sha256=mbkasvRwLie-XoQWK5qZ1B3qj3b-fQIVVYeD2THOkzA,4263
+zrb/runner/web_route/static/resources/session/current-session.js,sha256=GlRBLwItCwITqVR_hUQFr6W1myD9WRl8R_TTbrzCovw,6739
+zrb/runner/web_route/static/resources/session/event.js,sha256=X5OlSHefK0SDB9VkFCRyBKE_Pb7mqM319mW9jRGoDOk,4716
 zrb/runner/web_route/static/resources/session/past-session.js,sha256=RwGJYKSp75K8NZ-iZP58XppWgdzkiKFaiC5wgcMLxDo,5470
 zrb/runner/web_route/static/static_route.py,sha256=7x069VfACZLkLykY0vLL5t13jIQPgkeEJtkpbfNQfLg,1540
 zrb/runner/web_route/task_input_api_route.py,sha256=xkZ36vmHXMPj0ekp6ocUysO0QUgl1PLaSHt3YL_OfK8,1749
@@ -260,7 +262,7 @@ zrb/task/base_task.py,sha256=ImA0ReyB6neVUfY4nKLnL0h2EMGIJ9wvvNvIAN92-RE,21194
 zrb/task/base_trigger.py,sha256=jC722rDvodaBLeNaFghkTyv1u0QXrK6BLZUUqcmBJ7Q,4581
 zrb/task/cmd_task.py,sha256=JpClYoEmJTqKSxhuCErXd2kHLS3Hk2zXeYnl7entNeU,10378
 zrb/task/http_check.py,sha256=Gf5rOB2Se2EdizuN9rp65HpGmfZkGc-clIAlHmPVehs,2565
-zrb/task/llm_task.py,sha256=ZEdjCdq0_6jmE0r3PBuFYBC_XX5hmslYY8JE8XJ1Aa0,12511
+zrb/task/llm_task.py,sha256=hU1waf3NFc41YxdIe0k9z1eKrcPDaBUo4imuEq737TU,7782
 zrb/task/make_task.py,sha256=PD3b_aYazthS8LHeJsLAhwKDEgdurQZpymJDKeN60u0,2265
 zrb/task/rsync_task.py,sha256=pVVslZ46qgcpU_EKhyTQEQie8kUOMuTsVQdbQG2L-yk,6318
 zrb/task/scaffolder.py,sha256=rME18w1HJUHXgi9eTYXx_T2G4JdqDYzBoNOkdOOo5-o,6806
@@ -291,7 +293,7 @@ zrb/util/file.py,sha256=cBPkIonfcWytoqtG3ScJd6FFK7HVYeCIuLmfAFO1HIQ,791
 zrb/util/git.py,sha256=o_kLF1fySv5uQdLlhY-ztc-z0zLOdcDf0IpuPAl2ciA,4733
 zrb/util/git_subtree.py,sha256=US8oCHUOKgt14Ie6SaEelwTs__jLGLPsDQZvI-1P4KY,2640
 zrb/util/group.py,sha256=Bg7HrSycoK110U5s_Tca6-uUQuZ5CMgb8wxZSrvDQ98,2790
-zrb/util/llm/tool.py,sha256=Ux58wYSymVCXxgIWDUObsluZzYzmfyB0uwgKagL0bVg,1898
+zrb/util/llm/tool.py,sha256=NkENrUlGxcqqU7jzHAH7DBXNcm_ndEo2dFnJ5nhvWmk,2991
 zrb/util/load.py,sha256=i8_83ApWJXlZlbFMNfEptrOzfXdvtaIhAErsd6tU9y8,1649
 zrb/util/run.py,sha256=DGHUP9x1Q8V8UF3FbpmjLGuhVVCCLfjTH2teT8qXlNI,207
 zrb/util/string/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -301,7 +303,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.0.0b3.dist-info/METADATA,sha256=G9In8MllPsV3At12vaqC0fCmbj5QRDWB-bYLEt_LeWs,4224
-zrb-1.0.0b3.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-zrb-1.0.0b3.dist-info/entry_points.txt,sha256=-Pg3ElWPfnaSM-XvXqCxEAa-wfVI6BEgcs386s8C8v8,46
-zrb-1.0.0b3.dist-info/RECORD,,
+zrb-1.0.0b5.dist-info/METADATA,sha256=BhCdzcbWjo2XbxLbBVo7JtQpGUAnQS1CnKyRgTkN-cM,4228
+zrb-1.0.0b5.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+zrb-1.0.0b5.dist-info/entry_points.txt,sha256=-Pg3ElWPfnaSM-XvXqCxEAa-wfVI6BEgcs386s8C8v8,46
+zrb-1.0.0b5.dist-info/RECORD,,