zrb 1.0.0b2__py3-none-any.whl → 1.0.0b4__py3-none-any.whl

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/error_page/show_error_page.py

@@ -23,5 +23,6 @@ def show_error_page(user: User, root_group: AnyGroup, status_code: int, message:
                 "error_status_code": status_code,
                 "error_message": message,
             },
-        )
+        ),
+        status_code=status_code,
     )

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

@@ -13,14 +13,16 @@ const CURRENT_SESSION = {
                 for (const inputName in dataInputs) {
                     const inputValue = dataInputs[inputName];
                     const input = submitTaskForm.querySelector(`[name="${inputName}"]`);
-                    input.value = inputValue;
+                    if (input) {
+                        input.value = inputValue;
+                    }
                 }
                 resultLineCount = data.final_result.split("\n").length;
                 resultTextarea.rows = resultLineCount <= 5 ? resultLineCount : 5;
                 // update text areas
                 resultTextarea.value = data.final_result;
                 logTextarea.value = data.log.join("\n");
-                logTextarea.scrollTop = logTextarea.scrollHeight;
+                // logTextarea.scrollTop = logTextarea.scrollHeight;
                 // visualize history
                 this.showCurrentSession(data.task_status, data.finished);
                 if (data.finished) {

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("input", async function(event) {
+submitTaskForm.addEventListener("change", async function(event) {
     const currentInput = event.target;
-    const inputs = Array.from(submitTaskForm.querySelectorAll("input[name]"));
+    const inputs = Array.from(submitTaskForm.querySelectorAll("input[name], textarea[name], select[name]"));
     const inputMap = {};
     const fixedInputNames = [];
     for (const input of inputs) {
@@ -53,6 +53,12 @@ submitTaskForm.addEventListener("input", async function(event) {
                     return;
                 }
                 const input = submitTaskForm.querySelector(`[name="${key}"]`);
+                if (input === currentInput) {
+                    return;
+                }
+                if (value === "") {
+                    return;
+                }
                 input.value = value;
             });
         } else {

zrb/runner/web_route/task_session_api_route.py

@@ -94,9 +94,54 @@ def serve_task_session_api(
                     if min_start_query is None
                     else datetime.strptime(min_start_query, "%Y-%m-%d %H:%M:%S")
                 )
-                return session_state_logger.list(
-                    task_path, min_start_time, max_start_time, page, limit
+                return sanitize_session_state_log_list(
+                    task,
+                    session_state_logger.list(
+                        task_path, min_start_time, max_start_time, page, limit
+                    ),
                 )
             else:
-                return session_state_logger.read(residual_args[0])
+                return sanitize_session_state_log(
+                    task, session_state_logger.read(residual_args[0])
+                )
         return JSONResponse(content={"detail": "Not found"}, status_code=404)
+
+
+def sanitize_session_state_log_list(
+    task: AnyTask, session_state_log_list: SessionStateLogList
+) -> SessionStateLogList:
+    return SessionStateLogList(
+        total=session_state_log_list.total,
+        data=[
+            sanitize_session_state_log(task, data)
+            for data in session_state_log_list.data
+        ],
+    )
+
+
+def sanitize_session_state_log(
+    task: AnyTask, session_state_log: SessionStateLog
+) -> SessionStateLog:
+    """
+    In session, we create snake_case aliases of inputs.
+    The purpose was to increase ergonomics, so that user can use `input.system_prompt`
+    instead of `input["system-prompt"]`
+    However, when we serve the session through HTTP API,
+    we only want to show the original input names.
+    """
+    enhanced_inputs = session_state_log.input
+    real_inputs = {}
+    for real_input in task.inputs:
+        real_input_name = real_input.name
+        real_inputs[real_input_name] = enhanced_inputs[real_input_name]
+    return SessionStateLog(
+        name=session_state_log.name,
+        start_time=session_state_log.start_time,
+        main_task_name=session_state_log.main_task_name,
+        path=session_state_log.path,
+        input=real_inputs,
+        final_result=session_state_log.final_result,
+        finished=session_state_log.finished,
+        log=session_state_log.log,
+        task_status=session_state_log.task_status,
+    )

zrb/task/base_task.py

@@ -242,28 +242,28 @@ class BaseTask(AnyTask):
     def run(
         self, session: AnySession | None = None, str_kwargs: dict[str, str] = {}
     ) -> Any:
-        loop = asyncio.new_event_loop()
-        try:
-            return loop.run_until_complete(self._run_and_cleanup(session, str_kwargs))
-        finally:
-            loop.close()
+        return asyncio.run(self._run_and_cleanup(session, str_kwargs))
 
     async def _run_and_cleanup(
-        self, session: AnySession | None = None, str_kwargs: dict[str, str] = {}
+        self,
+        session: AnySession | None = None,
+        str_kwargs: dict[str, str] = {},
     ) -> Any:
+        current_task = asyncio.create_task(self.async_run(session, str_kwargs))
         try:
-            result = await self.async_run(session, str_kwargs)
+            result = await current_task
         finally:
-            if not session.is_terminated:
+            if session and not session.is_terminated:
                 session.terminate()
             # Cancel all running tasks except the current one
-            current_task = asyncio.current_task()
             pending = [task for task in asyncio.all_tasks() if task is not current_task]
             for task in pending:
                 task.cancel()
-            # Wait for all tasks to complete with a timeout
             if pending:
-                await asyncio.wait(pending, timeout=5)
+                try:
+                    await asyncio.wait(pending, timeout=5)
+                except asyncio.CancelledError:
+                    pass
         return result
 
     async def async_run(
@@ -274,7 +274,8 @@ class BaseTask(AnyTask):
         # Update session
         self.__fill_shared_context_inputs(session.shared_ctx, str_kwargs)
         self.__fill_shared_context_envs(session.shared_ctx)
-        return await run_async(self.exec_root_tasks(session))
+        result = await run_async(self.exec_root_tasks(session))
+        return result
 
     def __fill_shared_context_inputs(
         self, shared_context: AnySharedContext, str_kwargs: dict[str, str] = {}
@@ -352,7 +353,7 @@ class BaseTask(AnyTask):
             session.get_task_status(self).mark_as_skipped()
             return
         # Wait for task to be ready
-        await run_async(self.__exec_action_until_ready(session))
+        return await run_async(self.__exec_action_until_ready(session))
 
     def __get_execute_condition(self, session: Session) -> bool:
         ctx = self.get_ctx(session)

zrb/task/llm_task.py

@@ -17,6 +17,7 @@ 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]]
 
@@ -24,14 +25,18 @@ ListOfDict = list[dict[str, Any]]
 class AdditionalTool(BaseModel):
     fn: Callable
     name: str | None
-    description: str | None
 
 
 def scratchpad(thought: str) -> str:
-    """Use this tool to note your thought and planning"""
+    """Write your thought, analysis, reasoning, and evaluation here."""
     return thought
 
 
+def end_conversation(final_answer: str) -> str:
+    """End conversation with a final answer containing all necessary information"""
+    return final_answer
+
+
 class LLMTask(BaseTask):
     def __init__(
         self,
@@ -47,11 +52,17 @@ class LLMTask(BaseTask):
         system_prompt: StrAttr | None = LLM_SYSTEM_PROMPT,
         render_system_prompt: bool = True,
         message: StrAttr | None = None,
-        tools: (
-            dict[str, Callable] | Callable[[AnySharedContext], dict[str, Callable]]
-        ) = {},
-        history: ListOfDict | Callable[[AnySharedContext], ListOfDict] = [],
-        history_file: StrAttr | None = None,
+        tools: list[Callable] | Callable[[AnySharedContext], list[Callable]] = [],
+        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]]
@@ -97,84 +108,165 @@ class LLMTask(BaseTask):
         self._render_system_prompt = render_system_prompt
         self._message = message
         self._tools = tools
-        self._history = history
-        self._history_file = history_file
+        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._additional_tools: list[AdditionalTool] = []
 
-    def add_tool(
-        self, tool: Callable, name: str | None = None, description: str | None = None
-    ):
-        self._additional_tools.append(
-            AdditionalTool(fn=tool, name=name, description=description)
-        )
+    def add_tool(self, tool: Callable):
+        self._tools.append(tool)
 
     async def _exec_action(self, ctx: AnyContext) -> Any:
-        from litellm import acompletion, supports_function_calling
+        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:
-            allow_function_call = supports_function_calling(model=model)
+            is_function_call_supported = supports_function_calling(model=model)
         except Exception:
-            allow_function_call = False
-        model_kwargs = self._get_model_kwargs(ctx)
+            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
+        )
+        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)
+        history = await self._read_conversation_history(ctx)
         ctx.log_debug("HISTORY PROMPT", history)
-        user_message = {"role": "user", "content": self._get_message(ctx)}
-        ctx.print(stylize_faint(f"{user_message}"))
-        messages = history + [user_message]
-        available_tools = self._get_tools(ctx)
-        available_tools["scratchpad"] = scratchpad
-        if allow_function_call:
-            tool_schema = [
-                callable_to_tool_schema(tool, name)
-                for name, tool in available_tools.items()
-            ]
-            for additional_tool in self._additional_tools:
-                fn = additional_tool.fn
-                tool_name = additional_tool.name or fn.__name__
-                tool_description = additional_tool.description
-                available_tools[tool_name] = additional_tool.fn
-                tool_schema.append(
-                    callable_to_tool_schema(
-                        fn, name=tool_name, description=tool_description
-                    )
-                )
-            model_kwargs["tools"] = tool_schema
-            ctx.log_debug("TOOL SCHEMA", tool_schema)
-        history_file = self._get_history_file(ctx)
+        conversations = history + [user_message]
         while True:
-            response = await acompletion(
-                model=model,
-                messages=[{"role": "system", "content": system_prompt}] + messages,
-                **model_kwargs,
+            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
+                    await self._write_conversation_history(ctx, 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":
+                        await self._write_conversation_history(ctx, 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,
+    ):
+        # 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
             )
-            response_message = response.choices[0].message
-            ctx.print(stylize_faint(f"{response_message.to_dict()}"))
-            messages.append(response_message.to_dict())
-            tool_calls = response_message.tool_calls
-            if tool_calls:
-                # noqa Reference: https://docs.litellm.ai/docs/completion/function_call#full-code---parallel-function-calling-with-gpt-35-turbo-1106
-                for tool_call in tool_calls:
-                    function_name = tool_call.function.name
-                    function_to_call = available_tools[function_name]
-                    function_kwargs = json.loads(tool_call.function.arguments)
-                    function_response = function_to_call(**function_kwargs)
-                    tool_call_message = {
-                        "tool_call_id": tool_call.id,
-                        "role": "tool",
-                        "name": function_name,
-                        "content": function_response,
-                    }
-                    ctx.print(stylize_faint(f"{tool_call_message}"))
-                    messages.append(tool_call_message)
-                continue
-            if history_file != "":
-                write_file(history_file, json.dumps(messages, indent=2))
-            return response_message.content
+            ctx.print(stylize_faint(f"{tool_execution_message}"))
+            conversations.append(tool_execution_message)
+
+    async def _write_conversation_history(
+        self, ctx: AnyContext, 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,
+        )
+        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}"
+        )
+
+    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(
@@ -192,29 +284,67 @@ 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) -> dict[str, Callable]:
+    def _get_model_kwargs(
+        self, ctx: AnyContext, available_tools: dict[str, Callable]
+    ) -> dict[str, Any]:
+        model_kwargs = {}
         if callable(self._model_kwargs):
-            return self._model_kwargs(ctx)
-        return {**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_tools(self, ctx: AnyContext) -> dict[str, Callable]:
-        if callable(self._tools):
-            return self._tools(ctx)
-        return self._tools
+    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")