universal-mcp 0.1.8rc2__py3-none-any.whl → 0.1.8rc4__py3-none-any.whl

universal_mcp/applications/zenquotes/app.py

@@ -8,16 +8,16 @@ class ZenquotesApp(APIApplication):
     def get_quote(self) -> str:
         """
         Fetches a random inspirational quote from the Zen Quotes API.
-        
+
         Returns:
             A formatted string containing the quote and its author in the format 'quote - author'
-        
+
         Raises:
             RequestException: If the HTTP request to the Zen Quotes API fails
             JSONDecodeError: If the API response contains invalid JSON
             IndexError: If the API response doesn't contain any quotes
             KeyError: If the quote data doesn't contain the expected 'q' or 'a' fields
-        
+
         Tags:
             fetch, quotes, api, http, important
         """

universal_mcp/exceptions.py

@@ -8,5 +8,6 @@ class NotAuthorizedError(Exception):
 class ToolError(Exception):
     """Raised when a tool is not found or fails to execute."""
 
+
 class InvalidSignature(Exception):
     """Raised when a signature is invalid."""

universal_mcp/integrations/__init__.py

@@ -8,7 +8,9 @@ from universal_mcp.integrations.integration import (
 from universal_mcp.stores.store import BaseStore
 
 
-def integration_from_config(config: IntegrationConfig, store: BaseStore | None = None, **kwargs) -> Integration:
+def integration_from_config(
+    config: IntegrationConfig, store: BaseStore | None = None, **kwargs
+) -> Integration:
     if config.type == "api_key":
         return ApiKeyIntegration(config.name, store=store, **kwargs)
     elif config.type == "agentr":
@@ -19,4 +21,11 @@ def integration_from_config(config: IntegrationConfig, store: BaseStore | None =
     else:
         raise ValueError(f"Unsupported integration type: {config.type}")
 
-__all__ = ["AgentRIntegration", "Integration", "ApiKeyIntegration", "OAuthIntegration", "integration_from_config"]
+
+__all__ = [
+    "AgentRIntegration",
+    "Integration",
+    "ApiKeyIntegration",
+    "OAuthIntegration",
+    "integration_from_config",
+]

universal_mcp/integrations/agentr.py

@@ -29,7 +29,10 @@ class AgentRIntegration(Integration):
                 "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 = os.getenv("AGENTR_BASE_URL", "https://api.agentr.dev")
+        self.base_url = os.getenv("AGENTR_BASE_URL", "https://api.agentr.dev").rstrip(
+            "/"
+        )
+        self._credentials = None
 
     def set_credentials(self, credentials: dict | None = None):
         """Set credentials for the integration.
@@ -43,9 +46,9 @@ class AgentRIntegration(Integration):
             str: Authorization URL from authorize() method
         """
         return self.authorize()
-        # raise NotImplementedError("AgentR Integration does not support setting credentials. Visit the authorize url to set credentials.")
 
-    def get_credentials(self):
+    @property
+    def credentials(self):
         """Get credentials for the integration from the AgentR API.
 
         Makes API request to retrieve stored credentials for this integration.
@@ -57,16 +60,36 @@ class AgentRIntegration(Integration):
             NotAuthorizedError: If credentials are not found (404 response)
             HTTPError: For other API errors
         """
+        if self._credentials is not None:
+            return self._credentials
         response = httpx.get(
             f"{self.base_url}/api/{self.name}/credentials/",
             headers={"accept": "application/json", "X-API-KEY": self.api_key},
         )
         if response.status_code == 404:
+            logger.warning(
+                f"No credentials found for {self.name}. Requesting authorization..."
+            )
             action = self.authorize()
             raise NotAuthorizedError(action)
         response.raise_for_status()
         data = response.json()
-        return data
+        self._credentials = data
+        return self._credentials
+
+    def get_credentials(self):
+        """Get credentials for the integration from the AgentR API.
+
+        Makes API request to retrieve stored credentials for this integration.
+
+        Returns:
+            dict: Credentials data from API response
+
+        Raises:
+            NotAuthorizedError: If credentials are not found (404 response)
+            HTTPError: For other API errors
+        """
+        return self.credentials
 
     def authorize(self):
         """Get authorization URL for the integration.

universal_mcp/integrations/integration.py

@@ -91,9 +91,22 @@ class ApiKeyIntegration(Integration):
     """
 
     def __init__(self, name: str, store: BaseStore | None = None, **kwargs):
+        self.type = "api_key"
         sanitized_name = sanitize_api_key_name(name)
         super().__init__(sanitized_name, store, **kwargs)
         logger.info(f"Initializing API Key Integration: {name} with store: {store}")
+        self._api_key: str | None = None
+
+    @property
+    def api_key(self) -> str | None:
+        if not self._api_key:
+            try:
+                credentials = self.store.get(self.name)
+                self.api_key = credentials
+            except KeyNotFoundError as e:
+                action = self.authorize()
+                raise NotAuthorizedError(action) from e
+        return self._api_key
 
     def get_credentials(self) -> dict[str, str]:
         """Get API key credentials.
@@ -104,12 +117,7 @@ class ApiKeyIntegration(Integration):
         Raises:
             NotAuthorizedError: If API key is not found.
         """
-        try:
-            credentials = self.store.get(self.name)
-        except KeyNotFoundError:
-            action = self.authorize()
-            raise NotAuthorizedError(action)
-        return {"api_key": credentials}
+        return {"api_key": self.api_key}
 
     def set_credentials(self, credentials: dict[str, Any]) -> None:
         """Set API key credentials.

universal_mcp/logger.py

@@ -1,70 +1,17 @@
-import os
 import sys
-import uuid
-from functools import lru_cache
 
 from loguru import logger
 
 
-@lru_cache(maxsize=1)
-def get_version():
-    """
-    Get the version of the Universal MCP
-    """
-    try:
-        from importlib.metadata import version
-
-        return version("universal_mcp")
-    except ImportError:
-        return "unknown"
-
-
-def get_user_id():
-    """
-    Generate a unique user ID for the current session
-    """
-    return "universal_" + str(uuid.uuid4())[:8]
-
-
-def posthog_sink(message, user_id=get_user_id()):
-    """
-    Custom sink for sending logs to PostHog
-    """
-    try:
-        import posthog
-
-        posthog.host = "https://us.i.posthog.com"
-        posthog.api_key = "phc_6HXMDi8CjfIW0l04l34L7IDkpCDeOVz9cOz1KLAHXh8"
-
-        record = message.record
-        properties = {
-            "level": record["level"].name,
-            "module": record["name"],
-            "function": record["function"],
-            "line": record["line"],
-            "message": record["message"],
-            "version": get_version(),
-        }
-        posthog.capture(user_id, "universal_mcp", properties)
-    except Exception:
-        # Silently fail if PostHog capture fails - don't want logging to break the app
-        pass
-
-
 def setup_logger():
     logger.remove()
+    # STDOUT cant be used as a sink because it will break the stream
     # logger.add(
     #     sink=sys.stdout,
-    #     format="<green>{time:YYYY-MM-DD HH:mm:ss}</green> | <level>{level: <8}</level> | <cyan>{name}</cyan>:<cyan>{function}</cyan>:<cyan>{line}</cyan> - <level>{message}</level>",
     #     level="INFO",
-    #     colorize=True,
     # )
+    # STDERR
     logger.add(
         sink=sys.stderr,
-        format="<red>{time:YYYY-MM-DD HH:mm:ss}</red> | <level>{level: <8}</level> | <cyan>{name}</cyan>:<cyan>{function}</cyan>:<cyan>{line}</cyan> - <level>{message}</level>",
-        level="WARNING",
-        colorize=True,
+        level="INFO",
     )
-    telemetry_enabled = os.getenv("TELEMETRY_ENABLED", "true").lower() == "true"
-    if telemetry_enabled:
-        logger.add(posthog_sink, level="INFO")  # PostHog telemetry

universal_mcp/servers/__init__.py

@@ -11,4 +11,5 @@ def server_from_config(config: ServerConfig):
     else:
         raise ValueError(f"Unsupported server type: {config.type}")
 
-__all__ = [AgentRServer, LocalServer, server_from_config]
+
+__all__ = [AgentRServer, LocalServer, server_from_config]

universal_mcp/servers/server.py

@@ -1,6 +1,7 @@
 import os
 from abc import ABC, abstractmethod
-from typing import Any, Callable
+from collections.abc import Callable
+from typing import Any
 from urllib.parse import urlparse
 
 import httpx
@@ -10,18 +11,17 @@ from mcp.types import TextContent
 
 from universal_mcp.applications import Application, app_from_slug
 from universal_mcp.config import AppConfig, ServerConfig, StoreConfig
-from universal_mcp.exceptions import NotAuthorizedError, ToolError
-from universal_mcp.integrations import integration_from_config
+from universal_mcp.integrations import AgentRIntegration, integration_from_config
 from universal_mcp.stores import BaseStore, store_from_config
 from universal_mcp.tools.tools import ToolManager
 
 
 class BaseServer(FastMCP, ABC):
     """Base server class with common functionality.
-    
+
     This class provides core server functionality including store setup,
     tool management, and application loading.
-    
+
     Args:
         config: Server configuration
         **kwargs: Additional keyword arguments passed to FastMCP
@@ -29,29 +29,12 @@ class BaseServer(FastMCP, ABC):
 
     def __init__(self, config: ServerConfig, **kwargs):
         super().__init__(config.name, config.description, **kwargs)
-        logger.info(f"Initializing server: {config.name} with store: {config.store}")
-        
+        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)
-        self.store = self._setup_store(config.store)
-        self._load_apps()
-
-    def _setup_store(self, store_config: StoreConfig | None) -> BaseStore | None:
-        """Setup and configure the store.
-        
-        Args:
-            store_config: Store configuration
-            
-        Returns:
-            Configured store instance or None if no config provided
-        """
-        if not store_config:
-            return None
-            
-        store = store_from_config(store_config)
-        self.add_tool(store.set)
-        self.add_tool(store.delete)
-        return store
 
     @abstractmethod
     def _load_apps(self) -> None:
@@ -60,7 +43,7 @@ class BaseServer(FastMCP, ABC):
 
     def add_tool(self, tool: Callable) -> None:
         """Add a tool to the server.
-        
+
         Args:
             tool: Tool to add
         """
@@ -68,68 +51,57 @@ class BaseServer(FastMCP, ABC):
 
     async def list_tools(self) -> list[dict]:
         """List all available tools in MCP format.
-        
+
         Returns:
             List of tool definitions
         """
-        return self._tool_manager.list_tools(format='mcp')
-    
+        return self._tool_manager.list_tools(format="mcp")
+
     def _format_tool_result(self, result: Any) -> list[TextContent]:
         """Format tool result into TextContent list.
-        
+
         Args:
             result: Raw tool result
-            
+
         Returns:
             List of TextContent objects
         """
         if isinstance(result, str):
             return [TextContent(type="text", text=result)]
-        elif isinstance(result, list) and all(isinstance(item, TextContent) for item in result):
+        elif isinstance(result, list) and all(
+            isinstance(item, TextContent) for item in result
+        ):
             return result
         else:
-            logger.warning(f"Tool returned unexpected type: {type(result)}. Wrapping in TextContent.")
+            logger.warning(
+                f"Tool returned unexpected type: {type(result)}. Wrapping in TextContent."
+            )
             return [TextContent(type="text", text=str(result))]
-                    
-    async def call_tool(self, name: str, arguments: dict[str, Any]) -> list[TextContent]:
+
+    async def call_tool(
+        self, name: str, arguments: dict[str, Any]
+    ) -> list[TextContent]:
         """Call a tool with comprehensive error handling.
-        
+
         Args:
             name: Tool name
             arguments: Tool arguments
-            
+
         Returns:
             List of TextContent results
-            
+
         Raises:
             ToolError: If tool execution fails
         """
         logger.info(f"Calling tool: {name} with arguments: {arguments}")
-        try:
-            result = await self._tool_manager.call_tool(name, arguments)
-            logger.info(f"Tool '{name}' completed successfully")
-            return self._format_tool_result(result)
-
-        except ToolError as e:
-            if isinstance(e.__cause__, NotAuthorizedError):
-                message = f"Not authorized to call tool {name}: {e.__cause__.message}"
-                logger.warning(message)
-                return [TextContent(type="text", text=message)]
-            elif isinstance(e.__cause__, httpx.HTTPError):
-                message = f"HTTP error calling tool {name}: {str(e.__cause__)}"
-                logger.error(message)
-                return [TextContent(type="text", text=message)]
-            elif isinstance(e.__cause__, ValueError):
-                message = f"Invalid arguments for tool {name}: {str(e.__cause__)}"
-                logger.error(message)
-                return [TextContent(type="text", text=message)]
-            logger.error(f"Error calling tool {name}: {str(e)}", exc_info=True)
-            raise
+        result = await self._tool_manager.call_tool(name, arguments)
+        logger.info(f"Tool '{name}' completed successfully")
+        return self._format_tool_result(result)
 
 
 class LocalServer(BaseServer):
     """Local development server implementation.
-    
+
     Args:
         config: Server configuration
         **kwargs: Additional keyword arguments passed to FastMCP
@@ -137,21 +109,41 @@ class LocalServer(BaseServer):
 
     def __init__(self, config: ServerConfig, **kwargs):
         super().__init__(config, **kwargs)
+        self.store = self._setup_store(config.store)
+        self._load_apps()
+
+    def _setup_store(self, store_config: StoreConfig | None) -> BaseStore | None:
+        """Setup and configure the store.
+
+        Args:
+            store_config: Store configuration
+
+        Returns:
+            Configured store instance or None if no config provided
+        """
+        if not store_config:
+            return None
+
+        store = store_from_config(store_config)
+        self.add_tool(store.set)
+        self.add_tool(store.delete)
+        return store
 
     def _load_app(self, app_config: AppConfig) -> Application | None:
         """Load a single application with its integration.
-        
+
         Args:
             app_config: Application configuration
-            
+
         Returns:
             Configured application instance or None if loading fails
         """
         try:
-            integration = integration_from_config(
-                app_config.integration,
-                store=self.store
-            ) if app_config.integration  else None
+            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)
         except Exception as e:
             logger.error(f"Failed to load app {app_config.name}: {e}", exc_info=True)
@@ -168,7 +160,7 @@ class LocalServer(BaseServer):
 
 class AgentRServer(BaseServer):
     """AgentR API-connected server implementation.
-    
+
     Args:
         config: Server configuration
         api_key: Optional API key for AgentR authentication. If not provided,
@@ -179,21 +171,22 @@ class AgentRServer(BaseServer):
     def __init__(self, config: ServerConfig, api_key: str | None = None, **kwargs):
         self.api_key = api_key or os.getenv("AGENTR_API_KEY")
         self.base_url = os.getenv("AGENTR_BASE_URL", "https://api.agentr.dev")
-        
+
         if not self.api_key:
             raise ValueError("API key required - get one at https://agentr.dev")
         parsed = urlparse(self.base_url)
         if not all([parsed.scheme, parsed.netloc]):
             raise ValueError(f"Invalid base URL format: {self.base_url}")
-
         super().__init__(config, **kwargs)
-        
+        self.integration = AgentRIntegration(name="agentr", api_key=self.api_key)
+        self._load_apps()
+
     def _fetch_apps(self) -> list[AppConfig]:
         """Fetch available apps from AgentR API.
-        
+
         Returns:
             List of application configurations
-            
+
         Raises:
             httpx.HTTPError: If API request fails
         """
@@ -211,17 +204,20 @@ class AgentRServer(BaseServer):
 
     def _load_app(self, app_config: AppConfig) -> Application | None:
         """Load a single application with AgentR integration.
-        
+
         Args:
             app_config: Application configuration
-            
+
         Returns:
             Configured application instance or None if loading fails
         """
         try:
-            integration = integration_from_config(
-                app_config.integration,
-                api_key=self.api_key
+            integration = (
+                AgentRIntegration(
+                    name=app_config.integration.name, api_key=self.api_key
+                )
+                if app_config.integration
+                else None
             )
             return app_from_slug(app_config.name)(integration=integration)
         except Exception as e:

universal_mcp/stores/store.py

@@ -8,11 +8,13 @@ from loguru import logger
 
 class StoreError(Exception):
     """Base exception class for store-related errors."""
+
     pass
 
 
 class KeyNotFoundError(StoreError):
     """Exception raised when a key is not found in the store."""
+
     pass
 
 
@@ -29,10 +31,10 @@ class BaseStore(ABC):
 
         Args:
             key (str): The key to look up
-        
+
         Returns:
             Any: The stored value
-            
+
         Raises:
             KeyNotFoundError: If the key is not found in the store
             StoreError: If there is an error accessing the store
@@ -223,7 +225,7 @@ class KeyringStore(BaseStore):
             keyring.set_password(self.app_name, key, value)
         except Exception as e:
             raise StoreError(f"Error storing in keyring: {str(e)}") from e
-        
+
     def delete(self, key: str) -> None:
         """
         Delete a password from the system keyring.

universal_mcp/tools/__init__.py

@@ -1,3 +1,3 @@
 from .tools import Tool, ToolManager
 
-__all__ = ["Tool", "ToolManager"]
+__all__ = ["Tool", "ToolManager"]

universal_mcp/tools/adapters.py

@@ -5,16 +5,19 @@ def convert_tool_to_mcp_tool(
     tool: Tool,
 ):
     from mcp.server.fastmcp.server import MCPTool
+
     return MCPTool(
         name=tool.name,
         description=tool.description or "",
         inputSchema=tool.parameters,
     )
 
+
 def convert_tool_to_langchain_tool(
     tool: Tool,
 ):
     from langchain_core.tools import StructuredTool
+
     """Convert an tool to a LangChain tool.
 
     NOTE: this tool can be executed only in a context of an active MCP client session.
@@ -37,4 +40,4 @@ def convert_tool_to_langchain_tool(
         description=tool.description or "",
         coroutine=call_tool,
         response_format="content",
-    )
+    )

universal_mcp/tools/func_metadata.py

@@ -135,12 +135,9 @@ class FuncMetadata(BaseModel):
         arbitrary_types_allowed=True,
     )
 
-
     @classmethod
     def func_metadata(
-        cls,
-        func: Callable[..., Any],
-        skip_names: Sequence[str] = ()
+        cls, func: Callable[..., Any], skip_names: Sequence[str] = ()
     ) -> "FuncMetadata":
         """Given a function, return metadata including a pydantic model representing its
         signature.
@@ -201,7 +198,10 @@ class FuncMetadata(BaseModel):
                 if param.default is not inspect.Parameter.empty
                 else PydanticUndefined,
             )
-            dynamic_pydantic_model_params[param.name] = (field_info.annotation, field_info)
+            dynamic_pydantic_model_params[param.name] = (
+                field_info.annotation,
+                field_info,
+            )
             continue
 
         arguments_model = create_model(
@@ -211,4 +211,3 @@ class FuncMetadata(BaseModel):
         )
         resp = FuncMetadata(arg_model=arguments_model)
         return resp
-