universal-mcp-agents 0.1.10__py3-none-any.whl → 0.1.12__py3-none-any.whl

universal_mcp/applications/ui/app.py

@@ -1,10 +1,12 @@
-import re
-from typing import Literal, TypedDict
+import os
+from typing import Any, Literal, TypedDict
 
+from dotenv import load_dotenv
 import httpx
-from loguru import logger
-from markitdown import MarkItDown
 from universal_mcp.applications.application import BaseApplication
+from markitdown import MarkItDown
+
+load_dotenv()
 
 
 class SeriesItem(TypedDict):
@@ -35,6 +37,8 @@ class UiApp(BaseApplication):
         """Initialize the DefaultToolsApp"""
         super().__init__(name="ui")
         self.markitdown = MarkItDown(enable_plugins=True)
+        self.exa_base_url = "https://api.exa.ai"
+        self.exa_api_key = os.getenv("EXA_API_KEY")
 
     def create_bar_chart(
         self,
@@ -118,162 +122,136 @@ class UiApp(BaseApplication):
         """
         return "Success"
 
-    def _handle_response(self, response: httpx.Response):
-        """
-        Handle the HTTP response, returning JSON if possible, otherwise text.
-        """
+    def _fetch_exa(self, endpoint: str, body: dict, error_solution: str) -> dict[str, Any]:
+        if not self.exa_api_key:
+            return {
+                "isError": True,
+                "error": "EXA_API_KEY is not configured",
+                "solution": error_solution,
+            }
+
+        url = f"{self.exa_base_url}{endpoint}"
+        headers = {
+            "Content-Type": "application/json",
+            "x-api-key": self.exa_api_key,
+        }
         try:
+            response = httpx.post(url, json=body, headers=headers)
+            response.raise_for_status()
             return response.json()
-        except Exception:
-            logger.warning(
-                f"Response is not JSON, returning text. Content-Type: {response.headers.get('content-type')}"
-            )
+        except Exception as e:
             return {
-                "text": response.text,
-                "status_code": response.status_code,
-                "headers": dict(response.headers),
+                "isError": True,
+                "error": str(e),
+                "solution": error_solution,
             }
 
-    def http_get(self, url: str, headers: dict | None = None, query_params: dict | None = None):
-        """
-        Perform a GET request to the specified URL with optional parameters.
-
-        Args:
-            url (str): The URL to send the GET request to. Example: "https://api.example.com/data"
-            headers (dict, optional): Optional HTTP headers to include in the request. Example: {"Authorization": "Bearer token"}
-            query_params (dict, optional): Optional dictionary of query parameters to include in the request. Example: {"page": 1}
-
-        Returns:
-            dict: The JSON response from the GET request, or text if not JSON.
-        Tags:
-            get, important
-        """
-        logger.debug(f"GET request to {url} with headers {headers} and query params {query_params}")
-        response = httpx.get(url, params=query_params, headers=headers)
-        response.raise_for_status()
-        return self._handle_response(response)
-
-    def http_post(self, url: str, headers: dict | None = None, body: dict | None = None):
-        """
-        Perform a POST request to the specified URL with optional parameters.
-
-        Args:
-            url (str): The URL to send the POST request to. Example: "https://api.example.com/data"
-            headers (dict, optional): Optional HTTP headers to include in the request. Example: {"Content-Type": "application/json"}
-            body (dict, optional): Optional JSON body to include in the request. Example: {"name": "John"}
-
-        Returns:
-            dict: The JSON response from the POST request, or text if not JSON.
-        Tags:
-            post, important
-        """
-        logger.debug(f"POST request to {url} with headers {headers} and body {body}")
-        response = httpx.post(url, json=body, headers=headers)
-        response.raise_for_status()
-        return self._handle_response(response)
-
-    def http_put(self, url: str, headers: dict | None = None, body: dict | None = None):
+    def web_search(
+        self,
+        query: str,
+        numResults: int | None = None,
+        type: Literal["auto", "keyword", "neural"] | None = None,
+        category: str | None = None,
+        includeDomains: list[str] | None = None,
+        excludeDomains: list[str] | None = None,
+        startPublishedDate: str | None = None,
+        endPublishedDate: str | None = None,
+        maxCharacters: int | None = None,
+    ) -> dict[str, Any]:
         """
-        Perform a PUT request to the specified URL with optional parameters.
+        Search the web using Exa AI - performs real-time web searches with semantic and neural search capabilities. Returns high-quality, relevant results with full content extraction.
 
         Args:
-            url (str): The URL to send the PUT request to. Example: "https://api.example.com/data/1"
-            headers (dict, optional): Optional HTTP headers to include in the request. Example: {"Authorization": "Bearer token"}
-            body (dict, optional): Optional JSON body to include in the request. Example: {"name": "Jane"}
+            query (str): Search query.
+            numResults (Optional[int]): Number of search results to return.
+            type (Optional[str]): Search type - auto lets Exa decide, keyword for exact matches, neural for semantic search.
+            category (Optional[str]): Category to focus the search on.
+            includeDomains (Optional[List[str]]): List of domains to specifically include in search results.
+            excludeDomains (Optional[List[str]]): List of domains to specifically exclude from search results.
+            startPublishedDate (Optional[str]): Start date for published content (YYYY-MM-DD format).
+            endPublishedDate (Optional[str]): End date for published content (YYYY-MM-DD format).
+            maxCharacters (Optional[int]): Maximum characters to extract from each result.
 
         Returns:
-            dict: The JSON response from the PUT request, or text if not JSON.
-        Tags:
-            put, important
-        """
-        logger.debug(f"PUT request to {url} with headers {headers} and body {body}")
-        response = httpx.put(url, json=body, headers=headers)
-        response.raise_for_status()
-        return self._handle_response(response)
-
-    def http_delete(self, url: str, headers: dict | None = None, body: dict | None = None):
-        """
-        Perform a DELETE request to the specified URL with optional parameters.
-
-        Args:
-            url (str): The URL to send the DELETE request to. Example: "https://api.example.com/data/1"
-            headers (dict, optional): Optional HTTP headers to include in the request. Example: {"Authorization": "Bearer token"}
-            body (dict, optional): Optional JSON body to include in the request. Example: {"reason": "obsolete"}
+            dict[str, Any]: Exa search response. On error, returns { isError, error, solution }.
 
-        Returns:
-            dict: The JSON response from the DELETE request, or text if not JSON.
         Tags:
-            delete, important
-        """
-        logger.debug(f"DELETE request to {url} with headers {headers} and body {body}")
-        response = httpx.delete(url, json=body, headers=headers)
-        response.raise_for_status()
-        return self._handle_response(response)
-
-    def http_patch(self, url: str, headers: dict | None = None, body: dict | None = None):
-        """
-        Perform a PATCH request to the specified URL with optional parameters.
-
-        Args:
-            url (str): The URL to send the PATCH request to. Example: "https://api.example.com/data/1"
-            headers (dict, optional): Optional HTTP headers to include in the request. Example: {"Authorization": "Bearer token"}
-            body (dict, optional): Optional JSON body to include in the request. Example: {"status": "active"}
-
-        Returns:
-            dict: The JSON response from the PATCH request, or text if not JSON.
-        Tags:
-            patch, important
+            important
         """
-        logger.debug(f"PATCH request to {url} with headers {headers} and body {body}")
-        response = httpx.patch(url, json=body, headers=headers)
-        response.raise_for_status()
-        return self._handle_response(response)
+        # Build request body
+        request_body: dict[str, Any] = {
+            "query": query,
+            "type": type or "auto",
+            "numResults": numResults or 5,
+            "contents": {
+                "text": {"maxCharacters": maxCharacters or 3000},
+                "livecrawl": "preferred",
+            },
+        }
+
+        # Optional fields (only include if provided)
+        if category is not None:
+            request_body["category"] = category
+        if includeDomains:
+            request_body["includeDomains"] = includeDomains
+        if excludeDomains:
+            request_body["excludeDomains"] = excludeDomains
+        if startPublishedDate is not None:
+            request_body["startPublishedDate"] = startPublishedDate
+        if endPublishedDate is not None:
+            request_body["endPublishedDate"] = endPublishedDate
+
+        error_solution = (
+            "A web search error occurred. First, explain to the user what caused this specific "
+            "error and how they can resolve it. Then provide helpful information based on your "
+            "existing knowledge to answer their question."
+        )
+
+        result = self._fetch_exa("/search", request_body, error_solution)
+
+        # Add guide if not an error
+        if not result.get("isError"):
+            result["guide"] = (
+                "Use the search results to answer the user's question. Summarize the content and ask if "
+                "they have any additional questions about the topic."
+            )
+        return result
 
-    async def read_file(self, uri: str) -> str:
+    def web_content(
+        self,
+        urls: list[str],
+        maxCharacters: int | None = None,
+        livecrawl: Literal["always", "fallback", "preferred"] | None = None,
+    ) -> dict[str, Any]:
         """
-        This tool aims to extract the main text content from any url.
-        When faced with a question you do not know the answer to, call this tool as often as
-        needed to get the full context from any file in the user file attachments section.
+        Extract detailed content from specific URLs using Exa AI - retrieves full text content, metadata, and structured information from web pages with live crawling capabilities.
 
-        Asynchronously converts a URI or local file path to markdown format
-        using the markitdown converter.
         Args:
-            uri (str): The URI pointing to the resource or a local file path.
-                       Supported schemes:
-                       - http:// or https:// (Web pages, feeds, APIs)
-                       - file:// (Local or accessible network files)
-                       - data: (Embedded data)
+            urls (List[str]): List of URLs to extract content from.
+            maxCharacters (Optional[int]): Maximum characters to extract from each URL.
+            livecrawl (Optional[str]): Live crawling preference - always forces live crawl, fallback uses cache first, preferred tries live first.
 
         Returns:
-            A string containing the markdown representation of the content at the specified URI
-
-        Raises:
-            ValueError: If the URI is invalid, empty, or uses an unsupported scheme
-                        after automatic prefixing.
+            dict[str, Any]: Exa contents response. On error, returns { isError, error, solution }.
 
         Tags:
-            convert, markdown, async, uri, transform, document, important
+            important
         """
-        if not uri:
-            raise ValueError("URI cannot be empty")
-
-        known_schemes = ["http://", "https://", "file://", "data:"]
-        has_scheme = any(uri.lower().startswith(scheme) for scheme in known_schemes)
-        if not has_scheme and not re.match(r"^[a-zA-Z]+:", uri):
-            if re.match(r"^[a-zA-Z]:[\\/]", uri):  # Check for Windows drive letter path
-                normalized_path = uri.replace("\\", "/")  # Normalize backslashes
-                processed_uri = f"file:///{normalized_path}"
-            else:  # Assume Unix-like path or simple relative path
-                processed_uri = (
-                    f"file://{uri}" if uri.startswith("/") else f"file:///{uri}"
-                )  # Add leading slash if missing for absolute paths
-
-            uri_to_process = processed_uri
-        else:
-            # Use the uri as provided
-            uri_to_process = uri
-
-        return self.markitdown.convert_uri(uri_to_process).markdown
+        request_body: dict[str, Any] = {
+            "ids": urls,
+            "contents": {
+                "text": {"maxCharacters": maxCharacters or 3000},
+                "livecrawl": livecrawl or "preferred",
+            },
+        }
+
+        error_solution = (
+            "A web content extraction error occurred. First, explain to the user what caused this "
+            "specific error and how they can resolve it. Then provide helpful information based on "
+            "your existing knowledge to answer their question."
+        )
+
+        return self._fetch_exa("/contents", request_body, error_solution)
 
     def list_tools(self):
         """List all available tool methods in this application.
@@ -286,10 +264,6 @@ class UiApp(BaseApplication):
             self.create_line_chart,
             self.create_pie_chart,
             self.create_table,
-            self.http_get,
-            self.http_post,
-            self.http_put,
-            self.http_delete,
-            self.http_patch,
-            self.read_file,
+            self.web_search,
+            self.web_content,
         ]

