Merge pull request #1608 from siiddhantt/feat/api-tool

feat: API Tool

application/llm/google_ai.py

@@ -57,25 +57,35 @@ class GoogleLLM(BaseLLM):
         for tool_data in tools_list:
             if tool_data["type"] == "function":
                 function = tool_data["function"]
-                genai_function = dict(
-                    name=function["name"],
-                    description=function["description"],
-                    parameters={
-                        "type": "OBJECT",
-                        "properties": {
-                            k: {
-                                **v,
-                                "type": v["type"].upper() if v["type"] else None,
-                            }
-                            for k, v in function["parameters"]["properties"].items()
+                parameters = function["parameters"]
+                properties = parameters.get("properties", {})
+
+                if properties:
+                    genai_function = dict(
+                        name=function["name"],
+                        description=function["description"],
+                        parameters={
+                            "type": "OBJECT",
+                            "properties": {
+                                k: {
+                                    **v,
+                                    "type": v["type"].upper() if v["type"] else None,
+                                }
+                                for k, v in properties.items()
+                            },
+                            "required": (
+                                parameters["required"]
+                                if "required" in parameters
+                                else []
+                            ),
                         },
-                        "required": (
-                            function["parameters"]["required"]
-                            if "required" in function["parameters"]
-                            else []
-                        ),
-                    },
-                )
+                    )
+                else:
+                    genai_function = dict(
+                        name=function["name"],
+                        description=function["description"],
+                    )
+
                 genai_tool = types.Tool(function_declarations=[genai_function])
                 genai_tools.append(genai_tool)
 

application/tools/agent.py

@@ -26,6 +26,21 @@ class Agent:
         tools_by_id = {str(tool["_id"]): tool for tool in user_tools}
         return tools_by_id
 
+    def _build_tool_parameters(self, action):
+        params = {"type": "object", "properties": {}, "required": []}
+        for param_type in ["query_params", "headers", "body", "parameters"]:
+            if param_type in action and action[param_type].get("properties"):
+                for k, v in action[param_type]["properties"].items():
+                    if v.get("filled_by_llm", True):
+                        params["properties"][k] = {
+                            key: value
+                            for key, value in v.items()
+                            if key != "filled_by_llm" and key != "value"
+                        }
+
+                        params["required"].append(k)
+        return params
+
     def _prepare_tools(self, tools_dict):
         self.tools = [
             {
@@ -33,31 +48,16 @@ class Agent:
                 "function": {
                     "name": f"{action['name']}_{tool_id}",
                     "description": action["description"],
-                    "parameters": {
-                        **action["parameters"],
-                        "properties": {
-                            k: {
-                                key: value
-                                for key, value in v.items()
-                                if key != "filled_by_llm" and key != "value"
-                            }
-                            for k, v in action["parameters"]["properties"].items()
-                            if v.get("filled_by_llm", False)
-                        },
-                        "required": [
-                            key
-                            for key in action["parameters"]["required"]
-                            if key in action["parameters"]["properties"]
-                            and action["parameters"]["properties"][key].get(
-                                "filled_by_llm", False
-                            )
-                        ],
-                    },
+                    "parameters": self._build_tool_parameters(action),
                 },
             }
             for tool_id, tool in tools_dict.items()
-            for action in tool["actions"]
-            if action["active"]
+            for action in (
+                tool["config"]["actions"].values()
+                if tool["name"] == "api_tool"
+                else tool["actions"]
+            )
+            if action.get("active", True)
         ]
 
     def _execute_tool_action(self, tools_dict, call):
@@ -65,18 +65,59 @@ class Agent:
         tool_id, action_name, call_args = parser.parse_args(call)
 
         tool_data = tools_dict[tool_id]
-        action_data = next(
-            action for action in tool_data["actions"] if action["name"] == action_name
+        action_data = (
+            tool_data["config"]["actions"][action_name]
+            if tool_data["name"] == "api_tool"
+            else next(
+                action
+                for action in tool_data["actions"]
+                if action["name"] == action_name
+            )
         )
 
-        for param, details in action_data["parameters"]["properties"].items():
-            if param not in call_args and "value" in details:
-                call_args[param] = details["value"]
+        query_params, headers, body, parameters = {}, {}, {}, {}
+        param_types = {
+            "query_params": query_params,
+            "headers": headers,
+            "body": body,
+            "parameters": parameters,
+        }
+
+        for param_type, target_dict in param_types.items():
+            if param_type in action_data and action_data[param_type].get("properties"):
+                for param, details in action_data[param_type]["properties"].items():
+                    if param not in call_args and "value" in details:
+                        target_dict[param] = details["value"]
+
+        for param, value in call_args.items():
+            for param_type, target_dict in param_types.items():
+                if param_type in action_data and param in action_data[param_type].get(
+                    "properties", {}
+                ):
+                    target_dict[param] = value
 
         tm = ToolManager(config={})
-        tool = tm.load_tool(tool_data["name"], tool_config=tool_data["config"])
-        print(f"Executing tool: {action_name} with args: {call_args}")
-        result = tool.execute_action(action_name, **call_args)
+        tool = tm.load_tool(
+            tool_data["name"],
+            tool_config=(
+                {
+                    "url": tool_data["config"]["actions"][action_name]["url"],
+                    "method": tool_data["config"]["actions"][action_name]["method"],
+                    "headers": headers,
+                    "query_params": query_params,
+                }
+                if tool_data["name"] == "api_tool"
+                else tool_data["config"]
+            ),
+        )
+        if tool_data["name"] == "api_tool":
+            print(
+                f"Executing api: {action_name} with query_params: {query_params}, headers: {headers}, body: {body}"
+            )
+            result = tool.execute_action(action_name, **body)
+        else:
+            print(f"Executing tool: {action_name} with args: {call_args}")
+            result = tool.execute_action(action_name, **parameters)
         call_id = getattr(call, "id", None)
         return result, call_id
 

application/tools/implementations/api_tool.py

@@ -0,0 +1,54 @@
+import json
+
+import requests
+from application.tools.base import Tool
+
+
+class APITool(Tool):
+    """
+    API Tool
+    A flexible tool for performing various API actions (e.g., sending messages, retrieving data) via custom user-specified APIs
+    """
+
+    def __init__(self, config):
+        self.config = config
+        self.url = config.get("url", "")
+        self.method = config.get("method", "GET")
+        self.headers = config.get("headers", {"Content-Type": "application/json"})
+        self.query_params = config.get("query_params", {})
+
+    def execute_action(self, action_name, **kwargs):
+        return self._make_api_call(
+            self.url, self.method, self.headers, self.query_params, kwargs
+        )
+
+    def _make_api_call(self, url, method, headers, query_params, body):
+        if query_params:
+            url = f"{url}?{requests.compat.urlencode(query_params)}"
+        if isinstance(body, dict):
+            body = json.dumps(body)
+        try:
+            print(f"Making API call: {method} {url} with body: {body}")
+            response = requests.request(method, url, headers=headers, data=body)
+            response.raise_for_status()
+            try:
+                data = response.json()
+            except ValueError:
+                data = None
+
+            return {
+                "status_code": response.status_code,
+                "data": data,
+                "message": "API call successful.",
+            }
+        except requests.exceptions.RequestException as e:
+            return {
+                "status_code": response.status_code if response else None,
+                "message": f"API call failed: {str(e)}",
+            }
+
+    def get_actions_metadata(self):
+        return []
+
+    def get_config_requirements(self):
+        return {}