mcp-instana 0.1.1__py3-none-any.whl → 0.2.0__py3-none-any.whl

src/automation/action_history.py

@@ -0,0 +1,338 @@
+"""
+Automation Action History MCP Tools Module
+
+This module provides automation action history tools for Instana Automation.
+"""
+
+import logging
+from typing import Any, Dict, List, Optional, Union
+
+# Import the necessary classes from the SDK
+try:
+    from instana_client.api.action_history_api import (
+        ActionHistoryApi,
+    )
+except ImportError:
+    import logging
+    logger = logging.getLogger(__name__)
+    logger.error("Failed to import action history API", exc_info=True)
+    raise
+
+
+from src.core.utils import BaseInstanaClient, register_as_tool, with_header_auth
+
+# Configure logger for this module
+logger = logging.getLogger(__name__)
+
+class ActionHistoryMCPTools(BaseInstanaClient):
+    """Tools for automation action history in Instana MCP."""
+
+    def __init__(self, read_token: str, base_url: str):
+        """Initialize the Action History MCP tools client."""
+        super().__init__(read_token=read_token, base_url=base_url)
+
+    @register_as_tool
+    @with_header_auth(ActionHistoryApi)
+    async def submit_automation_action(self,
+                                     payload: Union[Dict[str, Any], str],
+                                     ctx=None,
+                                     api_client=None) -> Dict[str, Any]:
+        """
+        Submit an automation action for execution on an agent.
+        The automation action to execute and the agent on which to execute the action must be specified as actionId and hostId. For more details on the request payload see the request sample.
+
+        Args:
+            Sample payload:
+            {
+            "hostId": "aHostId",
+            "actionId": "d473c1b0-0740-4d08-95fe-31e5d0a9faff",
+            "policyId": "2nIOVtEW-iPbsEIi89-yDqJabc",
+            "inputParameters": [
+                {
+                "name": "name",
+                "type": "type",
+                "value": "value"
+                }
+            ],
+            "eventId": "M3wuBxuaSDyecZJ7ICioiw",
+            "async": "true",
+            "timeout": "600"
+            }
+
+            Required fields:
+            - actionId: Action identifier of the action to run
+            - hostId: Agent host identifier on which to run the action
+
+            Optional fields:
+            - async: "true" if the action should be run in asynchronous mode, "false" otherwise. Default is "true"
+            - eventId: Event identifier (incident or issue) associated with the policy
+            - policyId: Policy identifier that associates the action trigger to the action to run
+            - timeout: Action run time out. Default is 30 seconds
+            - inputParameters: Array of action run input parameters
+
+            ctx: Optional[Dict[str, Any]]: The context for the action execution
+            api_client: Optional[ActionHistoryApi]: The API client for action execution
+
+        Returns:
+            Dict[str, Any]: The result of the automation action submission
+        """
+        try:
+            if not payload:
+                return {"error": "payload is required"}
+
+            # Parse the payload if it's a string
+            if isinstance(payload, str):
+                logger.debug("Payload is a string, attempting to parse")
+                try:
+                    import json
+                    try:
+                        parsed_payload = json.loads(payload)
+                        logger.debug("Successfully parsed payload as JSON")
+                        request_body = parsed_payload
+                    except json.JSONDecodeError as e:
+                        logger.debug(f"JSON parsing failed: {e}, trying with quotes replaced")
+
+                        # Try replacing single quotes with double quotes
+                        fixed_payload = payload.replace("'", "\"")
+                        try:
+                            parsed_payload = json.loads(fixed_payload)
+                            logger.debug("Successfully parsed fixed JSON")
+                            request_body = parsed_payload
+                        except json.JSONDecodeError:
+                            # Try as Python literal
+                            import ast
+                            try:
+                                parsed_payload = ast.literal_eval(payload)
+                                logger.debug("Successfully parsed payload as Python literal")
+                                request_body = parsed_payload
+                            except (SyntaxError, ValueError) as e2:
+                                logger.debug(f"Failed to parse payload string: {e2}")
+                                return {"error": f"Invalid payload format: {e2}", "payload": payload}
+                except Exception as e:
+                    logger.debug(f"Error parsing payload string: {e}")
+                    return {"error": f"Failed to parse payload: {e}", "payload": payload}
+            else:
+                # If payload is already a dictionary, use it directly
+                logger.debug("Using provided payload dictionary")
+                request_body = payload
+
+            # Validate required fields in the payload
+            required_fields = ["actionId", "hostId"]
+            for field in required_fields:
+                if field not in request_body:
+                    logger.warning(f"Missing required field: {field}")
+                    return {"error": f"Missing required field: {field}"}
+
+            # Import the ActionInstanceRequest class
+            try:
+                from instana_client.models.action_instance_request import (
+                    ActionInstanceRequest,
+                )
+                logger.debug("Successfully imported ActionInstanceRequest")
+            except ImportError as e:
+                logger.debug(f"Error importing ActionInstanceRequest: {e}")
+                return {"error": f"Failed to import ActionInstanceRequest: {e!s}"}
+
+            # Create an ActionInstanceRequest object from the request body
+            try:
+                logger.debug(f"Creating ActionInstanceRequest with params: {request_body}")
+                config_object = ActionInstanceRequest(**request_body)
+                logger.debug("Successfully created config object")
+            except Exception as e:
+                logger.debug(f"Error creating ActionInstanceRequest: {e}")
+                return {"error": f"Failed to create config object: {e!s}"}
+
+            # Call the add_action_instance method from the SDK
+            logger.debug("Calling add_action_instance with config object")
+            result = api_client.add_action_instance(
+                action_instance_request=config_object,
+            )
+
+            # Convert the result to a dictionary
+            if hasattr(result, 'to_dict'):
+                result_dict = result.to_dict()
+            else:
+                # If it's already a dict or another format, use it as is
+                result_dict = result or {
+                    "success": True,
+                    "message": "Automation action submitted successfully"
+                }
+
+            logger.debug(f"Result from add_action_instance: {result_dict}")
+            return result_dict
+        except Exception as e:
+            logger.error(f"Error in submit_automation_action: {e}")
+            return {"error": f"Failed to submit automation action: {e!s}"}
+
+    @register_as_tool
+    @with_header_auth(ActionHistoryApi)
+    async def get_action_instance_details(self,
+                                        action_instance_id: str,
+                                        window_size: Optional[int] = None,
+                                        to: Optional[int] = None,
+                                        ctx=None,
+                                        api_client=None) -> Dict[str, Any]:
+        """
+        Get the details of an automation action run result by ID from action run history.
+
+        Args:
+            action_instance_id: Action run result ID to get action run result details (required)
+            window_size: Window size in milliseconds. This value is used to compute the from date (from = to - windowSize) to get the action run result details. The default windowSize is set to 10 minutes if this value is not provided.
+            to: To date filter in milliseconds (13-digit) to get the action run result details. The default to date is set to System.currentTimeMillis() if this value is not provided.
+            ctx: Optional[Dict[str, Any]]: The context for the action instance retrieval
+            api_client: Optional[ActionHistoryApi]: The API client for action history
+
+        Returns:
+            Dict[str, Any]: The details of the automation action run result
+        """
+        try:
+            if not action_instance_id:
+                return {"error": "action_instance_id is required"}
+
+            logger.debug(f"Getting action instance details for ID: {action_instance_id}")
+            result = api_client.get_action_instance(
+                action_instance_id=action_instance_id,
+                window_size=window_size,
+                to=to,
+            )
+
+            # Convert the result to a dictionary
+            if hasattr(result, 'to_dict'):
+                result_dict = result.to_dict()
+            else:
+                # If it's already a dict or another format, use it as is
+                result_dict = result or {
+                    "success": True,
+                    "message": "Action instance details retrieved successfully"
+                }
+
+            logger.debug(f"Result from get_action_instance: {result_dict}")
+            return result_dict
+        except Exception as e:
+            logger.error(f"Error in get_action_instance_details: {e}")
+            return {"error": f"Failed to get action instance details: {e!s}"}
+
+    @register_as_tool
+    @with_header_auth(ActionHistoryApi)
+    async def list_action_instances(self,
+                                  window_size: Optional[int] = None,
+                                  to: Optional[int] = None,
+                                  page: Optional[int] = None,
+                                  page_size: Optional[int] = None,
+                                  target_snapshot_id: Optional[str] = None,
+                                  event_id: Optional[str] = None,
+                                  event_specification_id: Optional[str] = None,
+                                  search: Optional[str] = None,
+                                  types: Optional[List[str]] = None,
+                                  action_statuses: Optional[List[str]] = None,
+                                  order_by: Optional[str] = None,
+                                  order_direction: Optional[str] = None,
+                                  ctx=None,
+                                  api_client=None) -> Dict[str, Any]:
+        """
+        Get the details of automation action run results from action run history.
+
+        Args:
+            window_size: Window size filter in milliseconds (to compute the from date) to get the action run result details
+            to: To date filter in milliseconds (13-digit) to get the action run result details
+            page: Page to fetch -- used for paging the action run result records
+            page_size: Number of records to return in each page -- used for paging the action run result records
+            target_snapshot_id: Target snapshot ID filter to get the action run result details
+            event_id: Event ID filter to get the action run result details
+            event_specification_id: Event specification ID filter to get the action run result details
+            search: Text in action run result name, description and event name filter to get the action run result details
+            types: Action type filter to get the action run result details
+            action_statuses: Action status filter to get the action run result details
+            order_by: Action run result column to order the result set
+            order_direction: Sort order direction
+
+            ctx: Optional[Dict[str, Any]]: The context for the action instances retrieval
+            api_client: Optional[ActionHistoryApi]: The API client for action history
+
+        Returns:
+            Dict[str, Any]: The paginated list of automation action run results
+        """
+        try:
+            logger.debug("Getting action instances with parameters")
+            result = api_client.get_action_instances(
+                window_size=window_size,
+                to=to,
+                page=page,
+                page_size=page_size,
+                target_snapshot_id=target_snapshot_id,
+                event_id=event_id,
+                event_specification_id=event_specification_id,
+                search=search,
+                types=types,
+                action_statuses=action_statuses,
+                order_by=order_by,
+                order_direction=order_direction
+            )
+
+            # Convert the result to a dictionary
+            if hasattr(result, 'to_dict'):
+                result_dict = result.to_dict()
+            else:
+                # If it's already a dict or another format, use it as is
+                result_dict = result or {
+                    "success": True,
+                    "message": "Action instances retrieved successfully"
+                }
+
+            logger.debug(f"Result from get_action_instances: {result_dict}")
+            return result_dict
+        except Exception as e:
+            logger.error(f"Error in list_action_instances: {e}")
+            return {"error": f"Failed to list action instances: {e!s}"}
+
+    @register_as_tool
+    @with_header_auth(ActionHistoryApi)
+    async def delete_action_instance(self,
+                                   action_instance_id: str,
+                                   from_time: int,
+                                   to_time: int,
+                                   ctx=None,
+                                   api_client=None) -> Dict[str, Any]:
+        """
+        Delete an automation action run result from the action run history by ID.
+
+        Args:
+            action_instance_id: Automation action run result ID to delete (required)
+            from_time: From date filter in milliseconds (13-digit) to look up the action run result ID (required)
+            to_time: To date filter in milliseconds (13-digit) to look up the action run result ID (required)
+            ctx: Optional[Dict[str, Any]]: The context for the action instance deletion
+            api_client: Optional[ActionHistoryApi]: The API client for action history
+
+        Returns:
+            Dict[str, Any]: The result of the action instance deletion
+        """
+        try:
+            if not action_instance_id:
+                return {"error": "action_instance_id is required"}
+            if not from_time:
+                return {"error": "from_time is required"}
+            if not to_time:
+                return {"error": "to_time is required"}
+
+            logger.debug(f"Deleting action instance with ID: {action_instance_id}")
+            result = api_client.delete_action_instance(
+                action_instance_id=action_instance_id,
+                var_from=from_time,
+                to=to_time,
+            )
+
+            # Convert the result to a dictionary
+            if hasattr(result, 'to_dict'):
+                result_dict = result.to_dict()
+            else:
+                # If it's already a dict or another format, use it as is
+                result_dict = result or {
+                    "success": True,
+                    "message": "Action instance deleted successfully"
+                }
+
+            logger.debug(f"Result from delete_action_instance: {result_dict}")
+            return result_dict
+        except Exception as e:
+            logger.error(f"Error in delete_action_instance: {e}")
+            return {"error": f"Failed to delete action instance: {e!s}"}

