universal-mcp-agents 0.1.13__py3-none-any.whl → 0.1.14__py3-none-any.whl

universal_mcp/agents/codeact0/agent.py

@@ -18,7 +18,8 @@ from universal_mcp.agents.codeact0.prompts import (
 )
 from universal_mcp.agents.codeact0.sandbox import eval_unsafe, execute_ipython_cell
 from universal_mcp.agents.codeact0.state import CodeActState
-from universal_mcp.agents.codeact0.utils import filter_retry_on, inject_context
+from universal_mcp.agents.utils import filter_retry_on
+from universal_mcp.agents.codeact0.utils import inject_context
 from universal_mcp.agents.llm import load_chat_model
 
 
@@ -63,9 +64,9 @@ class CodeActAgent(BaseAgent):
                 raise ValueError("Tools are configured but no registry is provided")
             # Langchain tools are fine
             exported_tools = await self.registry.export_tools(self.tools_config, ToolFormat.LANGCHAIN)
-        exported_tools.extend([smart_print, data_extractor, ai_classify, call_llm])
-        self.processed_tools = [t if isinstance(t, StructuredTool) else create_tool(t) for t in exported_tools]
-        self.instructions, self.tools_context = create_default_prompt(self.processed_tools, self.instructions)
+        additional_tools= [smart_print, data_extractor, ai_classify, call_llm]
+        additional_tools = [t if isinstance(t, StructuredTool) else create_tool(t) for t in additional_tools]
+        self.instructions, self.tools_context = create_default_prompt(exported_tools, additional_tools, self.instructions)
 
         def call_model(state: CodeActState) -> Command[Literal["sandbox"]]:
             messages = [{"role": "system", "content": self.instructions}] + state["messages"]

universal_mcp/agents/codeact0/langgraph_agent.py

@@ -0,0 +1,17 @@
+import asyncio
+
+from langgraph.checkpoint.memory import MemorySaver
+from rich import print
+from universal_mcp.agentr.registry import AgentrRegistry
+
+from universal_mcp.agents.codeact0.agent import CodeActAgent
+from universal_mcp.agents.utils import messages_to_list
+async def agent():
+    agent_obj = CodeActAgent(
+            name="CodeAct Agent",
+            instructions="Be very concise in your answers.",
+            model="anthropic:claude-4-sonnet-20250514",
+            tools={"google_calendar": ["get_upcoming_events"], "exa" : ["search_with_filters"]},
+            registry=AgentrRegistry()
+        )
+    return await agent_obj._build_graph()

universal_mcp/agents/codeact0/llm_tool.py

@@ -27,7 +27,7 @@ def smart_print(data: Any) -> None:
     Args:
         data: Either a dictionary with string keys, or a list of such dictionaries
     """
-    light_copy(data)
+    print(light_copy(data))
 
 
 def creative_writer(

universal_mcp/agents/codeact0/prompts.py

@@ -1,5 +1,5 @@
 uneditable_prompt = """
-You are Wingman, an AI Assistant created by AgentR. You are a creative, straight-forward and direct principal software engineer.
+You are Wingmen, an AI Assistant created by AgentR. You are a creative, straight-forward and direct principal software engineer.
 
 Your job is to answer the user's question or perform the task they ask for.
 - Answer simple questions (which do not require you to write any code or access any external resources) directly. Note that any operation that involves using ONLY print functions should be answered directly.
@@ -7,19 +7,18 @@ Your job is to answer the user's question or perform the task they ask for.
 - You have access to `execute_ipython_cell` tool that allows you to execute Python code in an IPython notebook cell.
 - In writing or natural language processing tasks DO NOT answer directly. Instead use `execute_ipython_cell` tool with the AI functions provided to you for tasks like summarizing, text generation, classification, data extraction from text or unstructured data, etc.
 - The code you write will be executed in a sandbox environment, and you can use the output of previous executions in your code.
-- Read and understand the output of the previous code snippet and use it to answer the user's request. Note that the code output is not visible to the user, so after the task is complete, you have to give the output to the user in a markdown format.
+- Read and understand the output of the previous code snippet and use it to answer the user's request. Note that the code output is NOT visible to the user, so after the task is complete, you have to give the output to the user in a markdown format.
 - If needed, feel free to ask for more information from the user (without using the execute_ipython_cell tool) to clarify the task.
 
 GUIDELINES for writing code:
 - Variables defined at the top level of previous code snippets can be referenced in your code.
