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

universal_mcp/applications/llm/app.py

@@ -0,0 +1,158 @@
+import json
+from typing import Any, Literal, cast
+
+from langchain.chat_models import init_chat_model
+from langchain_openai import AzureChatOpenAI
+from pydantic import BaseModel, Field
+from universal_mcp.applications.application import BaseApplication
+
+MAX_RETRIES = 3
+
+
+def _get_context_as_string(source: Any | list[Any] | dict[str, Any]) -> str:
+    """Converts context to a string representation.
+
+    Args:
+        source: The source data to be converted. Can be a single value, a list of values, or a dictionary.
+
+    Returns:
+        A string representation of the source data, formatted with XML-like tags for dictionaries.
+    """
+
+    if not isinstance(source, dict):
+        if isinstance(source, list):
+            source = {f"doc_{i + 1}": str(doc) for i, doc in enumerate(source)}
+        else:
+            source = {"content": str(source)}
+
+    return "\n".join(f"<{k}>\n{str(v)}\n</{k}>" for k, v in source.items())
+
+
+class LLMApp(BaseApplication):
+    """
+    An application for leveraging Large Language Models (LLMs) for advanced text processing tasks.
+    """
+
+    def __init__(self, **kwargs):
+        """Initialize the LLMApp."""
+        super().__init__(name="llm")
+
+    def generate_text(
+        self,
+        task: str,
+        context: Any | list[Any] | dict[str, Any],
+        tone: str = "normal",
+        output_format: Literal["markdown", "html", "plain"] = "markdown",
+        length: Literal["very-short", "concise", "normal", "long"] = "concise",
+    ) -> str:
+        """
+        Generates well-written text for a high-level task using the provided context.
+
+        Use this function for creative writing, summarization, and other text generation tasks.
+
+        Args:
+            task: The main writing task or directive.
+            context: A single string, list of strings, or dictionary mapping labels to content.
+            tone: The desired tone of the output (e.g., "formal", "casual", "technical").
+            output_format: The desired output format ('markdown', 'html', 'plain').
+            length: The desired length of the output ('very-short', 'concise', 'normal', 'long').
+
+        Returns:
+            The generated text as a string.
+        """
+        context_str = _get_context_as_string(context)
+
+        prompt = f"{task.strip()}\n\n"
+        if output_format == "markdown":
+            prompt += "Please write in Markdown format.\n\n"
+        elif output_format == "html":
+            prompt += "Please write in HTML format.\n\n"
+        else:
+            prompt += "Please write in plain text format. Do not use markdown or HTML.\n\n"
+
+        if tone not in ["normal", "default", ""]:
+            prompt = f"{prompt} (Tone instructions: {tone})"
+
+        if length not in ["normal", "default", ""]:
+            prompt = f"{prompt} (Length instructions: {length})"
+
+        full_prompt = f"{prompt}\n\nContext:\n{context_str}\n\n"
+
+        model = AzureChatOpenAI(model="gpt-4o", temperature=0.7)
+        response = model.with_retry(stop_after_attempt=MAX_RETRIES).invoke(full_prompt)
+        return str(response.content)
+
+    def classify_data(
+        self,
+        task: str,
+        context: Any | list[Any] | dict[str, Any],
+        class_descriptions: dict[str, str],
+    ) -> dict[str, Any]:
+        """
+        Classifies data into one of several categories based on a given task and context.
+
+        Args:
+            task: The classification question and any specific rules or requirements.
+            context: The data to be classified, provided as a string, list, or dictionary.
+            class_descriptions: A dictionary mapping class names to their descriptions.
+
+        Returns:
+            A dictionary containing the classification probabilities, the reasoning, and the top class.
+        """
+        context_str = _get_context_as_string(context)
+
+        prompt = (
+            f"{task}\n\n"
+            f"This is a classification task.\nPossible classes and descriptions:\n"
+            f"{json.dumps(class_descriptions, indent=2)}\n\n"
+            f"Context:\n{context_str}\n\n"
+            "Return ONLY a valid JSON object, no extra text."
+        )
+
+        model = init_chat_model(model="claude-4-sonnet-20250514", temperature=0)
+
+        class ClassificationResult(BaseModel):
+            probabilities: dict[str, float] = Field(..., description="The probabilities for each class.")
+            reason: str = Field(..., description="The reasoning behind the classification.")
+            top_class: str = Field(..., description="The class with the highest probability.")
+
+        response = (
+            model.with_structured_output(schema=ClassificationResult, method="json_mode")
+            .with_retry(stop_after_attempt=MAX_RETRIES)
+            .invoke(prompt)
+        )
+        return cast(dict[str, Any], response)
+
+    def extract_data(
+        self,
+        task: str,
+        source: Any | list[Any] | dict[str, Any],
+        output_schema: dict[str, Any],
+    ) -> dict[str, Any]:
+        """
+        Extracts structured data from unstructured text based on a provided JSON schema.
+
+        Args:
+            task: A description of the data to be extracted.
+            source: The unstructured data to extract from (e.g., document, webpage content).
+            output_schema: A valid JSON schema with a 'title' and 'description'.
+
+        Returns:
+            A dictionary containing the extracted data, matching the provided schema.
+        """
+        context_str = _get_context_as_string(source)
+
+        prompt = (
+            f"{task}\n\n"
+            f"Context:\n{context_str}\n\n"
+            "Return ONLY a valid JSON object that conforms to the provided schema, with no extra text."
+        )
+
+        model = init_chat_model(model="claude-4-sonnet-20250514", temperature=0)
+
+        response = (
+            model.with_structured_output(schema=output_schema, method="json_mode")
+            .with_retry(stop_after_attempt=MAX_RETRIES)
+            .invoke(prompt)
+        )
+        return cast(dict[str, Any], response)

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.11.dist-info → universal_mcp_agents-0.1.13.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: universal-mcp-agents
-Version: 0.1.11
+Version: 0.1.13
 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.13.dist-info/RECORD

@@ -0,0 +1,63 @@
+universal_mcp/agents/__init__.py,sha256=kM4mC6Pf6lmaaZF1volo7VtKgA8FDyzb1sNenpB7Ulk,1244
+universal_mcp/agents/base.py,sha256=le5vy02eXN15u8ntHWCu6Y-LgOmE_DA8tWmPOmLohAk,6908
+universal_mcp/agents/cli.py,sha256=AG9e4iSX3GazT537573YrYT1wSaZYOr42rrYQ7xP3YA,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=sKZWokTHcuL68Y6SNyaaHe6_XkWxaIq36TrNmPJfQto,9762
+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=NjN6ISj8psFtHf8V0w24ChJdUMUWkq7OrlbHdzm4wBc,2299
+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/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=KPF_nONfF12BmUTb9stHnxveqL7enGBi7wBGLrOjMsQ,9489
+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.13.dist-info/METADATA,sha256=wiruytjCRQN0GSX6yMToFwnIlmqWJPZbdbUOHXpUXJY,878
+universal_mcp_agents-0.1.13.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+universal_mcp_agents-0.1.13.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