universal-mcp 0.1.18rc3__py3-none-any.whl → 0.1.19__py3-none-any.whl

universal_mcp/config.py

@@ -38,7 +38,6 @@ class ServerConfig(BaseSettings):
     """Main server configuration."""
 
     model_config = SettingsConfigDict(
-        env_prefix="MCP_",
         env_file=".env",
         env_file_encoding="utf-8",
         case_sensitive=True,
@@ -47,19 +46,17 @@ class ServerConfig(BaseSettings):
 
     name: str = Field(default="Universal MCP", description="Name of the MCP server")
     description: str = Field(default="Universal MCP", description="Description of the MCP server")
-    api_key: SecretStr | None = Field(default=None, description="API key for authentication")
+    api_key: SecretStr | None = Field(default=None, description="API key for authentication", alias="AGENTR_API_KEY")
     type: Literal["local", "agentr"] = Field(default="agentr", description="Type of server deployment")
     transport: Literal["stdio", "sse", "streamable-http"] = Field(
         default="stdio", description="Transport protocol to use"
     )
-    port: int = Field(default=8005, description="Port to run the server on (if applicable)")
+    port: int = Field(default=8005, description="Port to run the server on (if applicable)", ge=1024, le=65535)
     host: str = Field(default="localhost", description="Host to bind the server to (if applicable)")
     apps: list[AppConfig] | None = Field(default=None, description="List of configured applications")
     store: StoreConfig | None = Field(default=None, description="Default store configuration")
     debug: bool = Field(default=False, description="Enable debug mode")
     log_level: str = Field(default="INFO", description="Logging level")
-    max_connections: int = Field(default=100, description="Maximum number of concurrent connections")
-    request_timeout: int = Field(default=60, description="Default request timeout in seconds")
 
     @field_validator("log_level", mode="before")
     def validate_log_level(cls, v: str) -> str:

universal_mcp/exceptions.py

@@ -19,3 +19,7 @@ class StoreError(Exception):
 
 class KeyNotFoundError(StoreError):
     """Exception raised when a key is not found in the store."""
+
+
+class ConfigurationError(Exception):
+    """Exception raised when a configuration error occurs."""

universal_mcp/servers/server.py

@@ -1,4 +1,3 @@
-from abc import ABC, abstractmethod
 from collections.abc import Callable
 from typing import Any
 
@@ -6,16 +5,18 @@ import httpx
 from loguru import logger
 from mcp.server.fastmcp import FastMCP
 from mcp.types import TextContent
+from pydantic import ValidationError
 
 from universal_mcp.applications import BaseApplication, app_from_slug
 from universal_mcp.config import AppConfig, ServerConfig, StoreConfig
+from universal_mcp.exceptions import ConfigurationError, ToolError
 from universal_mcp.integrations import AgentRIntegration, integration_from_config
 from universal_mcp.stores import BaseStore, store_from_config
 from universal_mcp.tools import ToolManager
 from universal_mcp.utils.agentr import AgentrClient
 
 
-class BaseServer(FastMCP, ABC):
+class BaseServer(FastMCP):
     """Base server class with common functionality.
 
     This class provides core server functionality including store setup,
@@ -26,24 +27,27 @@ class BaseServer(FastMCP, ABC):
         **kwargs: Additional keyword arguments passed to FastMCP
     """
 
-    def __init__(self, config: ServerConfig, **kwargs):
-        super().__init__(config.name, config.description, port=config.port, **kwargs)
-        logger.info(f"Initializing server: {config.name} ({config.type}) with store: {config.store}")
-
-        self.config = config  # Store config at base level for consistency
-        self._tool_manager = ToolManager(warn_on_duplicate_tools=True)
-
-    @abstractmethod
-    def _load_apps(self) -> None:
-        """Load and register applications."""
-        pass
+    def __init__(self, config: ServerConfig, tool_manager: ToolManager | None = None, **kwargs):
+        try:
+            super().__init__(config.name, config.description, port=config.port, **kwargs)
+            logger.info(f"Initializing server: {config.name} ({config.type}) with store: {config.store}")
+            self.config = config
+            self._tool_manager = tool_manager or ToolManager(warn_on_duplicate_tools=True)
+            ServerConfig.model_validate(config)
+        except Exception as e:
+            logger.error(f"Failed to initialize server: {e}", exc_info=True)
+            raise ConfigurationError(f"Server initialization failed: {str(e)}") from e
 
     def add_tool(self, tool: Callable) -> None:
         """Add a tool to the server.
 
         Args:
             tool: Tool to add
+
+        Raises:
+            ValueError: If tool is invalid
         """
+
         self._tool_manager.add_tool(tool)
 
     async def list_tools(self) -> list[dict]:
@@ -83,11 +87,21 @@ class BaseServer(FastMCP, ABC):
 
         Raises:
             ToolError: If tool execution fails
+            ValueError: If tool name is invalid or arguments are malformed
         """
+        if not name:
+            raise ValueError("Tool name is required")
+        if not isinstance(arguments, dict):
+            raise ValueError("Arguments must be a dictionary")
+
         logger.info(f"Calling tool: {name} with arguments: {arguments}")
-        result = await self._tool_manager.call_tool(name, arguments)
-        logger.info(f"Tool '{name}' completed successfully")
-        return self._format_tool_result(result)
+        try:
+            result = await self._tool_manager.call_tool(name, arguments)
+            logger.info(f"Tool '{name}' completed successfully")
+            return self._format_tool_result(result)
+        except Exception as e:
+            logger.error(f"Tool '{name}' failed: {e}", exc_info=True)
+            raise ToolError(f"Tool execution failed: {str(e)}") from e
 
 
 class LocalServer(BaseServer):
@@ -111,14 +125,23 @@ class LocalServer(BaseServer):
 
         Returns:
             Configured store instance or None if no config provided
+
+        Raises:
+            ConfigurationError: If store configuration is invalid
         """
         if not store_config:
+            logger.info("No store configuration provided")
             return None
 
-        store = store_from_config(store_config)
-        self.add_tool(store.set)
-        self.add_tool(store.delete)
-        return store
+        try:
+            store = store_from_config(store_config)
+            self.add_tool(store.set)
+            self.add_tool(store.delete)
+            logger.info(f"Successfully configured store: {store_config.type}")
+            return store
+        except Exception as e:
+            logger.error(f"Failed to setup store: {e}", exc_info=True)
+            raise ConfigurationError(f"Store setup failed: {str(e)}") from e
 
     def _load_app(self, app_config: AppConfig) -> BaseApplication | None:
         """Load a single application with its integration.
@@ -129,22 +152,57 @@ class LocalServer(BaseServer):
         Returns:
             Configured application instance or None if loading fails
         """
+        if not app_config.name:
+            logger.error("App configuration missing name")
+            return None
+
         try:
-            integration = (
-                integration_from_config(app_config.integration, store=self.store) if app_config.integration else None
-            )
-            return app_from_slug(app_config.name)(integration=integration)
+            integration = None
+            if app_config.integration:
+                try:
+                    integration = integration_from_config(app_config.integration, store=self.store)
+                    logger.debug(f"Successfully configured integration for {app_config.name}")
+                except Exception as e:
+                    logger.error(f"Failed to setup integration for {app_config.name}: {e}", exc_info=True)
+                    # Continue without integration if it fails
+
+            app = app_from_slug(app_config.name)(integration=integration)
+            logger.info(f"Successfully loaded app: {app_config.name}")
+            return app
         except Exception as e:
             logger.error(f"Failed to load app {app_config.name}: {e}", exc_info=True)
             return None
 
     def _load_apps(self) -> None:
-        """Load all configured applications."""
-        logger.info(f"Loading apps: {self.config.apps}")
+        """Load all configured applications with graceful degradation."""
+        if not self.config.apps:
+            logger.warning("No applications configured")
+            return
+
+        logger.info(f"Loading {len(self.config.apps)} apps")
+        loaded_apps = 0
+        failed_apps = []
+
         for app_config in self.config.apps:
             app = self._load_app(app_config)
             if app:
-                self._tool_manager.register_tools_from_app(app, app_config.actions)
+                try:
+                    self._tool_manager.register_tools_from_app(app, app_config.actions)
+                    loaded_apps += 1
+                    logger.info(f"Successfully registered tools for {app_config.name}")
+                except Exception as e:
+                    logger.error(f"Failed to register tools for {app_config.name}: {e}", exc_info=True)
+                    failed_apps.append(app_config.name)
+            else:
+                failed_apps.append(app_config.name)
+
+        if failed_apps:
+            logger.warning(f"Failed to load {len(failed_apps)} apps: {', '.join(failed_apps)}")
+
+        if loaded_apps == 0:
+            logger.error("No apps were successfully loaded")
+        else:
+            logger.info(f"Successfully loaded {loaded_apps}/{len(self.config.apps)} apps")
 
 
 class AgentRServer(BaseServer):
@@ -154,27 +212,39 @@ class AgentRServer(BaseServer):
         config: Server configuration
         api_key: Optional API key for AgentR authentication. If not provided,
                 will attempt to read from AGENTR_API_KEY environment variable.
+        max_retries: Maximum number of retries for API calls (default: 3)
+        retry_delay: Delay between retries in seconds (default: 1)
         **kwargs: Additional keyword arguments passed to FastMCP
     """
 
-    def __init__(self, config: ServerConfig, api_key: str | None = None, **kwargs):
-        self.client = AgentrClient(api_key=api_key)
+    def __init__(self, config: ServerConfig, **kwargs):
+        self.api_key = config.api_key.get_secret_value() if config.api_key else None
+        logger.info(f"Initializing AgentR server with API key: {self.api_key}")
+        self.client = AgentrClient(api_key=self.api_key)
         super().__init__(config, **kwargs)
         self.integration = AgentRIntegration(name="agentr", api_key=self.client.api_key)
         self._load_apps()
 
     def _fetch_apps(self) -> list[AppConfig]:
-        """Fetch available apps from AgentR API.
+        """Fetch available apps from AgentR API with retry logic.
 
         Returns:
             List of application configurations
 
         Raises:
-            httpx.HTTPError: If API request fails
+            httpx.HTTPError: If API request fails after all retries
+            ValidationError: If app configuration validation fails
         """
         try:
             apps = self.client.fetch_apps()
-            return [AppConfig.model_validate(app) for app in apps]
+            validated_apps = []
+            for app in apps:
+                try:
+                    validated_apps.append(AppConfig.model_validate(app))
+                except ValidationError as e:
+                    logger.error(f"Failed to validate app config: {e}", exc_info=True)
+                    continue
+            return validated_apps
         except httpx.HTTPError as e:
             logger.error(f"Failed to fetch apps from AgentR: {e}", exc_info=True)
             raise
@@ -194,21 +264,37 @@ class AgentRServer(BaseServer):
                 if app_config.integration
                 else None
             )