-- External functions which return a dict or list[dict] are ambiguous. Therefore, you MUST explore the structure of the returned data using `smart_print()` statements before using it, printing keys and values.
-- Ensure to not print large amounts of data, use string truncation to limit the output to a few lines when checking the data structure.
+- External functions which return a dict or list[dict] are ambiguous. Therefore, you MUST explore the structure of the returned data using `smart_print()` statements before using it, printing keys and values. `smart_print` truncates long strings from data, preventing huge output logs.
 - When an operation involves running a fixed set of steps on a list of items, run one run correctly and then use a for loop to run the steps on each item in the list.
 - In a single code snippet, try to achieve as much as possible.
-- You can only import libraries that come pre-installed with Python, and these have to be imported at the top of every code snippet where required.
-- Wrap await calls in a function and call it using `asyncio.run` to use async functions.
+- You can only import libraries that come pre-installed with Python.
+- You must wrap await calls in an async function and call it using `asyncio.run`.
+- For displaying final results to the user, you must present your output in markdown format, including image links, so that they are rendered and displayed to the user. The code output is NOT visible to the user.
 
-NOTE: If any function throws an error requiring authentication, provide the user with a Markdown link to the authentication page and prompt them to authenticate.
 """
 import inspect
 import re
@@ -27,6 +26,7 @@ from collections.abc import Sequence
 from datetime import datetime
 
 from langchain_core.tools import StructuredTool
+from universal_mcp.agents.codeact0.utils import schema_to_signature
 
 
 def make_safe_function_name(name: str) -> str:
@@ -119,38 +119,49 @@ def indent(text, prefix, predicate=None):
     return "".join(prefixed_lines)
 
 
+
 def create_default_prompt(
     tools: Sequence[StructuredTool],
+    additional_tools : Sequence[StructuredTool],
     base_prompt: str | None = None,
 ):
-    system_prompt = uneditable_prompt.strip() + (
-        "\n\nIn addition to the Python Standard Library, you can use the following external functions:\n"
+    system_prompt = uneditable_prompt.strip()  + (
+        "\n\nIn addition to the Python Standard Library, you can use the following external functions:"
+        "\n"
     )
     tools_context = {}
     for tool in tools:
-        # Create a safe function name
-        safe_name = make_safe_function_name(tool.name)
-        # Use coroutine if it exists, otherwise use func
         if hasattr(tool, "coroutine") and tool.coroutine is not None:
             tool_callable = tool.coroutine
-            signature = inspect.signature(tool_callable)
             is_async = True
         elif hasattr(tool, "func") and tool.func is not None:
             tool_callable = tool.func
-            signature = inspect.signature(tool_callable)
             is_async = False
-        else:
-            raise ValueError(f"Tool {tool.name} does not have a callable coroutine or function.")
+        system_prompt += f'''{"async " if is_async else ""}{schema_to_signature(tool.args, tool.name)}:
+    """{tool.description}"""
+    ...
+    '''
+        safe_name = make_safe_function_name(tool.name)
         tools_context[safe_name] = tool_callable
-        system_prompt += f'''
-{"async " if is_async else ""}def {safe_name}{str(signature)}:
-    """
-{indent(dedent(tool.description), "    ")}
-    """
+
+    for tool in additional_tools:
+        if hasattr(tool, "coroutine") and tool.coroutine is not None:
+            tool_callable = tool.coroutine
+            is_async = True
+        elif hasattr(tool, "func") and tool.func is not None:
+            tool_callable = tool.func
+            is_async = False
+        system_prompt += f'''{"async " if is_async else ""}def {tool.name} {str(inspect.signature(tool_callable))}:
+    """{tool.description}"""
     ...
-'''
-    system_prompt += f"\n\nThe current time is {datetime.now().strftime('%H:%M:%S')}"
+    '''
+        safe_name = make_safe_function_name(tool.name)
+        tools_context[safe_name] = tool_callable
+
     if base_prompt and base_prompt.strip():
         system_prompt += f"Your goal is to perform the following task:\n\n{base_prompt}"
 
     return system_prompt, tools_context
+
+
+

universal_mcp/agents/codeact0/usecases/11-github.yaml

@@ -1,13 +1,14 @@
 base_prompt: 'Fetch all open issues from the GitHub repository "microsoft/vscode" and add them to a new Google Sheet. Then create corresponding tasks in ClickUp for each issue with descriptions, tags, and "In Progress" status. Delete processed rows from the sheet after creating ClickUp tasks.'
 tools:
 - google_sheet__get_values
+- google_sheet__create_spreadsheet
+- google_sheet__write_values_to_sheet
+- google_sheet__delete_dimensions
+- google_sheet__append_values
+- google_sheet__update_values
 - clickup__tasks_create_new_task
 - clickup__spaces_get_details
 - clickup__lists_get_list_details
 - clickup__tasks_get_list_tasks
-- google_sheet__delete_dimensions
-- google_sheet__update_values
-- google_sheet__get_spreadsheet_metadata
-- google_sheet__batch_get_values_by_range
-- github__list_issues
+- github__search_issues
 - github__update_issue

universal_mcp/agents/codeact0/utils.py

@@ -3,8 +3,6 @@ from collections.abc import Sequence
 from typing import Any
 
 from langchain_core.messages import BaseMessage
-from pydantic import ValidationError
-from requests import JSONDecodeError
 
 
 def light_copy(data):
@@ -74,45 +72,6 @@ def make_safe_function_name(name: str) -> str:
         safe_name = "unnamed_tool"
     return safe_name
 
-
-def filter_retry_on(exc: Exception) -> bool:
-    import httpx
-    import requests
-
-    if isinstance(
-        exc,
-        (
-            ConnectionError,
-            JSONDecodeError,
-            ValidationError,
-        ),
-    ):
-        return True
-    if isinstance(
-        exc,
-        (
-            ValueError,
-            TypeError,
-            ArithmeticError,
-            ImportError,
-            LookupError,
-            NameError,
-            SyntaxError,
-            RuntimeError,
-            ReferenceError,
-            StopIteration,
-            StopAsyncIteration,
-            OSError,
-        ),
-    ):
-        return False
-    if isinstance(exc, httpx.HTTPStatusError):
-        return 500 <= exc.response.status_code < 600
-    if isinstance(exc, requests.HTTPError):
-        return 500 <= exc.response.status_code < 600 if exc.response else True
-    return True
-
-
 def derive_context(code: str, context: dict[str, Any]) -> dict[str, Any]:
     """
     Derive context from code by extracting classes, functions, and import statements.