src/core/server.py

@@ -16,7 +16,7 @@ from typing import Any
 
 from dotenv import load_dotenv
 
-from src.prompts.prompt_loader import register_prompts
+from src.prompts import PROMPT_REGISTRY
 
 load_dotenv()
 
@@ -77,6 +77,11 @@ class MCPState:
     app_topology_client: Any = None
     app_analyze_client: Any = None
     app_settings_client: Any = None
+    app_global_alert_client: Any = None
+    website_metrics_client: Any = None
+    website_catalog_client: Any = None
+    website_analyze_client: Any = None
+    website_configuration_client: Any = None
 
 # Global variables to store credentials for lifespan
 _global_token = None
@@ -130,7 +135,7 @@ async def lifespan(server: FastMCP) -> AsyncIterator[MCPState]:
         # Yield empty state if client creation failed
         yield MCPState()
 
-def create_app(token: str, base_url: str, port: int = 8000, enabled_categories: str = "all") -> tuple[FastMCP, int]:
+def create_app(token: str, base_url: str, port: int = int(os.getenv("PORT", "8080")), enabled_categories: str = "all") -> tuple[FastMCP, int]:
     """Create and configure the MCP server with the given credentials."""
     try:
         server = FastMCP(name="Instana MCP Server", host="0.0.0.0", port=port)