-            return app_from_slug(app_config.name)(integration=integration)
+            app = app_from_slug(app_config.name)(integration=integration)
+            logger.info(f"Successfully loaded app: {app_config.name}")
+            return app
         except Exception as e:
             logger.error(f"Failed to load app {app_config.name}: {e}", exc_info=True)
             return None
 
     def _load_apps(self) -> None:
-        """Load all apps available from AgentR."""
+        """Load all apps available from AgentR with graceful degradation."""
         try:
-            for app_config in self._fetch_apps():
+            app_configs = self._fetch_apps()
+            if not app_configs:
+                logger.warning("No apps found from AgentR API")
+                return
+
+            loaded_apps = 0
+            for app_config in app_configs:
                 app = self._load_app(app_config)
                 if app:
                     self._tool_manager.register_tools_from_app(app, app_config.actions)
+                    loaded_apps += 1
+
+            if loaded_apps == 0:
+                logger.error("Failed to load any apps from AgentR")
+            else:
+                logger.info(f"Successfully loaded {loaded_apps}/{len(app_configs)} apps from AgentR")
+
         except Exception:
             logger.error("Failed to load apps", exc_info=True)
-            raise
+            # Don't raise the exception to allow server to start with partial functionality
+            logger.warning("Server will start with limited functionality due to app loading failures")
 
 
 class SingleMCPServer(BaseServer):
