universal-mcp 0.1.24rc14__py3-none-any.whl → 0.1.24rc19__py3-none-any.whl

universal_mcp/agentr/client.py

@@ -1,3 +1,4 @@
+import io
 import os
 from typing import Any
 
@@ -25,6 +26,7 @@ class AgentrClient:
         base_url = base_url or os.getenv("AGENTR_BASE_URL", "https://api.agentr.dev")
         self.base_url = f"{base_url.rstrip('/')}/v1"
         api_key = api_key or os.getenv("AGENTR_API_KEY")
+        self.user_id = None
         if api_key:
             self.client = httpx.Client(
                 base_url=self.base_url,
@@ -34,6 +36,7 @@ class AgentrClient:
                 verify=False,
             )
             me_data = self.me()
+            self.user_id = me_data["id"]
             logger.debug(f"Client initialized with user: {me_data['email']}")
         elif auth_token:
             logger.debug("Initializing client with auth token")
@@ -45,6 +48,7 @@ class AgentrClient:
                 verify=False,
             )
             me_data = self.me()
+            self.user_id = me_data["id"]
             logger.debug(f"Client initialized with user: {me_data['email']}")
         else:
             raise ValueError("No API key or auth token provided")
@@ -207,3 +211,10 @@ class AgentrClient:
         response = self.client.get("/tools/", params=params)
         response.raise_for_status()
         return response.json().get("items", [])
+
+    def _upload_file(self, file_name: str, mime_type: str, base64_data: str) -> str:
+        """Upload a file to the server."""
+        files = {"file": (file_name, io.BytesIO(base64_data), mime_type)}
+        reponse = self.client.post("/files/upload", files=files)
+        reponse.raise_for_status()
+        return reponse.json()

universal_mcp/agentr/registry.py

@@ -1,15 +1,34 @@
+import base64
 from typing import Any
 
 from loguru import logger
 
 from universal_mcp.agentr.client import AgentrClient
-from universal_mcp.applications import app_from_slug
+from universal_mcp.applications.utils import app_from_slug
+from universal_mcp.exceptions import ToolError
 from universal_mcp.tools.manager import ToolManager, _get_app_and_tool_name
 from universal_mcp.tools.registry import ToolRegistry
 from universal_mcp.types import ToolConfig, ToolFormat
 
 from .integration import AgentrIntegration
 
+MARKDOWN_INSTRUCTIONS = """Always render the URL in markdown format for images and media files. Here are examples:
+The url is provided in the response as "signed_url".
+For images:
+- Use markdown image syntax: ![alt text](url)
+- Example: ![Generated sunset image](https://example.com/image.png)
+- Always include descriptive alt text that explains what the image shows
+
+For audio files:
+- Use markdown link syntax with audio description: [🔊 Audio file description](url)
+- Example: [🔊 Generated speech audio](https://example.com/audio.mp3)
+
+For other media:
+- Use descriptive link text: [📄 File description](url)
+- Example: [📄 Generated document](https://example.com/document.pdf)
+
+Always make the links clickable and include relevant context about what the user will see or hear when they access the URL."""
+
 
 class AgentrRegistry(ToolRegistry):
     """Platform manager implementation for AgentR platform."""
@@ -133,7 +152,7 @@ class AgentrRegistry(ToolRegistry):
         try:
             # Clear tools from tool manager before loading new tools
             self.tool_manager.clear_tools()
-            if isinstance(tools, ToolConfig):
+            if isinstance(tools, dict):
                 logger.info("Loading tools from tool config")
                 self._load_tools_from_tool_config(tools, self.tool_manager)
             else:
@@ -176,12 +195,28 @@ class AgentrRegistry(ToolRegistry):
             tool_config: The tool configuration containing app names and tools
             tool_manager: The tool manager to register tools with
         """
-        for app_name, tool_data in tool_config.agentrServers.items():
-            self._load_tools(app_name, tool_data.tools, tool_manager)
+        for app_name, tool_names in tool_config.items():
+            self._load_tools(app_name, tool_names, tool_manager)
 
     async def call_tool(self, tool_name: str, tool_args: dict[str, Any]) -> dict[str, Any]:
         """Call a tool with the given name and arguments."""
-        return await self.tool_manager.call_tool(tool_name, tool_args)
+        data = await self.tool_manager.call_tool(tool_name, tool_args)
+        logger.debug(f"Tool {tool_name} called with args {tool_args} and returned {data}")
+        if isinstance(data, dict):
+            type_ = data.get("type")
+            if type_ == "image" or type_ == "audio":
+                # Special handling for images and audio
+                base64_data = data.get("data")
+                mime_type = data.get("mime_type")
+                file_name = data.get("file_name")
+                if not mime_type or not file_name:
+                    raise ToolError("Mime type or file name is missing")
+                bytes_data = base64.b64decode(base64_data)
+                response = self.client._upload_file(file_name, mime_type, bytes_data)
+                # Hard code instructions for llm
+                response = {**response, "instructions": MARKDOWN_INSTRUCTIONS}
+                return response
+        return data
 
     async def list_connected_apps(self) -> list[str]:
         """List all apps that the user has connected."""

universal_mcp/applications/application.py

@@ -9,7 +9,6 @@ from gql.transport.requests import RequestsHTTPTransport
 from graphql import DocumentNode
 from loguru import logger
 
-from universal_mcp.analytics import analytics
 from universal_mcp.integrations.integration import Integration
 
 
@@ -37,7 +36,6 @@ class BaseApplication(ABC):
         """
         self.name = name
         logger.debug(f"Initializing Application '{name}' with kwargs: {kwargs}")
-        analytics.track_app_loaded(name)  # Track app loading
 
     @abstractmethod
     def list_tools(self) -> list[Callable]:

universal_mcp/applications/sample/app.py

@@ -1,22 +1,25 @@
 import datetime
 
 import httpx
+from loguru import logger
 
 from universal_mcp.applications.application import BaseApplication
 
 
-class SampleToolApp(BaseApplication):
+class SampleApp(BaseApplication):
     """A sample application providing basic utility tools."""
 
-    def __init__(self):
+    def __init__(self, **kwargs):
         """Initializes the SampleToolApp with the name 'sample_tool_app'."""
-        super().__init__(name="sample_tool_app")
+        super().__init__(name="sample")
 
     def get_current_time(self):
         """Get the current system time as a formatted string.
 
         Returns:
             str: The current time in the format 'YYYY-MM-DD HH:MM:SS'.
+        Tags:
+            time, date, current, system, utility, important
         """
         return datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
 
@@ -25,6 +28,8 @@ class SampleToolApp(BaseApplication):
 
         Returns:
             str: The current date in the format 'YYYY-MM-DD'.
+        Tags:
+            time, date, current, system, utility, important
         """
         return datetime.datetime.now().strftime("%Y-%m-%d")
 
@@ -36,6 +41,8 @@ class SampleToolApp(BaseApplication):
 
         Returns:
             str: The result of the calculation, or an error message if evaluation fails.
+        Tags:
+            math, calculation, utility, important
         """
         try:
             # Safe evaluation of mathematical expressions
@@ -44,29 +51,41 @@ class SampleToolApp(BaseApplication):
         except Exception as e:
             return f"Error in calculation: {str(e)}"
 
-    def file_operations(self, operation: str, filename: str, content: str = ""):
-        """Perform file read or write operations.
+    def read_file(self, filename: str):
+        """Read content from a file.
 
         Args:
-            operation (str): The operation to perform, either 'read' or 'write'.
-            filename (str): The name of the file to operate on.
-            content (str, optional): The content to write to the file (used only for 'write'). Defaults to "".
+            filename (str): The name of the file to read from.
 
         Returns:
-            str: The result of the file operation, or an error message if the operation fails.
+            str: The content of the file, or an error message if the operation fails.
+        Tags:
+            file, read, utility, important
         """
         try:
-            if operation == "read":
-                with open(filename) as f:
-                    return f"File content:\n{f.read()}"
-            elif operation == "write":
-                with open(filename, "w") as f:
-                    f.write(content)
-                return f"Successfully wrote to {filename}"
-            else:
-                return "Invalid operation. Use 'read' or 'write'"
+            with open(filename) as f:
+                return f"File content:\n{f.read()}"
         except Exception as e:
-            return f"File operation error: {str(e)}"
+            return f"File read error: {str(e)}"
+
+    def write_file(self, filename: str, content: str):
+        """Write content to a file.
+
+        Args:
+            filename (str): The name of the file to write to.
+            content (str): The content to write to the file.
+
+        Returns:
+            str: Success message or an error message if the operation fails.
+        Tags:
+            file, write, utility, important
+        """
+        try:
+            with open(filename, "w") as f:
+                f.write(content)
+            return f"Successfully wrote to {filename}"
+        except Exception as e:
+            return f"File write error: {str(e)}"
 
     def get_weather(
         self,
@@ -230,6 +249,44 @@ class SampleToolApp(BaseApplication):
         except Exception as e:
             return {"error": str(e)}
 
+    def generate_image(self, prompt: str):
+        """Generate an image based on a prompt.
+        A
+        Args:
+            prompt (str): The prompt to generate an image from.
+
+        Returns:
+            dict: The generated image.
+        Tags:
+            image, generate, utility, important
+        """
+        import base64
+        import io
+
+        from PIL import Image, ImageDraw, ImageFont
+
+        # Create a simple placeholder image
+        img = Image.new("RGB", (600, 400), color="lightblue")
+        draw = ImageDraw.Draw(img)
+
+        # Add text to the image
+        try:
+            # Try to use a default font
+            font = ImageFont.load_default()
+        except Exception as e:
+            logger.error(f"Error loading font: {e}")
+            font = None
+
+        text = f"Generated: {prompt[:50]}..."
+        draw.text((50, 200), text, fill="black", font=font)
+
+        # Convert to base64
+        buffer = io.BytesIO()
+        img.save(buffer, format="PNG")
+        img_base64 = base64.b64encode(buffer.getvalue()).decode("utf-8")
+
+        return {"type": "image", "data": img_base64, "mime_type": "image/png", "file_name": "sample.png"}
+
     def list_tools(self):
         """List all available tool methods in this application.
 
@@ -240,6 +297,8 @@ class SampleToolApp(BaseApplication):
             self.get_current_time,
             self.get_current_date,
             self.calculate,
-            self.file_operations,
+            self.read_file,
+            self.write_file,
             self.get_simple_weather,
+            self.generate_image,
         ]

universal_mcp/applications/utils.py

@@ -0,0 +1,52 @@
+import importlib
+
+from loguru import logger
+
+from universal_mcp.applications.application import BaseApplication
+
+# --- Default Name Generators ---
+
+
+def get_default_package_name(slug: str) -> str:
+    """
+    Convert a repository slug to a package name.
+    """
+    slug = slug.strip().lower().replace("-", "_")
+    package_name = f"universal_mcp.applications.{slug}"
+    return package_name
+
+
+def get_default_module_path(slug: str) -> str:
+    """
+    Convert a repository slug to a module path.
+    """
+    package_name = get_default_package_name(slug)
+    module_path = f"{package_name}.app"
+    return module_path
+
+
+def get_default_class_name(slug: str) -> str:
+    """
+    Convert a repository slug to a class name.
+    """
+    slug = slug.strip().lower()
+    parts = slug.replace("-", "_").split("_")
+    class_name = "".join(part.capitalize() for part in parts) + "App"
+    return class_name
+
+
+# --- Application Loaders ---
+
+
+def app_from_slug(slug: str) -> type[BaseApplication]:
+    """Loads an application from a slug."""
+    return load_app_from_package(slug)
+
+
+def load_app_from_package(slug: str) -> type[BaseApplication]:
+    """Loads an application from a pip-installable package."""
+    logger.debug(f"Loading '{slug}' as a package.")
+    module_path_str = get_default_module_path(slug)
+    class_name_str = get_default_class_name(slug)
+    module = importlib.import_module(module_path_str)
+    return getattr(module, class_name_str)

universal_mcp/servers/server.py

@@ -5,7 +5,8 @@ from loguru import logger
 from mcp.server.fastmcp import FastMCP
 from mcp.types import TextContent
 