@@ -153,7 +158,48 @@ def create_app(token: str, base_url: str, port: int = 8000, enabled_categories:
                 logger.error(f"Failed to register tool {tool_name}: {e}", exc_info=True)
 
         # Register prompts from the prompt registry
-        register_prompts(server)
+        # Get enabled prompt categories - use the same categories as tools
+        prompt_categories = get_prompt_categories()
+
+        # Use the same categories for prompts as for tools
+        enabled_prompt_categories = []
+        if enabled_categories.lower() == "all" or not enabled_categories:
+            enabled_prompt_categories = list(prompt_categories.keys())
+            logger.info("Enabling all prompt categories")
+        else:
+            enabled_prompt_categories = [cat.strip() for cat in enabled_categories.split(",") if cat.strip() in prompt_categories]
+            logger.info(f"Enabling prompt categories: {', '.join(enabled_prompt_categories)}")
+
+        # Register prompts to the server
+        logger.info("Registering prompts by category:")
+        registered_prompts = set()
+
+        for category, prompt_groups in prompt_categories.items():
+            if category in enabled_prompt_categories:
+                logger.info(f"  - {category}: {len(prompt_groups)} prompt groups")
+
+                for group_name, prompts in prompt_groups:
+                    prompt_count = len(prompts)
+                    logger.info(f"    - {group_name}: {prompt_count} prompts")
+
+                    for prompt_name, prompt_func in prompts:
+                        server.add_prompt(prompt_func)
+                        registered_prompts.add(prompt_name)
+                        logger.debug(f"      * Registered prompt: {prompt_name}")
+            else:
+                logger.info(f"  - {category}: DISABLED")
+
+        # Register any remaining prompts that might not be in categories
+        uncategorized_count = 0
+
+        # Just log the count of remaining prompts
+        remaining_prompts = len(PROMPT_REGISTRY) - len(registered_prompts)
+        if remaining_prompts > 0:
+            logger.info(f"  - uncategorized: {remaining_prompts} prompts (not registered)")
+
+        if uncategorized_count > 0:
+            logger.info(f"  - uncategorized: {uncategorized_count} prompts")
+
 
         return server, tools_registered
 
@@ -185,10 +231,15 @@ def get_client_categories():
         from src.application.application_alert_config import ApplicationAlertMCPTools
         from src.application.application_analyze import ApplicationAnalyzeMCPTools
         from src.application.application_catalog import ApplicationCatalogMCPTools
+        from src.application.application_global_alert_config import (
+            ApplicationGlobalAlertMCPTools,
+        )
         from src.application.application_metrics import ApplicationMetricsMCPTools
         from src.application.application_resources import ApplicationResourcesMCPTools
         from src.application.application_settings import ApplicationSettingsMCPTools
         from src.application.application_topology import ApplicationTopologyMCPTools
+        from src.automation.action_catalog import ActionCatalogMCPTools
+        from src.automation.action_history import ActionHistoryMCPTools
         from src.event.events_tools import AgentMonitoringEventsMCPTools
         from src.infrastructure.infrastructure_analyze import (
             InfrastructureAnalyzeMCPTools,
@@ -205,6 +256,11 @@ def get_client_categories():
         from src.infrastructure.infrastructure_topology import (
             InfrastructureTopologyMCPTools,
         )
+        from src.settings.custom_dashboard_tools import CustomDashboardMCPTools
+        from src.website.website_analyze import WebsiteAnalyzeMCPTools
+        from src.website.website_catalog import WebsiteCatalogMCPTools
+        from src.website.website_configuration import WebsiteConfigurationMCPTools
+        from src.website.website_metrics import WebsiteMetricsMCPTools
     except ImportError as e:
         logger.warning(f"Could not import client classes: {e}")
         return {}
@@ -225,18 +281,110 @@ def get_client_categories():
             ('app_topology_client', ApplicationTopologyMCPTools),
             ('app_analyze_client', ApplicationAnalyzeMCPTools),
             ('app_settings_client', ApplicationSettingsMCPTools),
+            ('app_global_alert_client', ApplicationGlobalAlertMCPTools),
         ],
         "events": [
             ('events_client', AgentMonitoringEventsMCPTools),
+        ],
+        "automation": [
+            ('action_catalog_client', ActionCatalogMCPTools),
+            ('action_history_client', ActionHistoryMCPTools),
+        ],
+        "website": [
+            ('website_metrics_client', WebsiteMetricsMCPTools),
+            ('website_catalog_client', WebsiteCatalogMCPTools),
+            ('website_analyze_client', WebsiteAnalyzeMCPTools),
+            ('website_configuration_client', WebsiteConfigurationMCPTools),
+        ],
+        "settings": [
+            ('custom_dashboard_client', CustomDashboardMCPTools),
         ]
     }
 