@@ -234,27 +320,13 @@ class SingleMCPServer(BaseServer):
         config: ServerConfig | None = None,
         **kwargs,
     ):
+        if not app_instance:
+            raise ValueError("app_instance is required")
         if not config:
             config = ServerConfig(
                 type="local",
-                name=f"{app_instance.name.title()} MCP Server for Local Development"
-                if app_instance
-                else "Unnamed MCP Server",
-                description=f"Minimal MCP server for the local {app_instance.name} application."
-                if app_instance
-                else "Minimal MCP server with no application loaded.",
+                name=f"{app_instance.name.title()} MCP Server for Local Development",
+                description=f"Minimal MCP server for the local {app_instance.name} application.",
             )
         super().__init__(config, **kwargs)
-
-        self.app_instance = app_instance
-        self._load_apps()
-
-    def _load_apps(self) -> None:
-        """Registers tools from the single provided application instance."""
-        if not self.app_instance:
-            logger.warning("No app_instance provided. No tools registered.")
-            return
-
-        tool_functions = self.app_instance.list_tools()
-        for tool_func in tool_functions:
-            self._tool_manager.add_tool(tool_func)
+        self._tool_manager.register_tools_from_app(app_instance)

universal_mcp/tools/manager.py

@@ -85,7 +85,6 @@ class ToolManager:
         tools = list(self._tools.values())
         if tags:
             tools = _filter_by_tags(tools, tags)
