universal-mcp 0.1.8rc3__py3-none-any.whl → 0.1.9rc1__py3-none-any.whl

universal_mcp/applications/tavily/app.py

@@ -7,25 +7,6 @@ class TavilyApp(APIApplication):
         name = "tavily"
         self.base_url = "https://api.tavily.com"
         super().__init__(name=name, integration=integration)
-        self.api_key = None
-
-    def _get_headers(self):
-        if not self.api_key:
-            credentials = self.integration.get_credentials()
-            if not credentials:
-                raise ValueError("No credentials found")
-            api_key = (
-                credentials.get("api_key")
-                or credentials.get("API_KEY")
-                or credentials.get("apiKey")
-            )
-            if not api_key:
-                raise ValueError("No API key found")
-            self.api_key = api_key
-        return {
-            "Authorization": f"Bearer {self.api_key}",
-            "Content-Type": "application/json",
-        }
 
     def search(self, query: str) -> str:
         """
@@ -44,7 +25,6 @@ class TavilyApp(APIApplication):
         Tags:
             search, ai, web, query, important, api-client, text-processing
         """
-        self.validate()
         url = f"{self.base_url}/search"
         payload = {
             "query": query,

universal_mcp/applications/wrike/app.py

@@ -19,18 +19,6 @@ class WrikeApp(APIApplication):
         super().__init__(name="wrike", integration=integration, **kwargs)
         self.base_url = "https://www.wrike.com/api/v4"
 
-    def _get_headers(self):
-        if not self.integration:
-            raise ValueError("Integration not configured for WrikeApp")
-        credentials = self.integration.get_credentials()
-
-        if "headers" in credentials:
-            return credentials["headers"]
-        return {
-            "Authorization": f"Bearer {credentials['access_token']}",
-            "Content-Type": "application/json",
-        }
-
     def get_contacts(self, deleted=None, fields=None, metadata=None) -> Any:
         """
         Retrieves a list of contacts from the server, with optional filtering and field selection.

universal_mcp/applications/youtube/app.py

@@ -1,9 +1,6 @@
 from typing import Any
 
-from loguru import logger
-
 from universal_mcp.applications import APIApplication
-from universal_mcp.exceptions import NotAuthorizedError
 from universal_mcp.integrations import Integration
 
 
@@ -22,21 +19,6 @@ class YoutubeApp(APIApplication):
         super().__init__(name="youtube", integration=integration, **kwargs)
         self.base_url = "https://www.googleapis.com/youtube/v3"
 
-    def _get_headers(self):
-        if not self.integration:
-            raise ValueError("Integration not configured for YoutubeApp")
-        credentials = self.integration.get_credentials()
-        if not credentials:
-            logger.warning("No Google credentials found via integration.")
-            action = self.integration.authorize()
-            raise NotAuthorizedError(action)
-        if "headers" in credentials:
-            return credentials["headers"]
-        return {
-            "Authorization": f"Bearer {credentials['access_token']}",
-            "Content-Type": "application/json",
-        }
-
     def get_jobs_job_reports(
         self,
         jobId,

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 as e:
-            action = self.authorize()
-            raise NotAuthorizedError(action) from e
-        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/servers/server.py

@@ -9,8 +9,7 @@ from loguru import logger
 from mcp.server.fastmcp import FastMCP
 from mcp.types import TextContent
 
-from universal_mcp.analytics import analytics
-from universal_mcp.applications import Application, app_from_slug
+from universal_mcp.applications import BaseApplication, app_from_slug
 from universal_mcp.config import AppConfig, ServerConfig, StoreConfig
 from universal_mcp.integrations import AgentRIntegration, integration_from_config
 from universal_mcp.stores import BaseStore, store_from_config
@@ -130,7 +129,7 @@ class LocalServer(BaseServer):
         self.add_tool(store.delete)
         return store
 
-    def _load_app(self, app_config: AppConfig) -> Application | None:
+    def _load_app(self, app_config: AppConfig) -> BaseApplication | None:
         """Load a single application with its integration.
 
         Args:
@@ -145,7 +144,6 @@ class LocalServer(BaseServer):
                 if app_config.integration
                 else None
             )