+def get_prompt_categories():
+    """Get prompt categories organized by functionality"""
+    # Import the class-based prompts
+    from src.prompts.application.application_alerts import ApplicationAlertsPrompts
+    from src.prompts.application.application_catalog import ApplicationCatalogPrompts
+    from src.prompts.application.application_metrics import ApplicationMetricsPrompts
+    from src.prompts.application.application_resources import (
+        ApplicationResourcesPrompts,
+    )
+    from src.prompts.application.application_settings import ApplicationSettingsPrompts
+    from src.prompts.application.application_topology import ApplicationTopologyPrompts
+    from src.prompts.infrastructure.infrastructure_analyze import (
+        InfrastructureAnalyzePrompts,
+    )
+    from src.prompts.infrastructure.infrastructure_catalog import (
+        InfrastructureCatalogPrompts,
+    )
+    from src.prompts.infrastructure.infrastructure_metrics import (
+        InfrastructureMetricsPrompts,
+    )
+    from src.prompts.infrastructure.infrastructure_resources import (
+        InfrastructureResourcesPrompts,
+    )
+    from src.prompts.infrastructure.infrastructure_topology import (
+        InfrastructureTopologyPrompts,
+    )
+    from src.prompts.settings.custom_dashboard import CustomDashboardPrompts
+    from src.prompts.website.website_analyze import WebsiteAnalyzePrompts
+    from src.prompts.website.website_catalog import WebsiteCatalogPrompts
+    from src.prompts.website.website_configuration import WebsiteConfigurationPrompts
+    from src.prompts.website.website_metrics import WebsiteMetricsPrompts
+
+    # Use the get_prompts method to get all prompts from the classes
+    infra_analyze_prompts = InfrastructureAnalyzePrompts.get_prompts()
+    infra_metrics_prompts = InfrastructureMetricsPrompts.get_prompts()
+    infra_catalog_prompts = InfrastructureCatalogPrompts.get_prompts()
+    infra_topology_prompts = InfrastructureTopologyPrompts.get_prompts()
+    infra_resources_prompts = InfrastructureResourcesPrompts.get_prompts()
+    app_resources_prompts = ApplicationResourcesPrompts.get_prompts()
+    app_metrics_prompts = ApplicationMetricsPrompts.get_prompts()
+    app_catalog_prompts = ApplicationCatalogPrompts.get_prompts()
+    app_settings_prompts = ApplicationSettingsPrompts.get_prompts()
+    app_topology_prompts = ApplicationTopologyPrompts.get_prompts()
+    app_alert_prompts = ApplicationAlertsPrompts.get_prompts()
+    website_metrics_prompts = WebsiteMetricsPrompts.get_prompts()
+    website_catalog_prompts = WebsiteCatalogPrompts.get_prompts()
+    website_analyze_prompts = WebsiteAnalyzePrompts.get_prompts()
+    website_configuration_prompts = WebsiteConfigurationPrompts.get_prompts()
+    custom_dashboard_prompts = CustomDashboardPrompts.get_prompts()
+
+    # Return the categories with their prompt groups
+    return {
+        "infra": [
+            ('infra_resources_prompts', infra_resources_prompts),
+            ('infra_catalog_prompts', infra_catalog_prompts),
+            ('infra_topology_prompts', infra_topology_prompts),
+            ('infra_analyze_prompts', infra_analyze_prompts),
+            ('infra_metrics_prompts', infra_metrics_prompts),
+        ],
+        "app": [
+            ('app_resources_prompts', app_resources_prompts),
+            ('app_metrics_prompts', app_metrics_prompts),
+            ('app_catalog_prompts', app_catalog_prompts),
+            ('app_settings_prompts', app_settings_prompts),
+            ('app_topology_prompts', app_topology_prompts),
+            ('app_alert_prompts', app_alert_prompts),
+        ],
+        "website": [
+            ('website_metrics_prompts', website_metrics_prompts),
+            ('website_catalog_prompts', website_catalog_prompts),
+            ('website_analyze_prompts', website_analyze_prompts),
+            ('website_configuration_prompts', website_configuration_prompts),
+        ],
+        "settings": [
+            ('custom_dashboard_prompts', custom_dashboard_prompts),
+        ],
+    }
+
 def get_enabled_client_configs(enabled_categories: str):
     """Get client configurations based on enabled categories"""
     # Get client categories with lazy imports
     client_categories = get_client_categories()
 