@@ -176,23 +135,20 @@ def derive_context(code: str, context: dict[str, Any]) -> dict[str, Any]:
 
                 if class_def not in context["classes"]:
                     context["classes"].append(class_def)
-
-        # Extract function definitions (only top-level functions, not class methods)
+        
+        # Extract function definitions (including async)
         for node in ast.walk(tree):
-            if isinstance(node, ast.FunctionDef):
-                # Get the function definition as a string
+            if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)):
                 func_lines = code.split("\n")[node.lineno - 1 : node.end_lineno]
                 func_def = "\n".join(func_lines)
 
-                # Check if this is a top-level function by looking at indentation
-                # Top-level functions should start at column 0 (no indentation)
+                # Only top-level functions (col_offset == 0)
                 if node.col_offset == 0:
-                    # Clean up the function definition (remove leading/trailing whitespace)
                     func_def = func_def.strip()
-
                     if func_def not in context["functions"]:
                         context["functions"].append(func_def)
 
+
     except SyntaxError:
         # If the code has syntax errors, try a simpler regex-based approach
 
@@ -351,24 +307,47 @@ def inject_context(
                 exec(function_definition, namespace)
             except Exception:
                 # If execution fails, try to extract function name and create placeholder
-                import re
-
-                func_match = re.search(r"def\s+(\w+)", function_definition)
+                func_match = re.search(r"(async\s+)?def\s+(\w+)", function_definition)
                 if func_match:
-                    func_name = func_match.group(1)
+                    func_name = func_match.group(2)
+                    is_async = bool(func_match.group(1))
 
-                    # Create a placeholder function
-                    def placeholder_func(*args, **kwargs):
-                        raise NotImplementedError(f"Function '{func_name}' failed to load: {str(e)}")
+                    if is_async:
+                        async def placeholder_func(*args, **kwargs):
+                            raise NotImplementedError(f"Async function '{func_name}' failed to load: {str(e)}")
+                    else:
+                        def placeholder_func(*args, **kwargs):
+                            raise NotImplementedError(f"Function '{func_name}' failed to load: {str(e)}")
 
                     placeholder_func.__name__ = func_name
                     namespace[func_name] = placeholder_func
-                else:
-                    # If we can't extract function name, create a generic placeholder
-                    def generic_placeholder_func(*args, **kwargs):
-                        raise NotImplementedError(f"Function definition failed to load: {str(e)}")
-
-                    generic_placeholder_func.__name__ = f"func_{len(namespace)}"
-                    namespace[generic_placeholder_func.__name__] = generic_placeholder_func
 
     return namespace
+
+def schema_to_signature(schema: dict, func_name="my_function") -> str:
+    type_map = {
+        "integer": "int",
+        "string": "str",
+        "boolean": "bool",
+        "null": "None",
+    }
+
+    params = []
+    for name, meta in schema.items():
+        # figure out type
+        if "type" in meta:
+            typ = type_map.get(meta["type"], "Any")
+        elif "anyOf" in meta:
+            types = [type_map.get(t["type"], "Any") for t in meta["anyOf"]]
+            typ = " | ".join(set(types))
+        else:
+            typ = "Any"
+
+        default = meta.get("default", None)
+        default_repr = repr(default)
+
+        params.append(f"{name}: {typ} = {default_repr}")
+
+    # join into signature
+    param_str = ",\n    ".join(params)
+    return f"def {func_name}(\n    {param_str},\n):"

universal_mcp/agents/shared/__main__.py

@@ -0,0 +1,43 @@
+import asyncio
+
+from rich import print
+from universal_mcp.agentr.registry import AgentrRegistry
+from universal_mcp.agents.llm import load_chat_model
+from universal_mcp.agents.shared.tool_node import build_tool_node_graph
+from universal_mcp.logger import setup_logger
+
+
+async def main():
+    """
+    An example of how to run the tool_node graph independently.
+    """
+    setup_logger(level="INFO")
+
+    user_input = "What are the topics of my meetings today from Google Calendar and who are the attendees? Give a 1-line context for each attendee using LinkedIn or web search."
+
+    print(f"▶️  User Task: [bold cyan]'{user_input}'[/bold cyan]\n")
+
+    llm = load_chat_model("azure/gpt-4.1", thinking=False)
+    registry = AgentrRegistry()
+
+    graph = build_tool_node_graph(llm=llm, registry=registry)
+
+    initial_state = {"original_task": user_input}
+
+    print("🚀 Invoking the tool selection graph...")
+    final_state = await graph.ainvoke(initial_state)
+
+    execution_plan = final_state.get("execution_plan")
+
+    print("\n[bold green]✅ Graph execution complete![/bold green]")
+    print("\n--- Final Execution Plan (Selected Tools) ---")
+    if execution_plan:
+        print(execution_plan)
+    else:
+        print("[bold red]No execution plan was created.[/bold red]")
+        if messages := final_state.get("messages"):
+            print(f"Final Message: {messages[-1].content}")
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

universal_mcp/agents/shared/prompts.py

@@ -1,132 +1,83 @@
-TASK_DECOMPOSITION_PROMPT = """
-You are an expert planner. Your goal is to consolidate a complex user request into the minimum number of high-level sub-tasks required. Each sub-task should correspond to a major, consolidated action within a single target application.
+TOOL_SEARCH_QUERIES_PROMPT = """
+You are an expert at breaking down a complex user task into a list of simple, atomic search queries for finding tools. Your goal is to generate a list of queries that will cover all aspects of the user's request.
 
 **CORE PRINCIPLES:**
-1.  **App-Centric Grouping:** Group all related actions for a single application into ONE sub-task.
-2.  **Focus on Data Handoffs:** A good decomposition often involves one sub-task to *retrieve* information and a subsequent sub-task to *use* that information.
-3.  **Assume Internal Capabilities:** Do NOT create sub-tasks for abstract cognitive work like 'summarize' or 'analyze'.
-4.  **Simplify Single Actions:** If the user's task is already a single, simple action, the output should be a single sub-task that concisely describes that action. Do not make it identical to the user's input.
-5.  **General purpose sub tasks:** You also need to realise that these subtasks are going to be used to search for tools and apps. And the names and description of these tools and apps are going to be general in nature so the sub tasks should not be too specific. The task which you will get may be specific in nature but the sub taks must be general.
+1.  **Deconstruct the Task:** Analyze the user's request and identify the distinct actions or sub-tasks required.
+2.  **Include Application Context:** If the user mentions a specific application (e.g., Gmail, Google Docs, Exa), include it in the query.
+3.  **Focus on the Action:** Each query must describe a general capability. It should combine the core action (verb) and the general type of object it acts on (e.g., "create document", "get pull requests", "web search").
+4.  **STRIP SPECIFIC DETAILS:** **This is critical.** Do NOT include specific data, parameters, names, or details from the user's prompt in your queries. Your goal is to find a general tool, not to run the specific command.
+
 **--- EXAMPLES ---**
 
 **EXAMPLE 1:**
 - **User Task:** "Create a Google Doc summarizing the last 5 merged pull requests in my GitHub repo universal-mcp/universal-mcp."
-- **CORRECT DECOMPOSITION:**
-    - "Fetch the last 5 merged pull requests from the GitHub repository 'universal-mcp/universal-mcp'."
-    - "Create a new Google Doc containing the summary of the pull requests."
+- **CORRECT QUERIES:**
+    - "github get pull requests from repository"
+    - "google docs create document"
+    - "google docs append text to document"
+- **INCORRECT QUERIES:**
+    - "github get pull requests from universal-mcp/universal-mcp" (Contains specific repo name)
+    - "google docs create 'summary' document" (Contains specific document title)
+
 
 **EXAMPLE 2:**
-- **User Task:** "Find the best restaurants in Goa using perplexity web search."
-- **CORRECT DECOMPOSITION:**
-    - "Perform a web search using Perplexity to find the best restaurants in Goa."
+- **User Task:** "Find the best restaurants in Goa using exa web search, then email the list to my friend at test@example.com."
+- **CORRECT QUERIES:**
+    - "exa web search"
+    - "send email"
+- **INCORRECT QUERIES:**
+    - "exa search for best restaurants in Goa" (Contains specific search details)
+    - "email list to test@example.com" (Contains specific parameters)
+
+**EXAMPLE 3:**
+- **User Task:** "add an event to my google calendar at 2pm called 'Walk in the park'?"
+- **CORRECT QUERIES:**
+    - "google calendar create calendar event"
+- **INCORRECT QUERIES:**
+    - "google calendar create event 'Walk in the park' at 2pm" (Contains specific event details)
 
 **--- YOUR TASK ---**
 
 **USER TASK:**
 "{task}"
 
-**YOUR DECOMPOSITION (as a list of strings):**
+**YOUR SEARCH QUERIES (as a list of strings):**
 """
 
-
-APP_SEARCH_QUERY_PROMPT = """
-You are an expert at selecting an application to perform a specific sub-task. Your goal is to generate a concise query for an app search engine.
-
-Analyze the current sub-task in the context of the original user goal and the ENTIRE PLAN so far.
-
-**CORE INSTRUCTION:** If any application already used in the plan is capable of performing the current sub-task, your query MUST BE the name of that application to ensure continuity and efficiency. Otherwise, generate a concise query for the category of application needed.
-
-**--- EXAMPLES ---**
-
-**EXAMPLE 1: Reusing an app from two steps ago**
-- **Original User Task:** "Find my latest order confirmation in Gmail, search for reviews of the main product on perplexity, and then send an email to ankit@agentr.dev telling about the reviews"
-- **Plan So Far:**
-  - The sub-task 'Find order confirmation in Gmail' was assigned to app 'google_mail'.
-  - The sub-task 'Search for product reviews on perplexity' was assigned to app 'perplexity'.
-- **Current Sub-task:** "send an email to ankit@agentr.dev"
-- **CORRECT QUERY:** "google_mail"
-
-**EXAMPLE 2: First Step (No previous context)**
-- **Original User Task:** "Find the best restaurants in Goa."
-- **Plan So Far:** None. This is the first step.
-- **Current Sub-task:** "Perform a web search to find the best restaurants in Goa."
-- **CORRECT QUERY:** "web search"
-
-**--- YOUR TASK ---**
-
-**Original User Task:**
-"{original_task}"
-
-**Plan So Far:**
-{plan_context}
-
-**Current Sub-task:**
-"{sub_task}"
-
-**YOUR CONCISE APP SEARCH QUERY:**
-"""
-
-
-TOOL_SEARCH_QUERY_PROMPT = """
-You are an expert at summarizing the core *action* of a sub-task into a concise query for finding a tool. This query should ignore any application names.
+APP_SELECTION_PROMPT = """
+You are an AI assistant that selects the most appropriate applications (apps) from a list to accomplish a user's task.
 
 **INSTRUCTIONS:**
-1.  Focus only on the verb or action being performed in the sub-task.
-2.  Include key entities related to the action.
-3.  Do NOT include the names of applications (e.g., "Perplexity", "Gmail").
-4.  You also need to realise that this query is going to be used to search for tools in a particular app. And the names and description of these tools are going to be general in nature so the query should not be too specific. The sub task which you will get may be specific in nature but the query must be general.
-
-**EXAMPLES:**
-- **Sub-task:** "Perform a web search using Perplexity to find the best restaurants in Goa."
-- **Query:** "web search for restaurants"
-
-- **Sub-task:** "Fetch all marketing emails received from Gmail in the last 7 days."
-- **Query:** "get emails by date"
-
-- **Sub-task:** "Create a new Google Doc and append a summary."
-- **Query:** "create document, append text"
-
-**SUB-TASK:**
-"{sub_task}"
-
-**YOUR CONCISE TOOL SEARCH QUERY:**
-"""
-
-REVISE_DECOMPOSITION_PROMPT = """
-You are an expert planner who revises plans that have failed. Your previous attempt to break down a task resulted in a sub-task that could not be matched with any available tools.
-
-**INSTRUCTIONS:**
-1.  Analyze the original user task and the failed sub-task.
-2.  Generate a NEW, alternative decomposition of the original task.
-3.  This new plan should try to achieve the same overall goal but with different, perhaps broader or more combined, sub-tasks to increase the chance of finding a suitable tool.
+1.  Carefully review the original user task to understand the complete goal.
+2.  Examine the list of available apps, their IDs, and their descriptions.
+3.  Select ALL app IDs that are necessary to complete the entire task.
+4.  If the user's task mentions a specific app, you MUST select it.
+5.  If no apps are a good fit, return an empty list.
 
 **ORIGINAL USER TASK:**
 "{task}"
 
-**FAILED SUB-TASK FROM PREVIOUS PLAN:**
-"{failed_sub_task}"
+**AVAILABLE APPS:**
+{app_candidates}
 
-**YOUR NEW, REVISED DECOMPOSITION (as a list of strings):**
+**YOUR SELECTED APP ID(s) (as a list of strings):**
 """
 
-
 TOOL_SELECTION_PROMPT = """
-You are an AI assistant that selects the most appropriate tool(s) from a list to accomplish a specific sub-task.
+You are an AI assistant that selects the most appropriate tool(s) from a list to accomplish a user's overall task.
 
 **INSTRUCTIONS:**
-1.  Carefully review the sub-task to understand the required action.
-2.  Examine the list of available tools and their descriptions.
-3.  Select the best tool ID that matches the sub-task. You are encouraged to select multiple tools if there are multiple tools with similar capabilties
-or names. It is always good to have more tools than having insufficent tools.
-4.  If no tool is a good fit, return an empty list.
-5.  Only return the tool IDs.
-6. You should understand that the sub task maybe specific in nature but the tools are made to be general purpose and therefore the tool_candidates you will get will be very general purpose but that should not stop you from selecting the tools as these tools will be given to a very smart agent who will be able to use these tools for the specific sub-taks
+1.  Carefully review the original user task to understand the complete goal.
+2.  Examine the list of available tools, their IDs, and their descriptions. These tools have been found using a search based on the task.
+3.  Select all tool IDs that are necessary to complete the entire task. It is critical to select all tools needed for a multi-step task.
+4.  If no tools are a good fit for the task, return an empty list.
+5.  Only return the tool IDs. The tools are general purpose, but you are smart enough to see how they can be used for the specific task.
 
-**SUB-TASK:**
-"{sub_task}"
+**ORIGINAL USER TASK:**
+"{task}"
 
 **AVAILABLE TOOLS:**
 {tool_candidates}
 
-**YOUR SELECTED TOOL ID(s):**
-"""
+**YOUR SELECTED TOOL ID(s) (as a list of strings):**
+"""