-from universal_mcp.applications import BaseApplication, app_from_config
+from universal_mcp.applications.application import BaseApplication
+from universal_mcp.applications.utils import app_from_slug
 from universal_mcp.config import ServerConfig
 from universal_mcp.exceptions import ConfigurationError, ToolError
 from universal_mcp.integrations.integration import ApiKeyIntegration, OAuthIntegration
@@ -44,8 +45,8 @@ def load_from_local_config(config: ServerConfig, tool_manager: ToolManager) -> N
                     integration = OAuthIntegration(config.name, store=store, **app_config.integration.credentials)
                 else:
                     raise ValueError(f"Unsupported integration type: {app_config.integration.type}")
-            app = app_from_config(app_config)(integration=integration)
-            tool_manager.register_tools_from_app(app, app_config.actions)
+            app = app_from_slug(app_config.name)(integration=integration)
+            tool_manager.register_tools_from_app(app, tool_names=app_config.actions)
             logger.info(f"Loaded app: {app_config.name}")
         except Exception as e:
             logger.error(f"Failed to load app {app_config.name}: {e}", exc_info=True)

universal_mcp/tools/manager.py

@@ -3,7 +3,6 @@ from typing import Any
 
 from loguru import logger
 
-from universal_mcp.analytics import analytics
 from universal_mcp.applications.application import BaseApplication
 from universal_mcp.exceptions import ToolNotFoundError
 from universal_mcp.tools.adapters import (
@@ -298,8 +297,6 @@ class ToolManager:
             raise ToolNotFoundError(f"Unknown tool: {name}")
         try:
             result = await tool.run(arguments, context)
-            analytics.track_tool_called(name, app_name, "success")
             return result
         except Exception as e:
-            analytics.track_tool_called(name, app_name, "error", str(e))
             raise e

universal_mcp/types.py

@@ -1,7 +1,4 @@
 from enum import Enum
-from typing import Literal
-
-from pydantic import BaseModel
 
 # Constants
 DEFAULT_IMPORTANT_TAG = "important"
@@ -18,21 +15,4 @@ class ToolFormat(str, Enum):
     OPENAI = "openai"
 
 
-class AgentrConnection(BaseModel):
-    tools: list[str]
-
-
-class MCPConnection(BaseModel):
-    transport: Literal["stdio", "sse", "streamable-http"]
-    command: str | None = None
-    args: list[str] | None = None
-    url: str | None = None
-    headers: dict[str, str] | None = None
-
-
-class AgentrToolConfig(BaseModel):
-    agentrServers: dict[str, AgentrConnection] | None = None
-
-
-class ToolConfig(AgentrToolConfig):
-    mcpServers: dict[str, MCPConnection] | None = None
+ToolConfig = dict[str, list[str]]

universal_mcp/utils/prompts.py

@@ -229,7 +229,6 @@ from loguru import logger
 
 import httpx
 
-from universal_mcp.analytics import analytics
 from universal_mcp.integrations import Integration
 
 class BaseApplication(ABC):
@@ -256,7 +255,6 @@ class BaseApplication(ABC):
         """
         self.name = name
         logger.debug(f"Initializing Application '{name}' with kwargs: {kwargs}")
-        analytics.track_app_loaded(name)  # Track app loading
 
     @abstractmethod
     def list_tools(self) -> list[Callable]:

universal_mcp/utils/testing.py

@@ -8,7 +8,7 @@ from pydantic import BaseModel, SecretStr
 
 from universal_mcp.agentr import AgentrIntegration
 from universal_mcp.agentr.client import AgentrClient
-from universal_mcp.applications import APIApplication, BaseApplication
+from universal_mcp.applications.application import APIApplication, BaseApplication
 from universal_mcp.tools import Tool, ToolManager
 from universal_mcp.types import ToolFormat
 

{universal_mcp-0.1.24rc14.dist-info → universal_mcp-0.1.24rc19.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: universal-mcp
-Version: 0.1.24rc14
+Version: 0.1.24rc19
 Summary: Universal MCP acts as a middle ware for your API applications. It can store your credentials, authorize, enable disable apps on the fly and much more.
 Author-email: Manoj Bajaj <manojbajaj95@gmail.com>
 License: MIT

universal_mcp-0.1.24rc19.dist-info/RECORD

@@ -0,0 +1,54 @@
+universal_mcp/cli.py,sha256=pPnIWLhSrLV9ukI8YAg2znehCR3VovhEkmh8XkRT3MU,2505
+universal_mcp/config.py,sha256=lOlDAgQMT7f6VymmsuCP9sYLlxGKj0hDF3hFcJ2nzS4,8135
+universal_mcp/exceptions.py,sha256=Uen8UFgLHGlSwXgRUyF-nhqTwdiBuL3okgBVRV2AgtA,2150
+universal_mcp/logger.py,sha256=VmH_83efpErLEDTJqz55Dp0dioTXfGvMBLZUx5smOLc,2116
+universal_mcp/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+universal_mcp/types.py,sha256=DAzYyS7Zqdi38SpnhdOm08_JeN2CJiC0hDIpLLIhlSw,316
+universal_mcp/agentr/README.md,sha256=t15pVgkCwZM5wzgLgrf0Zv6hVL7dPmKXvAeTf8CiXPQ,6641
+universal_mcp/agentr/__init__.py,sha256=fv1ZnOCduIUiJ9oN4e6Ya_hA2oWQvcEuDU3Ek1vEufI,180
+universal_mcp/agentr/client.py,sha256=CwfmOAgWsApm0buxZPni3vW6MFgrwdddXsXmQA5UYrA,7882
+universal_mcp/agentr/integration.py,sha256=V5GjqocqS02tRoI8MeV9PL6m-BzejwBzgJhOHo4MxAE,4212
+universal_mcp/agentr/registry.py,sha256=cWkg9cUEmksWqeuh4xazFf1WtRQ3lEZf1s53hqTlmG4,8657
+universal_mcp/agentr/server.py,sha256=bIPmHMiKKwnUYnxmfZVRh1thcn7Rytm_-bNiXTfANzc,2098
+universal_mcp/applications/application.py,sha256=do45GC0jnNepZHL8US2yDNq9s0ZnE6bII4Xbw90GRTc,23727
+universal_mcp/applications/utils.py,sha256=8Pp9lZU6IPt9z9BnuJ-vpv-NGuzryt1c4e4-ShDd2XI,1450
+universal_mcp/applications/sample/app.py,sha256=D9zPezC13xXVMlfO2A0fHgJQD_I-bnpf9UOOHveHMek,10537
+universal_mcp/client/oauth.py,sha256=O00zOUfQxINaruFU2zt-64DIR1_mAqrY8ykLQo-teJU,8679
+universal_mcp/client/token_store.py,sha256=6VAzjzJG49wYvmEDqksFvb-fVqdjHIKWv7yYyh_AuF8,3912
+universal_mcp/client/transport.py,sha256=qqtb0ky6yvLBxsaA9-oFU0v9MwfcQb4eomq-O2fmwtQ,11850
+universal_mcp/integrations/__init__.py,sha256=tfzLyPEPly5tfIcT8K6-oKCr_MEFGxOROHy_NeVy0KM,200
+universal_mcp/integrations/integration.py,sha256=H-hOoDHqk78A4Fi_TGN7OOFS7PDfqXK_nedH8iSz-6A,16459
+universal_mcp/servers/__init__.py,sha256=speBb_E94UJa4A6Fv8RHFeoJ7cR-q2bCMtKV7R21P5w,142
+universal_mcp/servers/server.py,sha256=bJTG86X_kn0R8lWIYvCZw-cp-rVAOKd12-E5WOEsz8Y,5950
+universal_mcp/stores/__init__.py,sha256=quvuwhZnpiSLuojf0NfmBx2xpaCulv3fbKtKaSCEmuM,603
+universal_mcp/stores/store.py,sha256=yWbEGZb53z3fpVyqGWbes63z1CtIzC_IuM49OXy__UY,10137
+universal_mcp/tools/__init__.py,sha256=jC8hsqfTdtn32yU57AVFUXiU3ZmUOCfCERSCaNEIH7E,395
+universal_mcp/tools/adapters.py,sha256=YJ2oqgc8JgmtsdRRtvO-PO0Q0bKqTJ4Y3J6yxlESoTo,3947
+universal_mcp/tools/docstring_parser.py,sha256=efEOE-ME7G5Jbbzpn7pN2xNuyu2M5zfZ1Tqu1lRB0Gk,8392
+universal_mcp/tools/func_metadata.py,sha256=F4jd--hoZWKPBbZihVtluYKUsIdXdq4a0VWRgMl5k-Q,10838
+universal_mcp/tools/manager.py,sha256=T8iSk7Q6s3MFaQcwUapPvcQ6_l7_g4Xt2xXk55lPJ1w,10321
+universal_mcp/tools/registry.py,sha256=LD0J_bPsd8PRTObyvXglqTW1jfZX98m7KBdyP8Yn7wA,2585
+universal_mcp/tools/tools.py,sha256=Lk-wUO3rfhwdxaRANtC7lQr5fXi7nclf0oHzxNAb79Q,4927
+universal_mcp/utils/__init__.py,sha256=8wi4PGWu-SrFjNJ8U7fr2iFJ1ktqlDmSKj1xYd7KSDc,41
+universal_mcp/utils/installation.py,sha256=PU_GfHPqzkumKk-xG4L9CkBzSmABxmchwblZkx-zY-I,7204
+universal_mcp/utils/prompts.py,sha256=yaZ8lj5GooA8bbT42lcWR2r35HAnOalCvyWS1I2ltGM,27439
+universal_mcp/utils/singleton.py,sha256=RoOiKxBOAhp0TK1QaMDYi-8GjRcy2Vh-bAOuIAcYan0,775
+universal_mcp/utils/testing.py,sha256=PJYB-QVlBuDkRW-luHkJapf4T1oaNjxt8gvQoTS7cCA,8021
+universal_mcp/utils/openapi/__inti__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+universal_mcp/utils/openapi/api_generator.py,sha256=sygUE8Sropq3Pz09N1kSwGelgnTCAz_lOGspTaYCWEs,6985
+universal_mcp/utils/openapi/api_splitter.py,sha256=io7fV-E8hUIR4NxFlakqydbgrQF6aBAnZHPMlpxw-wc,20967
+universal_mcp/utils/openapi/cli.py,sha256=az5ObS74R-MmDCOZ1PHTJVKZJrHnsBOAweOUa7A-GqA,25918
+universal_mcp/utils/openapi/docgen.py,sha256=DNmwlhg_-TRrHa74epyErMTRjV2nutfCQ7seb_Rq5hE,21366
+universal_mcp/utils/openapi/filters.py,sha256=96FajO5nLbvjNPy2A1HvSS9jqpzMDHd4q_QTP-DIsPI,3842
+universal_mcp/utils/openapi/openapi.py,sha256=mcmahLJrR-CS-r2RDaYOgMV1Eq7ZuCHMk7_Qrijadh4,62613
+universal_mcp/utils/openapi/postprocessor.py,sha256=j_OZ5u2VCb44rfvnJZdKcxQRyGgrEVMr8ue9oN0Ed7A,12235
+universal_mcp/utils/openapi/preprocessor.py,sha256=r4n0WQI__OzPL8FTza7jxiM4EYeZwa-3tvEJaJYZC44,63081
+universal_mcp/utils/openapi/readme.py,sha256=R2Jp7DUXYNsXPDV6eFTkLiy7MXbSULUj1vHh4O_nB4c,2974
+universal_mcp/utils/openapi/test_generator.py,sha256=vucBh9klWmQOUA740TFwfM9ry2nkwKWQiNRcsiZ9HbY,12229
+universal_mcp/utils/templates/README.md.j2,sha256=Mrm181YX-o_-WEfKs01Bi2RJy43rBiq2j6fTtbWgbTA,401
+universal_mcp/utils/templates/api_client.py.j2,sha256=972Im7LNUAq3yZTfwDcgivnb-b8u6_JLKWXwoIwXXXQ,908
+universal_mcp-0.1.24rc19.dist-info/METADATA,sha256=zKP0JF9Lp3hnTW-8ZvLutdDpGEcqAishzXtrICY3a4Y,3255
+universal_mcp-0.1.24rc19.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+universal_mcp-0.1.24rc19.dist-info/entry_points.txt,sha256=QlBrVKmA2jIM0q-C-3TQMNJTTWOsOFQvgedBq2rZTS8,56
+universal_mcp-0.1.24rc19.dist-info/licenses/LICENSE,sha256=NweDZVPslBAZFzlgByF158b85GR0f5_tLQgq1NS48To,1063
+universal_mcp-0.1.24rc19.dist-info/RECORD,,

universal_mcp/agents/__init__.py

@@ -1,10 +0,0 @@
-from universal_mcp.agents.autoagent import AutoAgent
-from universal_mcp.agents.base import BaseAgent
-from universal_mcp.agents.bigtool import BigToolAgent
-from universal_mcp.agents.planner import PlannerAgent
-from universal_mcp.agents.react import ReactAgent
-from universal_mcp.agents.simple import SimpleAgent
-from universal_mcp.agents.bigtool2 import BigToolAgent2
-from universal_mcp.agents.builder import BuilderAgent
-
-__all__ = ["BaseAgent", "ReactAgent", "SimpleAgent", "AutoAgent", "BigToolAgent", "PlannerAgent", "BuilderAgent" ,"BigToolAgent2"]

universal_mcp/agents/autoagent/__init__.py

@@ -1,30 +0,0 @@
-from langgraph.checkpoint.base import BaseCheckpointSaver
-
-from universal_mcp.agents.autoagent.graph import build_graph
-from universal_mcp.agents.base import BaseAgent
-from universal_mcp.tools.registry import ToolRegistry
-
-
-class AutoAgent(BaseAgent):
-    def __init__(
-        self,
-        name: str,
-        instructions: str,
-        model: str,
-        memory: BaseCheckpointSaver | None = None,
-        registry: ToolRegistry | None = None,
-        **kwargs,
-    ):
-        super().__init__(name, instructions, model, memory, **kwargs)
-        self.tool_registry = registry
-
-    async def _build_graph(self):
-        builder = await build_graph(self.tool_registry, self.instructions)
-        return builder.compile(checkpointer=self.memory)
-
-    @property
-    def graph(self):
-        return self._graph
-
-
-__all__ = ["AutoAgent"]

universal_mcp/agents/autoagent/__main__.py

@@ -1,25 +0,0 @@
-import asyncio
-
-from loguru import logger
-
-from universal_mcp.agentr.registry import AgentrRegistry
-from universal_mcp.agents.autoagent import AutoAgent
-
-
-async def main():
-    agent = AutoAgent(
-        name="autoagent",
-        instructions="You are a helpful assistant that can use tools to help the user.",
-        model="azure/gpt-4.1",
-        registry=AgentrRegistry(),
-    )
-    async for event in agent.stream(
-        user_input="Send an email to manoj@agentr.dev",
-        thread_id="test123",
-    ):
-        logger.info(event.content)
-    # from loguru import logger; logger.debug(result)
-
-
-if __name__ == "__main__":
-    asyncio.run(main())

universal_mcp/agents/autoagent/context.py

@@ -1,26 +0,0 @@
-from dataclasses import dataclass, field
-from typing import Annotated
-
-from universal_mcp.agents.autoagent.prompts import SYSTEM_PROMPT
-
-
-@dataclass(kw_only=True)
-class Context:
-    """The context for the agent."""
-
-    system_prompt: str = field(
-        default=SYSTEM_PROMPT,
-        metadata={
-            "description": "The system prompt to use for the agent's interactions. "
-            "This prompt sets the context and behavior for the agent."
-        },
-    )
-
-    model: Annotated[str, {"__template_metadata__": {"kind": "llm"}}] = field(
-        default="anthropic/claude-4-sonnet-20250514",
-        # default="vertex/gemini-2.5-flash",
-        metadata={
-            "description": "The name of the language model to use for the agent's main interactions. "
-            "Should be in the form: provider/model-name."
-        },
-    )