-
         if format == ToolFormat.MCP:
             tools = [convert_tool_to_mcp_tool(tool) for tool in tools]
         elif format == ToolFormat.LANGCHAIN:
@@ -94,7 +93,6 @@ class ToolManager:
             tools = [convert_tool_to_openai_tool(tool) for tool in tools]
         else:
             raise ValueError(f"Invalid format: {format}")
-
         return tools
 
     def add_tool(self, fn: Callable[..., Any] | Tool, name: str | None = None) -> Tool:

universal_mcp/utils/agentr.py

@@ -5,10 +5,9 @@ from loguru import logger
 
 from universal_mcp.config import AppConfig
 from universal_mcp.exceptions import NotAuthorizedError
-from universal_mcp.utils.singleton import Singleton
 
 
-class AgentrClient(metaclass=Singleton):
+class AgentrClient:
     """Helper class for AgentR API operations.
 
     This class provides utility methods for interacting with the AgentR API,
@@ -19,14 +18,20 @@ class AgentrClient(metaclass=Singleton):
         base_url (str, optional): Base URL for AgentR API. Defaults to https://api.agentr.dev
     """
 
-    def __init__(self, api_key: str = None, base_url: str = None):
-        self.api_key = api_key or os.getenv("AGENTR_API_KEY")
-        if not self.api_key:
+    def __init__(self, api_key: str | None = None, base_url: str | None = None):
+        if api_key:
+            self.api_key = api_key
+        elif os.getenv("AGENTR_API_KEY"):
+            self.api_key = os.getenv("AGENTR_API_KEY")
+        else:
             logger.error(
                 "API key for AgentR is missing. Please visit https://agentr.dev to create an API key, then set it as AGENTR_API_KEY environment variable."
             )
             raise ValueError("AgentR API key required - get one at https://agentr.dev")
         self.base_url = (base_url or os.getenv("AGENTR_BASE_URL", "https://api.agentr.dev")).rstrip("/")
+        self.client = httpx.Client(
+            base_url=self.base_url, headers={"X-API-KEY": self.api_key}, timeout=30, follow_redirects=True
+        )
 
     def get_credentials(self, integration_name: str) -> dict:
         """Get credentials for an integration from the AgentR API.
@@ -41,9 +46,8 @@ class AgentrClient(metaclass=Singleton):
             NotAuthorizedError: If credentials are not found (404 response)
             HTTPError: For other API errors
         """