-            analytics.track_app_loaded(app_config.name)  # Track app loading
             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)
@@ -204,7 +202,7 @@ class AgentRServer(BaseServer):
             logger.error(f"Failed to fetch apps from AgentR: {e}", exc_info=True)
             raise
 
-    def _load_app(self, app_config: AppConfig) -> Application | None:
+    def _load_app(self, app_config: AppConfig) -> BaseApplication | None:
         """Load a single application with AgentR integration.
 
         Args:
@@ -221,7 +219,6 @@ class AgentRServer(BaseServer):
                 if app_config.integration
                 else None
             )
-            analytics.track_app_loaded(app_config.name)  # Track app loading
             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)

universal_mcp/stores/store.py

@@ -69,6 +69,13 @@ class BaseStore(ABC):
         """
         pass
 
+    def __repr__(self):
+        return f"{self.__class__.__name__}()"
+    
+    def __str__(self):
+        return self.__repr__()
+    
+    
 
 class MemoryStore(BaseStore):
     """

universal_mcp/tools/tools.py

@@ -9,7 +9,7 @@ from loguru import logger
 from pydantic import BaseModel, Field
 
 from universal_mcp.analytics import analytics
-from universal_mcp.applications.application import Application
+from universal_mcp.applications import BaseApplication
 from universal_mcp.exceptions import NotAuthorizedError, ToolError
 from universal_mcp.utils.docstring_parser import parse_docstring
 
@@ -253,7 +253,7 @@ class ToolManager:
 
     def register_tools_from_app(
         self,
-        app: Application,
+        app: BaseApplication,
         tools: list[str] | None = None,
         tags: list[str] | None = None,
     ) -> None:

universal_mcp/utils/docstring_parser.py

@@ -4,16 +4,23 @@ from typing import Any
 
 def parse_docstring(docstring: str | None) -> dict[str, Any]:
     """
-    Parses a standard Python docstring into summary, args, returns, raises, and tags.
+    Parses a Python docstring into structured components: summary, arguments,
+    return value, raised exceptions, and custom tags.
+
+    Supports multi-line descriptions for each section. Recognizes common section
+    headers like 'Args:', 'Returns:', 'Raises:', 'Tags:', etc. Also attempts
+    to parse key-value pairs within 'Args:' and 'Raises:' sections.
 
     Args:
-        docstring: The docstring to parse.
+        docstring: The docstring string to parse, or None.
 
     Returns:
-        A dictionary with keys 'summary', 'args', 'returns', 'raises', 'tags'.
-        'args' is a dict mapping arg names to descriptions.
-        'raises' is a dict mapping exception type names to descriptions.
-        'tags' is a list of strings extracted from the 'Tags:' section, comma-separated.
+        A dictionary containing the parsed components:
+        - 'summary': The first paragraph of the docstring.
+        - 'args': A dictionary mapping argument names to their descriptions.
+        - 'returns': The description of the return value.
+        - 'raises': A dictionary mapping exception types to their descriptions.
+        - 'tags': A list of strings found in the 'Tags:' section.
     """
     if not docstring:
         return {"summary": "", "args": {}, "returns": "", "raises": {}, "tags": []}
@@ -22,123 +29,183 @@ def parse_docstring(docstring: str | None) -> dict[str, Any]:
     if not lines:
         return {"summary": "", "args": {}, "returns": "", "raises": {}, "tags": []}
 
-    summary = lines[0].strip()
-    args = {}
-    returns = ""
-    raises = {}
-    tags: list[str] = []  # Final list of parsed tags
-    current_section = None
-    current_key = None
-    current_desc_lines = []  # Accumulator for multi-line descriptions/tag content
+    summary: str = ""
+    summary_lines: list[str] = []
+    args: dict[str, str] = {}
+    returns: str = ""
+    raises: dict[str, str] = {}
+    tags: list[str] = []
+
+    current_section: str | None = None
+    current_key: str | None = None
+    current_desc_lines: list[str] = []
+
+    # Pattern to capture item key and the start of its description
+    # Matches "key:" or "key (type):" followed by description
     key_pattern = re.compile(r"^\s*([\w\.]+)\s*(?:\(.*\))?:\s*(.*)")
 
     def finalize_current_item():
-        """Helper function to finalize the currently parsed item."""
-        nonlocal returns, tags  # Allow modification of outer scope variables
+        """Processes the collected current_desc_lines and assigns them."""
+        nonlocal returns, tags, args, raises
         desc = " ".join(current_desc_lines).strip()
+
         if current_section == "args" and current_key:
-            args[current_key] = desc
+            if desc:
+                args[current_key] = desc
         elif current_section == "raises" and current_key:
-            raises[current_key] = desc
+            if desc:
+                 raises[current_key] = desc
         elif current_section == "returns":
             returns = desc
-        # SIM102 applied: Combine nested if
-        elif current_section == "tags" and desc:  # Only process if there's content
-            tags = [tag.strip() for tag in desc.split(",") if tag.strip()]
+        elif current_section == "tags":
+            # Tags section content is treated as a comma-separated list
+            tags.clear() # Clear existing tags in case of multiple tag sections (unlikely but safe)
+            tags.extend([tag.strip() for tag in desc.split(",") if tag.strip()])
+        # 'other' sections are ignored in the final output
+
+    def check_for_section_header(line: str) -> tuple[bool, str | None, str]:
+        """Checks if a line is a recognized section header."""
+        stripped_lower = line.strip().lower()
+        section_type: str | None = None
+        header_content = ""
 
-    # B007 applied: Rename unused loop variable i to _
-    for _, line in enumerate(lines[1:]):
+        if stripped_lower in ("args:", "arguments:", "parameters:"):
+            section_type = "args"
+        elif stripped_lower in ("returns:", "yields:"):
+            section_type = "returns"
+        elif stripped_lower in ("raises:", "errors:", "exceptions:"):
+             section_type = "raises"
+        elif stripped_lower in ("tags:",):
+             section_type = "tags"
+        # Allow "Raises Description:" or "Tags content:"
+        elif stripped_lower.startswith(("raises ", "errors ", "exceptions ")):
+             section_type = "raises"
+             # Capture content after header word and potential colon/space
+             parts = re.split(r"[:\s]+", line.strip(), maxsplit=1) # B034: Use keyword maxsplit
+             if len(parts) > 1:
+                header_content = parts[1].strip()
+        elif stripped_lower.startswith(("tags",)):
+            section_type = "tags"
+            # Capture content after header word and potential colon/space
+            parts = re.split(r"[:\s]+", line.strip(), maxsplit=1) # B034: Use keyword maxsplit
+            if len(parts) > 1:
+                header_content = parts[1].strip()
+
+
+        # Identify other known sections, but don't store their content
+        elif stripped_lower.endswith(":") and stripped_lower[:-1] in (
+            "attributes", "see also", "example", "examples", "notes", "todo", "fixme", "warning", "warnings"
+        ):
+            section_type = "other"
+
+        return section_type is not None, section_type, header_content
+
+
+    in_summary = True
+
+    for line in lines:
         stripped_line = line.strip()
         original_indentation = len(line) - len(line.lstrip(" "))
 
-        section_line = stripped_line.lower()
-        is_new_section_header = False
-        new_section_type = None
-        header_content = ""
+        is_new_section_header, new_section_type_this_line, header_content_this_line = check_for_section_header(line)
+
+        should_finalize_previous = False
+
+        # --- Summary Handling ---
+        if in_summary:
+            if not stripped_line or is_new_section_header:
+                # Empty line or section header marks the end of the summary
+                in_summary = False
+                summary = " ".join(summary_lines).strip()
+                summary_lines = [] # Clear summary_lines after finalizing summary
+
+                if not stripped_line:
+                     # If the line was just empty, continue to the next line
+                     # The new_section_header check will happen on the next iteration if it exists
+                     continue
+                # If it was a header, fall through to section handling below
+
+            else:
+                # Still in summary, append line
+                summary_lines.append(stripped_line)
+                continue # Process next line
+
+
+        # --- Section and Item Handling ---
+
+        # Decide if the previous item/section block should be finalized BEFORE processing the current line
+        # Finalize if:
+        # 1. A new section header is encountered.
+        # 2. An empty line is encountered AFTER we've started collecting content for an item or section.
+        # 3. In 'args' or 'raises', we encounter a line that looks like a new key: value pair, or a non-indented line.
+        # 4. In 'returns', 'tags', or 'other', we encounter a non-indented line after collecting content.
+        if is_new_section_header or (not stripped_line and (current_desc_lines or current_key is not None)) or \
+           (current_section in ["args", "raises"] and current_key is not None and (key_pattern.match(line) or (original_indentation == 0 and stripped_line))) or \
+           (current_section in ["returns", "tags", "other"] and current_desc_lines and original_indentation == 0 and stripped_line):
+            should_finalize_previous = True
+        elif current_section in ["args", "raises"] and current_key is not None:
+            # Inside args/raises, processing an item (current_key is set)
+            pass # Logic moved to the combined if statement
+        elif current_section in ["returns", "tags", "other"] and current_desc_lines:
+            # Inside returns/tags/other, collecting description lines
+            pass # Logic moved to the combined if statement
+
+        # If finalizing the previous item/section
+        if should_finalize_previous:
+            finalize_current_item()
+            # Reset state after finalizing the previous item/section block
+            # If it was a new section header, reset everything
+            # If it was an end-of-item/block signal within a section, reset key and description lines
+            # (The condition for resetting key here is complex but matches the original logic)
+            if is_new_section_header or (current_section in ["args", "raises"] and current_key is not None and not key_pattern.match(line) and (not stripped_line or original_indentation == 0)):
+                 current_key = None
+            current_desc_lines = [] # Always clear description lines
 
-        if section_line in ("args:", "arguments:", "parameters:"):
-            new_section_type = "args"
-            is_new_section_header = True
-        elif section_line in ("returns:", "yields:"):
-            new_section_type = "returns"
-            is_new_section_header = True
-        elif section_line.startswith(("raises ", "raises:", "errors:", "exceptions:")):
-            new_section_type = "raises"
-            is_new_section_header = True
-        elif section_line.startswith(
-            ("tags:", "tags")
-        ):  # Match "Tags:" or "Tags" potentially followed by content
-            new_section_type = "tags"
-            is_new_section_header = True
-            if ":" in stripped_line:
-                header_content = stripped_line.split(":", 1)[1].strip()
-        elif section_line.endswith(":") and section_line[:-1] in (
-            "attributes",
-            "see also",
-            "example",
-            "examples",
-            "notes",
-        ):
-            new_section_type = "other"
-            is_new_section_header = True
+        # --- Process the current line ---
 
-        finalize_previous = False
+        # If the current line is a section header
         if is_new_section_header:
-            finalize_previous = True
-        elif current_section in ["args", "raises"] and current_key:
-            if key_pattern.match(line) or (original_indentation == 0 and stripped_line):
-                finalize_previous = True
-        elif current_section in ["returns", "tags"] and current_desc_lines:
-            if original_indentation == 0 and stripped_line:
-                finalize_previous = True
-        # SIM102 applied: Combine nested if/elif
-        elif (
-            not stripped_line
-            and current_desc_lines
-            and current_section in ["args", "raises", "returns", "tags"]
-            and (current_section not in ["args", "raises"] or current_key)
-        ):
-            finalize_previous = True
-
-        if finalize_previous:
-            finalize_current_item()
-            current_key = None
-            current_desc_lines = []
-            if not is_new_section_header or new_section_type == "other":
-                current_section = None
-
-        if is_new_section_header and new_section_type != "other":
-            current_section = new_section_type
-            # If Tags header had content, start accumulating it
-            if new_section_type == "tags" and header_content:
-                current_desc_lines.append(header_content)
-            # Don't process the header line itself further
-            continue
+            current_section = new_section_type_this_line
+            if header_content_this_line:
+                 # Add content immediately following the header on the same line
+                 current_desc_lines.append(header_content_this_line)
+            continue # Move to the next line, header is processed
 
+        # If the line is empty, and not a section header (handled above), skip it
         if not stripped_line:
             continue
 
+        # If we are inside a section, process the line's content
         if current_section == "args" or current_section == "raises":
             match = key_pattern.match(line)
             if match:
+                # Found a new key: value item within args/raises
                 current_key = match.group(1)
-                current_desc_lines = [match.group(2).strip()]  # Start new description
-            elif (
-                current_key and original_indentation > 0
-            ):  # Check for indentation for continuation
-                current_desc_lines.append(stripped_line)
+                current_desc_lines = [match.group(2).strip()] # Start new description
+            elif current_key is not None:
+                 # Not a new key, but processing an existing item - append to description
+                 current_desc_lines.append(stripped_line)
+            # Lines that don't match key_pattern and occur when current_key is None
+            # within args/raises are effectively ignored by this block, which seems
+            # consistent with needing a key: description format.
+
+        elif current_section in ["returns", "tags", "other"]:
+            # In these sections, all non-empty, non-header lines are description lines
+            current_desc_lines.append(stripped_line)
+
+    # --- Finalization after loop ---
+    # Finalize any pending item/section block that was being collected
+    finalize_current_item()
 
-        elif current_section == "returns":
-            if not current_desc_lines or original_indentation > 0:
-                current_desc_lines.append(stripped_line)
+    # If the docstring only had a summary (no empty line or section header)
+    # ensure the summary is captured. This check is technically redundant
+    # because summary is finalized upon hitting the first empty line or header,
+    # or falls through to the final finalize call if neither occurs.
+    # Keeping it for clarity, though the logic flow should cover it.
+    if in_summary:
+         summary = " ".join(summary_lines).strip()
 
-        elif current_section == "tags":
-            if (
-                original_indentation > 0 or not current_desc_lines
-            ):  # Indented or first line
-                current_desc_lines.append(stripped_line)
 
-    finalize_current_item()
     return {
         "summary": summary,
         "args": args,
@@ -147,9 +214,9 @@ def parse_docstring(docstring: str | None) -> dict[str, Any]:
         "tags": tags,
     }
 
-
 docstring_example = """
-    Starts a crawl job for a given URL using Firecrawl. Returns the job ID immediately.
+    Starts a crawl job for a given URL using Firecrawl.
+Returns the job ID immediately.
 
     Args:
         url: The starting URL for the crawl.
@@ -163,17 +230,17 @@ docstring_example = """
         or a string containing an error message on failure. This description
         can also span multiple lines.
 
-    Raises:
+Raises:
         ValueError: If the URL is invalid.
-        requests.exceptions.ConnectionError: If connection fails.
+        ConnectionError: If connection fails.
 
     Tags:
         crawl, async_job, start, api,  long_tag_example , another
         , final_tag
-"""
+    """
 
 if __name__ == "__main__":
-    parsed = parse_docstring(docstring_example)
     import json
 
-    print(json.dumps(parsed, indent=4))
+    parsed = parse_docstring(docstring_example)
+    print(json.dumps(parsed, indent=4))