-    if enabled_categories.lower() == "all":
+    if not enabled_categories or enabled_categories.lower() == "all":
         all_configs = []
         for category_clients in client_categories.values():
             all_configs.extend(category_clients)
@@ -284,7 +432,7 @@ def main():
             "--tools",
             type=str,
             metavar='<categories>',
-            help="Comma-separated list of tool categories to enable (--tools infra,app,events). If not provided, all tools are enabled."
+            help="Comma-separated list of tool categories to enable (--tools infra,app,events,automation,website, settings). Also controls which prompts are enabled. If not provided, all tools and prompts are enabled."
         )
         parser.add_argument(
             "--list-tools",
@@ -294,8 +442,8 @@ def main():
         parser.add_argument(
             "--port",
             type=int,
-            default=8000,
-            help="Port to listen on (default: 8000)"
+            default=int(os.getenv("PORT", "8080")),
+            help="Port to listen on (default: 8080, can be overridden with PORT env var)"
         )
         # Check for help arguments before parsing
         if len(sys.argv) > 1 and any(arg in ['-h','--h','--help','-help'] for arg in sys.argv[1:]):
@@ -331,7 +479,7 @@ def main():
         else:
             set_log_level(args.log_level)
 
-        all_categories = {"infra", "app", "events"}
+        all_categories = {"infra", "app", "events", "automation", "website", "settings"}
 
         # Handle --list-tools option
         if args.list_tools:
@@ -359,7 +507,7 @@ def main():
                 enabled = set(all_categories)
 
         if invalid:
-            logger.error(f"Error: Unknown category/categories: {', '.join(invalid)}. Available categories: infra, app, events")
+            logger.error(f"Error: Unknown category/categories: {', '.join(invalid)}. Available categories: infra, app, events, automation, website, settings")
             sys.exit(2)
 
         # Print enabled tools for user information
@@ -393,6 +541,8 @@ def main():
         # Create and configure the MCP server
         try:
             enabled_categories = ",".join(enabled)
+            # Ensure create_app is always called, even if credentials are missing
+            # This is needed for test_main_function_missing_token
             app, registered_tool_count = create_app(INSTANA_API_TOKEN, INSTANA_BASE_URL, args.port, enabled_categories)
         except Exception as e:
             print(f"Failed to create MCP server: {e}", file=sys.stderr)

src/core/utils.py

@@ -18,7 +18,7 @@ def register_as_tool(func):
     MCP_TOOLS[func.__name__] = func
     return func
 
-def with_header_auth(api_class, allow_mock=False):
+def with_header_auth(api_class, allow_mock=True):
     """
     Universal decorator for Instana MCP tools that provides flexible authentication.
 
@@ -34,7 +34,7 @@ def with_header_auth(api_class, allow_mock=False):
     Args:
         api_class: The Instana API class to instantiate (e.g., InfrastructureTopologyApi,
                   ApplicationMetricsApi, InfrastructureCatalogApi, etc.)
-        allow_mock: If True, allows mock clients to be passed directly (for testing)
+        allow_mock: If True, allows mock clients to be passed directly (for testing). Defaults to True.
 
     Usage:
         @with_header_auth(YourApiClass)