-        response = httpx.get(
-            f"{self.base_url}/api/{integration_name}/credentials/",
-            headers={"accept": "application/json", "X-API-KEY": self.api_key},
+        response = self.client.get(
+            f"/api/{integration_name}/credentials/",
         )
         if response.status_code == 404:
             logger.warning(f"No credentials found for {integration_name}. Requesting authorization...")
@@ -64,15 +68,14 @@ class AgentrClient(metaclass=Singleton):
         Raises:
             HTTPError: If API request fails
         """
-        response = httpx.get(
-            f"{self.base_url}/api/{integration_name}/authorize/",
-            headers={"X-API-KEY": self.api_key},
+        response = self.client.get(
+            f"/api/{integration_name}/authorize/",
         )
         response.raise_for_status()
         url = response.json()
         return f"Please ask the user to visit the following url to authorize the application: {url}. Render the url in proper markdown format with a clickable link."
 
-    def fetch_apps(self) -> list[dict]:
+    def fetch_apps(self) -> list[AppConfig]:
         """Fetch available apps from AgentR API.
 
         Returns:
@@ -81,11 +84,7 @@ class AgentrClient(metaclass=Singleton):
         Raises:
             httpx.HTTPError: If API request fails
         """
-        response = httpx.get(
-            f"{self.base_url}/api/apps/",
-            headers={"X-API-KEY": self.api_key},
-            timeout=10,
-        )
+        response = self.client.get("/api/apps/")
         response.raise_for_status()
         data = response.json()
         return [AppConfig.model_validate(app) for app in data]

universal_mcp/utils/openapi/openapi.py

@@ -897,7 +897,12 @@ def _generate_method_code(path, method, operation):
 
     # --- Handle Response ---
     body_lines.append("        response.raise_for_status()")
-    body_lines.append("        return response.json()")
+    body_lines.append("        if response.status_code == 204 or not response.content or not response.text.strip():")
+    body_lines.append("            return None")
+    body_lines.append("        try:")
+    body_lines.append("            return response.json()")
+    body_lines.append("        except ValueError:")
+    body_lines.append("            return None")
 
     # --- Combine Signature, Docstring, and Body for Final Method Code ---
     method_code = signature + formatted_docstring + "\n" + "\n".join(body_lines)

{universal_mcp-0.1.18rc3.dist-info → universal_mcp-0.1.19.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: universal-mcp
-Version: 0.1.18rc3
+Version: 0.1.19
 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.18rc3.dist-info → universal_mcp-0.1.19.dist-info}/RECORD

@@ -1,8 +1,8 @@
 universal_mcp/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 universal_mcp/analytics.py,sha256=Dkv8mkc_2T2t5NxLSZzcr3BlmOispj1RKtbB86V1i4M,2306
 universal_mcp/cli.py,sha256=Xcdm4UMIlwxK6f0FHvmu5b6lZ8q14S3vZexRM32zAK4,10298
-universal_mcp/config.py,sha256=EbLtv1j7-0y2pI4-2lRFtTBXaVkEoiBhPm2jqeaVRQU,3502
-universal_mcp/exceptions.py,sha256=2A_aIzcwjB99tR4xCFjPkWPf10rBK_785FerJI7Tzns,564
+universal_mcp/config.py,sha256=HaAZvf-XzQZpqGGWUuT5zojWloO8GL5Acfa5_0sDs_Q,3321
+universal_mcp/exceptions.py,sha256=-pbeZhpNieJfnSd2-WM80pU8W8mK8VHXcSjky0BHwdk,665
 universal_mcp/logger.py,sha256=VmH_83efpErLEDTJqz55Dp0dioTXfGvMBLZUx5smOLc,2116
 universal_mcp/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 universal_mcp/applications/README.md,sha256=eqbizxaTxKH2O1tyIJR2yI0Db5TQxtgPd_vbpWyCa2Y,3527
@@ -13,7 +13,7 @@ universal_mcp/integrations/__init__.py,sha256=X8iEzs02IlXfeafp6GMm-cOkg70QdjnlTR
 universal_mcp/integrations/integration.py,sha256=QvZlq3G5OU4tHPv9uq9Nv5NFe30NdUsJU-Av474n0_o,13154
 universal_mcp/servers/README.md,sha256=ytFlgp8-LO0oogMrHkMOp8SvFTwgsKgv7XhBVZGNTbM,2284
 universal_mcp/servers/__init__.py,sha256=eBZCsaZjiEv6ZlRRslPKgurQxmpHLQyiXv2fTBygHnM,532
-universal_mcp/servers/server.py,sha256=1UWvywUzgGVYyIGlaES9tgj_xP_f6EC4bK_vM0nE_tE,9237
+universal_mcp/servers/server.py,sha256=X-CM5bCbMUVm7NkAT5RNeiyc38MbiFrwlZE3dbX10SM,12810
 universal_mcp/stores/README.md,sha256=jrPh_ow4ESH4BDGaSafilhOVaN8oQ9IFlFW-j5Z5hLA,2465
 universal_mcp/stores/__init__.py,sha256=quvuwhZnpiSLuojf0NfmBx2xpaCulv3fbKtKaSCEmuM,603
 universal_mcp/stores/store.py,sha256=mxnmOVlDNrr8OKhENWDtCIfK7YeCBQcGdS6I2ogRCsU,6756
@@ -21,10 +21,10 @@ universal_mcp/tools/README.md,sha256=RuxliOFqV1ZEyeBdj3m8UKfkxAsfrxXh-b6V4ZGAk8I
 universal_mcp/tools/__init__.py,sha256=Fatza_R0qYWmNF1WQSfUZZKQFu5qf-16JhZzdmyx3KY,333
 universal_mcp/tools/adapters.py,sha256=gz_sNDc_bseMHWmpQmqhOq65veE-DuK_kJYXGIx0Wi8,1427
 universal_mcp/tools/func_metadata.py,sha256=zIDXgIBvu5Gh8aNlg-Q7cZZos9Iky75MS0Me0BraXeM,8086
-universal_mcp/tools/manager.py,sha256=GMBKPl-W6zoyK6Hisiz-i9WROsV8W7VC9Vou8d55rXA,7983
+universal_mcp/tools/manager.py,sha256=eNYEGCeTvtSsyPkPWo4ciuJEqNw4ux-XCr0r5OyBejg,7981
 universal_mcp/tools/tools.py,sha256=8YBTaJCM38Nhan9Al6Vlq4FtSULrKlxg1q_o8OL1_FM,3322
 universal_mcp/utils/__init__.py,sha256=8wi4PGWu-SrFjNJ8U7fr2iFJ1ktqlDmSKj1xYd7KSDc,41
-universal_mcp/utils/agentr.py,sha256=GlFK5_RJXP3XpIGKLzkIe5nu2rfT6bqSoT0h1hipy9g,3438
+universal_mcp/utils/agentr.py,sha256=YmX6hvFW84keJKTZqP3jPz4rP9DM5wHZ0vTMHfxO6AI,3360
 universal_mcp/utils/common.py,sha256=HEZC2Mhilb8DrGXQG2tboAIw1r4veGilGWjfnPF1lyA,888
 universal_mcp/utils/docstring_parser.py,sha256=6oIeCjOUirFdVpXdGZt5zDKje6jmCY42-GeYOc_7r2I,11317
 universal_mcp/utils/installation.py,sha256=ItOfBFhKOh4DLz237jgAz_Fn0uOMdrKXw0n5BaUZZNs,7286
@@ -33,13 +33,13 @@ universal_mcp/utils/openapi/__inti__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMp
 universal_mcp/utils/openapi/api_generator.py,sha256=FjtvbnWuI1P8W8wXuKLCirUtsqQ4HI_TuQrhpA4SqTs,4749
 universal_mcp/utils/openapi/api_splitter.py,sha256=6O2y7fcCo2k3ixLr6_9-aAZx2kas3UAxQhqJy1esNkE,18829
 universal_mcp/utils/openapi/docgen.py,sha256=DNmwlhg_-TRrHa74epyErMTRjV2nutfCQ7seb_Rq5hE,21366
-universal_mcp/utils/openapi/openapi.py,sha256=6uH24mI_02yHBfz3dSsYZFpxy9G_dGr0mvDJFZ0JnvA,46547
+universal_mcp/utils/openapi/openapi.py,sha256=8XCIkJuwTN0UUcrBslQxitvz4y0NItBtuIgxdvb-Gdg,46857
 universal_mcp/utils/openapi/preprocessor.py,sha256=qLYv4ekors5B2OU_YUvXICYQ7XYhAOEPyAnKtnBvNpM,46699
 universal_mcp/utils/openapi/readme.py,sha256=R2Jp7DUXYNsXPDV6eFTkLiy7MXbSULUj1vHh4O_nB4c,2974
 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.18rc3.dist-info/METADATA,sha256=tTHxjWlSvE9VwhtC70HT_VenfsAgCeR0s-2PPNIsXyo,12125
-universal_mcp-0.1.18rc3.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-universal_mcp-0.1.18rc3.dist-info/entry_points.txt,sha256=QlBrVKmA2jIM0q-C-3TQMNJTTWOsOFQvgedBq2rZTS8,56
-universal_mcp-0.1.18rc3.dist-info/licenses/LICENSE,sha256=NweDZVPslBAZFzlgByF158b85GR0f5_tLQgq1NS48To,1063
-universal_mcp-0.1.18rc3.dist-info/RECORD,,
+universal_mcp-0.1.19.dist-info/METADATA,sha256=wPKF-GWj2l1ZK430vl25Su_RCi56JiyzV4opj_Lp4Rs,12122
+universal_mcp-0.1.19.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+universal_mcp-0.1.19.dist-info/entry_points.txt,sha256=QlBrVKmA2jIM0q-C-3TQMNJTTWOsOFQvgedBq2rZTS8,56
+universal_mcp-0.1.19.dist-info/licenses/LICENSE,sha256=NweDZVPslBAZFzlgByF158b85GR0f5_tLQgq1NS48To,1063
+universal_mcp-0.1.19.dist-info/RECORD,,