{universal_mcp_agents-0.1.10.dist-info → universal_mcp_agents-0.1.12.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: universal-mcp-agents
-Version: 0.1.10
+Version: 0.1.12
 Summary: Add your description here
 Project-URL: Homepage, https://github.com/universal-mcp/applications
 Project-URL: Repository, https://github.com/universal-mcp/applications

universal_mcp_agents-0.1.12.dist-info/RECORD

@@ -0,0 +1,65 @@
+universal_mcp/agents/__init__.py,sha256=xQ0Yoln3f0MQrqTQhAZ0im7Tp1DawEJ04YPp20Nw1DQ,1244
+universal_mcp/agents/base.py,sha256=le5vy02eXN15u8ntHWCu6Y-LgOmE_DA8tWmPOmLohAk,6908
+universal_mcp/agents/cli.py,sha256=Yv9g8VHOyK__V7me4UcWsWIXiviPz7F1vqMYH1jkCms,1016
+universal_mcp/agents/hil.py,sha256=_5PCK6q0goGm8qylJq44aSp2MadP-yCPvhOJYKqWLMo,3808
+universal_mcp/agents/llm.py,sha256=hVRwjZs3MHl5_3BWedmurs2Jt1oZDfFX0Zj9F8KH7fk,1787
+universal_mcp/agents/react.py,sha256=8XQvJ0HLVgc-K0qn9Ml48WGcgUGuIKtL67HatlT6Da0,3334
+universal_mcp/agents/simple.py,sha256=NSATg5TWzsRNS7V3LFiDG28WSOCIwCdcC1g7NRwg2nM,2095
+universal_mcp/agents/utils.py,sha256=QeysgwRCHvoe7LpIQkD05y9FGG7us4kWA8ApNj2ACr8,5274
+universal_mcp/agents/bigtool/__init__.py,sha256=uTA6KzZlRhL2reAUazwYmwCHFt9q4hERo27e13ifBX4,2250
+universal_mcp/agents/bigtool/__main__.py,sha256=a15OUoqPR938x7eseWtxu0aLX7lRS3nu8k5Ks3giUY4,472
+universal_mcp/agents/bigtool/agent.py,sha256=anXjMgFWS95RYrnQsZJJxYq8HoCB6z9Poi-Uv5fhPis,266
+universal_mcp/agents/bigtool/context.py,sha256=ny7gd-vvVpUOYAeQbAEUT0A6Vm6Nn2qGywxTzPBzYFg,929
+universal_mcp/agents/bigtool/graph.py,sha256=DEsuSm9OYWBTeGEmvPk_nv_yb7EvCflHe4pbja5-jC0,4337
+universal_mcp/agents/bigtool/prompts.py,sha256=Rz30qNGdscDG65vMj9d0Vfe7X1pQjBDQBBNc3BuyC94,1886
+universal_mcp/agents/bigtool/state.py,sha256=TQeGZD99okclkoCh5oz-VYIlEsC9yLQyDpnBnm7QCN8,759
+universal_mcp/agents/bigtool/tools.py,sha256=ynyEj9mVwKKDhxm76sjspyH51SFi63g2Vydi39pY0qY,5562
+universal_mcp/agents/builder/__main__.py,sha256=XaXpJNwkj5Os1Vn1er8wokPKd4O4WW_L2XkGkvqEhao,4912
+universal_mcp/agents/builder/builder.py,sha256=1p32txpFlG1l6XP1N5UOFAhNnQS02nmvA_uMDO5i-m4,9015
+universal_mcp/agents/builder/prompts.py,sha256=RFzDBdGxF5BsAQL09BVas9RjAwt_Q2ZACghG5pOxqas,8623
+universal_mcp/agents/builder/state.py,sha256=7DeWllxfN-yD6cd9wJ3KIgjO8TctkJvVjAbZT8W_zqk,922
+universal_mcp/agents/codeact/__init__.py,sha256=rLE8gvOo5H4YSr71DRq76b3RV3uuotxuAy_VnBVaVwk,60
+universal_mcp/agents/codeact/__main__.py,sha256=W2cHXRwH1dZG3ETIkMwUqA_d62K3IctHP-FDZWDjxdw,1067
+universal_mcp/agents/codeact/agent.py,sha256=RRMeXVgn3Ow2gxhDKszx9hSUYGDTk6yqqDVyNIOu5kI,9778
+universal_mcp/agents/codeact/models.py,sha256=2fdAcF5bxWDpljjEwDEdPBflTMShSPwwncHrphRjsYg,222
+universal_mcp/agents/codeact/prompts.py,sha256=EMI-imnd0Ps0Bd2FOvSqgiicvvtFFu0MF9s93PiC_3k,4493
+universal_mcp/agents/codeact/sandbox.py,sha256=gEAmZ08PovnFmCKP7uIQaKXHFLOyrnuSmoh7E_SHhjQ,2307
+universal_mcp/agents/codeact/state.py,sha256=WTPfpxDlGRnlr5tZuXMg_KU7GS7TZbnrIKslOvZLbQI,565
+universal_mcp/agents/codeact/utils.py,sha256=JUbT_HYGS_D1BzmzoVpORIe7SGur1KgJguTZ_1tZ4JY,1918
+universal_mcp/agents/codeact0/__init__.py,sha256=rLE8gvOo5H4YSr71DRq76b3RV3uuotxuAy_VnBVaVwk,60
+universal_mcp/agents/codeact0/__main__.py,sha256=V2wLWW9ym3rtiSvPEs-N0Mki7G5dYHzV5dAsAoF-ygQ,1148
+universal_mcp/agents/codeact0/agent.py,sha256=e1v_XVRqblKrAgrkyiPz7bs4atgDRTVHPnZQUjnT_4o,6495
+universal_mcp/agents/codeact0/config.py,sha256=H-1woj_nhSDwf15F63WYn723y4qlRefXzGxuH81uYF0,2215
+universal_mcp/agents/codeact0/langgraph_graph.py,sha256=mP3JrZ1I-Cqhk6E2DMRHUdLFevpyyad-Y3qhERn45JA,550
+universal_mcp/agents/codeact0/legacy_codeact.py,sha256=Lj4oH-AaP1zg6ifBkUxzWJcwMs9X5SepGzzZ6S5QMSg,4096
+universal_mcp/agents/codeact0/llm_tool.py,sha256=GEG8L2crRPyO5la_wlHohuqI9m6xH9KXgQxcP5fCFuU,13814
+universal_mcp/agents/codeact0/prompts.py,sha256=GTUwnxyyUVdeAoAwo4ODGOlEtZStMkoP_lJEFRbDglY,7324
+universal_mcp/agents/codeact0/sandbox.py,sha256=tkrhQoV7sAIT5rtd5kpNYEgDz4y82WSHKpMGE6bqthE,3108
+universal_mcp/agents/codeact0/state.py,sha256=kcoCoz-kd0Ukw1YNGDHNggixCK34KzMl2t6GztakSo4,412
+universal_mcp/agents/codeact0/utils.py,sha256=QIT4XIUln9o3H7MOmMen7i-dhDgvM8q0p--oy9Kbkss,15345
+universal_mcp/agents/codeact0/usecases/1-unsubscribe.yaml,sha256=DiChHW-mNOcaaiec7f_04_A0Xyf9a2ihzXiPA9-Fw1I,239
+universal_mcp/agents/codeact0/usecases/10-reddit2.yaml,sha256=R3vrZZNv_E-m_SuSJ5tSv11HqMomm8Gtxp_LDhkrnAw,618
+universal_mcp/agents/codeact0/usecases/11-github.yaml,sha256=IRom0gDPcj0w0qa2LSARQbvrwJhLGQRaHI2U2rglcG0,650
+universal_mcp/agents/codeact0/usecases/2-reddit.yaml,sha256=-dstvFMjsuP9UQM3B_G1HBn7ImNIMxSCNbITpfwgwAY,2525
+universal_mcp/agents/codeact0/usecases/2.1-instructions.md,sha256=0gQBY_A3jT_lgKNiu6GdyEYupbX0Xz2unlCoTQwv-Es,5098
+universal_mcp/agents/codeact0/usecases/2.2-instructions.md,sha256=Cx-VkcC55MrgFxlMBMBCD83jEge_yZgBWKwtuK1OPFc,4458
+universal_mcp/agents/codeact0/usecases/3-earnings.yaml,sha256=c1ipGMmqafz8zTzGNYyn_4VldC-PB5FY87l8HS9QkOM,344
+universal_mcp/agents/codeact0/usecases/4-maps.yaml,sha256=2KwGE1sFGtP8vEjKZ5Yjlro2j5LzafWbVlFy0E3a1CA,2462
+universal_mcp/agents/codeact0/usecases/5-gmailreply.yaml,sha256=2ExMgk3z453phZocmCw0bmnJXugy79YNaoAfZV5CfMU,593
+universal_mcp/agents/codeact0/usecases/6-contract.yaml,sha256=yVvoz1-pmJVsJSkCtTCuO57Ln5y1Kj7ErkjPyRweJb0,574
+universal_mcp/agents/codeact0/usecases/7-overnight.yaml,sha256=Vod5md6wxmhY4MFkc1soMOpNNDXquVufo48QkM2orz0,731
+universal_mcp/agents/codeact0/usecases/8-sheets_chart.yaml,sha256=aZpdyDMnrHjmV9wMqgV3VXsYGvNPFD58px6ZPjva5PM,1097
+universal_mcp/agents/codeact0/usecases/9-learning.yaml,sha256=MXAgTU1p0Ek1md8dvb5Srb1W6QU4xPUgb6KgNfoza10,535
+universal_mcp/agents/planner/__init__.py,sha256=7nGDDtmPk2LN4s5poIFkflm5ZoyRuQSQ73Qw_4GOov4,1415
+universal_mcp/agents/planner/__main__.py,sha256=OfhTfYDZK_ZUfc8sX-Sa6TWk-dNqD2rl13Ln64mNAtw,771
+universal_mcp/agents/planner/graph.py,sha256=70hhIoEZOcYojpiyVSCedgYpnmxVP7aqdn8s6VBu-D4,3228
+universal_mcp/agents/planner/prompts.py,sha256=_JoHqiAvswtqCDu90AGUHmfsu8eWE1-_yI4LLn3pqMU,657
+universal_mcp/agents/planner/state.py,sha256=qqyp-jSGsCxe1US-PRLT4-y1sITAcVE6nCMlQLnvop0,278
+universal_mcp/agents/shared/prompts.py,sha256=VOsXSUEwBXPaAuxJTUF6bgDGr41u6uctUNQSMRt_OJc,6414
+universal_mcp/agents/shared/tool_node.py,sha256=Ua_wzMt4YgIx4zLp3_ZCow-28qORwrZ2FvKqLPt3RlI,10415
+universal_mcp/applications/llm/__init__.py,sha256=xnpxq4Wl_pevvwtSUtEwcty8_d61ywO1V2YnEXyCREY,46
+universal_mcp/applications/llm/app.py,sha256=iNLU6z2LRZc01GfSKvV0vNzT1LhKAjq_UrSJEmjthjw,6032
+universal_mcp/applications/ui/app.py,sha256=56h9GvkHiELyAVOZvi0YjiowSymlqkJ5GW4O7LmGIPs,9459
+universal_mcp_agents-0.1.12.dist-info/METADATA,sha256=hqXAJNr5hrlsdZHsQwHed6ELV0b0h4q-l8Ar1IpsoEI,878
+universal_mcp_agents-0.1.12.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+universal_mcp_agents-0.1.12.dist-info/RECORD,,

universal_mcp/agents/bigtool2/__init__.py

@@ -1,67 +0,0 @@
-from langgraph.checkpoint.base import BaseCheckpointSaver
-from universal_mcp.logger import logger
-from universal_mcp.tools.registry import ToolRegistry
-from universal_mcp.types import ToolConfig, ToolFormat
-
-from universal_mcp.agents.base import BaseAgent
-from universal_mcp.agents.llm import load_chat_model
-
-from .graph import build_graph
-from .meta_tools import create_meta_tools
-from .prompts import SYSTEM_PROMPT
-
-
-class BigToolAgent2(BaseAgent):
-    def __init__(
-        self,
-        name: str,
-        instructions: str,
-        model: str,
-        registry: ToolRegistry,
-        memory: BaseCheckpointSaver | None = None,
-        tools: ToolConfig | None = None,
-        **kwargs,
-    ):
-        super().__init__(name, instructions, model, memory, **kwargs)
-
-        self.registry = registry
-        self.llm = load_chat_model(self.model)
-        self.recursion_limit = kwargs.get("recursion_limit", 10)
-        self.tools = tools or {}
-        if "ui" not in self.tools:
-            # self.tools["ui"] = ["create_bar_chart", "create_line_chart", "create_pie_chart", "create_table", "http_get", "http_post", "http_put", "http_delete", "http_patch", "read_file"]
-            self.tools["ui"] = ["create_table"]
-
-        logger.info(f"BigToolAgent '{self.name}' initialized with model '{self.model}'.")
-
-    def _build_system_message(self):
-        return SYSTEM_PROMPT.format(
-            name=self.name,
-            instructions=f"**User Instructions:**\n{self.instructions}",
-        )
-
-    async def _build_graph(self):
-        """Build the bigtool agent graph using the existing create_agent function."""
-        logger.info(f"Building graph for BigToolAgent '{self.name}'...")
-        try:
-            default_tools = await self.registry.export_tools(self.tools, ToolFormat.LANGCHAIN)
-            graph_builder = build_graph(
-                tool_registry=self.registry,
-                llm=self.llm,
-                system_prompt=self._build_system_message(),
-                default_tools=default_tools,
-            )
-
-            compiled_graph = graph_builder.compile(checkpointer=self.memory)
-            logger.info("Graph built and compiled successfully.")
-            return compiled_graph
-        except Exception as e:
-            logger.error(f"Error building graph for BigToolAgent '{self.name}': {e}")
-            raise
-
-    @property
-    def graph(self):
-        return self._graph
-
-
-__all__ = ["BigToolAgent2", "create_meta_tools"]

universal_mcp/agents/bigtool2/__main__.py

@@ -1,23 +0,0 @@
-import asyncio
-
-from loguru import logger
-from universal_mcp.agentr.registry import AgentrRegistry
-
-from universal_mcp.agents.bigtool2 import BigToolAgent2
-from universal_mcp.agents.utils import messages_to_list
-
-
-async def main():
-    agent = BigToolAgent2(
-        name="bigtool",
-        instructions="You are a helpful assistant that can use tools to help the user.",
-        model="azure/gpt-4.1",
-        registry=AgentrRegistry(),
-    )
-    await agent.ainit()
-    output = await agent.invoke(user_input="Send an email to manoj@agentr.dev")
-    logger.info(messages_to_list(output["messages"]))
-
-
-if __name__ == "__main__":
-    asyncio.run(main())

universal_mcp/agents/bigtool2/agent.py

@@ -1,13 +0,0 @@
-from universal_mcp.agentr.registry import AgentrRegistry
-
-from universal_mcp.agents.bigtool2 import BigToolAgent2
-
-
-async def agent():
-    agent_object = await BigToolAgent2(
-        name="BigTool Agent 2",
-        instructions="You are a helpful assistant that can use various tools to complete tasks.",
-        model="anthropic/claude-4-sonnet-20250514",
-        registry=AgentrRegistry(),
-    )._build_graph()
-    return agent_object

universal_mcp/agents/bigtool2/graph.py

@@ -1,155 +0,0 @@
-import json
-from datetime import UTC, datetime
-from typing import Literal, cast
-
-from langchain_core.language_models import BaseChatModel
-from langchain_core.messages import AIMessage, ToolMessage
-from langchain_core.tools import BaseTool
-from langgraph.graph import StateGraph
-from langgraph.types import Command
-from universal_mcp.logger import logger
-from universal_mcp.tools.registry import ToolRegistry
-from universal_mcp.types import ToolFormat
-
-from universal_mcp.agents.bigtool2.meta_tools import create_meta_tools
-from universal_mcp.agents.bigtool2.state import State
-
-
-def build_graph(tool_registry: ToolRegistry, llm: BaseChatModel, system_prompt: str, default_tools: list[BaseTool]):
-    # Instantiate meta tools (search, load, web_search)
-    search_tools, load_tools, web_search = create_meta_tools(tool_registry)
-
-    async def call_model(
-        state: State,
-    ) -> Command[Literal["select_tools", "call_tools"]]:
-        logger.info("Calling model...")
-        try:
-            system_message = system_prompt.format(system_time=datetime.now(tz=UTC).isoformat())
-            messages = [
-                {"role": "system", "content": system_message},
-                *state["messages"],
-            ]
-
-            logger.info(f"Selected tool IDs: {state['selected_tool_ids']}")
-            if len(state["selected_tool_ids"]) > 0:
-                selected_tools = await tool_registry.export_tools(
-                    tools=state["selected_tool_ids"], format=ToolFormat.LANGCHAIN
-                )
-                logger.info(f"Exported {len(selected_tools)} tools for model.")
-            else:
-                selected_tools = []
-
-            model = llm
-
-            tools = [search_tools, load_tools, web_search, *default_tools, *selected_tools]
-            # Remove duplicates based on tool name
-            seen_names = set()
-            unique_tools = []
-            for tool in tools:
-                if tool.name not in seen_names:
-                    seen_names.add(tool.name)
-                    unique_tools.append(tool)
-            tools = unique_tools
-            model_with_tools = model.bind_tools(
-                tools,
-                tool_choice="auto",
-            )
-            response = cast(AIMessage, await model_with_tools.ainvoke(messages))
-
-            if response.tool_calls:
-                logger.info(f"Model responded with {len(response.tool_calls)} tool calls.")
-                return Command(goto="call_tools", update={"messages": [response]})
-            else:
-                logger.info("Model responded with a message, ending execution.")
-                return Command(update={"messages": [response]})
-        except Exception as e:
-            logger.error(f"Error in call_model: {e}")
-            raise
-
-    async def select_tools(state: State) -> Command[Literal["call_model"]]:
-        logger.info("Selecting tools...")
-        try:
-            tool_call = state["messages"][-1].tool_calls[0]
-            searched_tools = await search_tools.ainvoke(input=tool_call["args"])
-            tool_msg = ToolMessage(
-                f"Available tool_ids: {searched_tools}. Call load_tools to select the required tools only.",
-                tool_call_id=tool_call["id"],
-            )
-            return Command(goto="call_model", update={"messages": [tool_msg]})
-        except Exception as e:
-            logger.error(f"Error in select_tools: {e}")
-            raise
-
-    async def call_tools(state: State) -> Command[Literal["call_model"]]:
-        logger.info("Calling tools...")
-        outputs = []
-        recent_tool_ids = []
-        for tool_call in state["messages"][-1].tool_calls:
-            try:
-                # Handle special tools internally (no export needed)
-                if tool_call["name"] == search_tools.name:
-                    search_result = await search_tools.ainvoke(input=tool_call["args"])
-                    outputs.append(
-                        ToolMessage(
-                            content=search_result,
-                            name=tool_call["name"],
-                            tool_call_id=tool_call["id"],
-                        )
-                    )
-                    continue
-
-                if tool_call["name"] == load_tools.name:
-                    selected_tool_ids = await load_tools.ainvoke(tool_call["args"])
-                    outputs.append(
-                        ToolMessage(
-                            content=json.dumps(f"Loaded tools- {selected_tool_ids}"),
-                            name=tool_call["name"],
-                            tool_call_id=tool_call["id"],
-                        )
-                    )
-                    recent_tool_ids = selected_tool_ids
-                    continue
-
-                if tool_call["name"] == web_search.name:
-                    web_search_result = await web_search.ainvoke(input=tool_call["args"])
-                    outputs.append(
-                        ToolMessage(
-                            content=json.dumps(f"Web search result: {web_search_result}"),
-                            name=tool_call["name"],
-                            tool_call_id=tool_call["id"],
-                        )
-                    )
-                    continue
-
-                # For other tools: export and call via registry
-                await tool_registry.export_tools([tool_call["name"]], ToolFormat.LANGCHAIN)
-                tool_result = await tool_registry.call_tool(tool_call["name"], tool_call["args"])
-                outputs.append(
-                    ToolMessage(
-                        content=json.dumps(tool_result),
-                        name=tool_call["name"],
-                        tool_call_id=tool_call["id"],
-                    )
-                )
-                recent_tool_ids.append(tool_call["name"])
-            except Exception as e:
-                logger.error(f"Error executing tool '{tool_call['name']}': {e}")
-                outputs.append(
-                    ToolMessage(
-                        content=json.dumps("Error: " + str(e)),
-                        name=tool_call["name"],
-                        tool_call_id=tool_call["id"],
-                    )
-                )
-        return Command(
-            goto="call_model",
-            update={"messages": outputs, "selected_tool_ids": recent_tool_ids},
-        )
-
-    builder = StateGraph(State)
-
-    builder.add_node(call_model)
-    builder.add_node(select_tools)
-    builder.add_node(call_tools)
-    builder.set_entry_point("call_model")
-    return builder