@dynatrace-oss/dynatrace-mcp-server 0.6.0-rc.1 → 0.6.0

package/README.md

@@ -18,14 +18,30 @@
   </a>
 </h4>
 
-This local MCP server allows interaction with the [Dynatrace](https://www.dynatrace.com/) observability platform.
-Bring real-time observability data directly into your development workflow.
+The local _Dynatrace MCP server_ allows AI Assistants to interact with the [Dynatrace](https://www.dynatrace.com/) observability platform,
+bringing real-time observability data directly into your development workflow.
 
 > Note: This product is not officially supported by Dynatrace.
 
-Please contact us via [GitHub Issues](https://github.com/dynatrace-oss/dynatrace-mcp/issues) if you have feature requests, questions, or need help.
+If you need help, please contact us via [GitHub Issues](https://github.com/dynatrace-oss/dynatrace-mcp/issues) if you have feature requests, questions, or need help.
 
-<img width="1046" alt="image" src="/assets/dynatrace-mcp-arch.png" />
+## Quickstart
+
+You can add this MCP server to your MCP Client like VSCode, Claude, Cursor, Amazon Q, Windsurf, ChatGPT, or Github Copilot via the npmjs package `@dynatrace-oss/dynatrace-mcp-server`, and type `stdio`.
+You can find more details about the configuration for different AI Assistants, Agents and MCP Clients in the [Configuration section below](#configuration).
+
+Furthermore, you need your Dynatrace environment URL, e.g., `https://abc12345.apps.dynatrace.com`, as well as a [Platform Token](https://docs.dynatrace.com/docs/manage/identity-access-management/access-tokens-and-oauth-clients/platform-tokens), e.g., `dt0s16.SAMPLE.abcd1234`, with [required scopes](#scopes-for-authentication).
+
+Depending on your MCP Client, you need to configure these as environment variables or as settings in the UI:
+
+- `DT_ENVIRONMENT` (string, e.g., `https://abc12345.apps.dynatrace.com`) - URL to your Dynatrace Platform (do not use Dynatrace classic URLs like `abc12345.live.dynatrace.com`)
+- `DT_PLATFORM_TOKEN` (string, e.g., `dt0s16.SAMPLE.abcd1234`) - **Recommended**: Dynatrace Platform Token
+
+Once you are done, we recommend looking into [example prompts](#-example-prompts-), like `Get all details of the entity 'my-service'` or `Show me error logs`. Please mind that these prompts lead to executing DQL statements which may incur [costs](#costs) in accordance to your licence.
+
+## Architecture
+
+![Architecture](https://github.com/dynatrace-oss/dynatrace-mcp/blob/main/assets/dynatrace-mcp-arch.png?raw=true)
 
 ## Use cases
 
@@ -60,6 +76,17 @@ depend on the volume (GB scanned).
 1. Review your current Dynatrace consumption model and pricing
 2. Understand the cost implications of the specific data you plan to query (logs, events, metrics) - see [Dynatrace Pricing and Rate Card](https://www.dynatrace.com/pricing/)
 3. Start with smaller timeframes (e.g., 12h-24h) and make use of [buckets](https://docs.dynatrace.com/docs/discover-dynatrace/platform/grail/data-model#built-in-grail-buckets) to reduce the cost impact
+4. Set an appropriate `DT_GRAIL_QUERY_BUDGET_GB` environment variable (default: 1000 GB) to control and monitor your Grail query consumption
+
+**Grail Budget Tracking:**
+
+The MCP server includes built-in budget tracking for Grail queries to help you monitor and control costs:
+
+- Set `DT_GRAIL_QUERY_BUDGET_GB` (default: 1000 GB) to define your session budget limit
+- The server tracks bytes scanned across all Grail queries in the current session
+- You'll receive warnings when approaching 80% of your budget
+- Budget exceeded alerts help prevent unexpected high consumption
+- Budget resets when you restart the MCP server session
 
 **To understand costs that occured:**
 
@@ -173,7 +200,7 @@ rules/
 
 For detailed information about the workshop rules, see the [Rules README](./dynatrace-agent-rules/rules/README.md).
 
-## Quickstart
+## Configuration
 
 You can add this MCP server (using STDIO) to your MCP Client like VS Code, Claude, Cursor, Amazon Q Developer CLI, Windsurf Github Copilot via the package `@dynatrace-oss/dynatrace-mcp-server`.
 
@@ -288,19 +315,6 @@ npx -y @dynatrace-oss/dynatrace-mcp-server@latest --version
 }
 ```
 
-**Configuration for MCP clients that support HTTP transport:**
-
-```json
-{
-  "mcpServers": {
-    "dynatrace-http": {
-      "url": "http://localhost:3000",
-      "transport": "http"
-    }
-  }
-}
-```
-
 ### Rule File
 
 For efficient result retrieval from Dynatrace, please consider creating a rule file (e.g., [.github/copilot-instructions.md](https://docs.github.com/en/copilot/how-tos/configure-custom-instructions/add-repository-instructions), [.amazonq/rules/](https://docs.aws.amazon.com/amazonq/latest/qdeveloper-ug/context-project-rules.html)), instructing coding agents on how to get more details for your component/app/service. Here is an example for [easytrade](https://github.com/Dynatrace/easytrade), please adapt the names and filters to fit your use-cases and components:
@@ -330,10 +344,11 @@ For fetching just error-logs, add `| filter loglevel == "ERROR"`.
 
 You can set up authentication via **Platform Tokens** (recommended) or **OAuth Client** via the following environment variables:
 
-- `DT_ENVIRONMENT` (string, e.g., https://abc12345.apps.dynatrace.com) - URL to your Dynatrace Platform (do not use Dynatrace classic URLs like `abc12345.live.dynatrace.com`)
+- `DT_ENVIRONMENT` (string, e.g., `https://abc12345.apps.dynatrace.com`) - URL to your Dynatrace Platform (do not use Dynatrace classic URLs like `abc12345.live.dynatrace.com`)
 - `DT_PLATFORM_TOKEN` (string, e.g., `dt0s16.SAMPLE.abcd1234`) - **Recommended**: Dynatrace Platform Token
 - `OAUTH_CLIENT_ID` (string, e.g., `dt0s02.SAMPLE`) - Alternative: Dynatrace OAuth Client ID (for advanced use cases)
 - `OAUTH_CLIENT_SECRET` (string, e.g., `dt0s02.SAMPLE.abcd1234`) - Alternative: Dynatrace OAuth Client Secret (for advanced use cases)
+- `DT_GRAIL_QUERY_BUDGET_GB` (number, default: `1000`) - Budget limit in GB (base 1000) for Grail query bytes scanned per session. The MCP server tracks your Grail usage and warns when approaching or exceeding this limit.
 
 **Platform Tokens are recommended** for most use cases as they provide a simpler authentication flow. OAuth Clients should only be used when specific OAuth features are required.
 
@@ -371,6 +386,7 @@ Depending on the features you are using, the following scopes are needed:
 - `davis-copilot:conversations:execute` - execute conversational skill (chat with Copilot)
 - `davis-copilot:nl2dql:execute` - execute Davis Copilot Natural Language (NL) to DQL skill
 - `davis-copilot:dql2nl:execute` - execute DQL to Natural Language (NL) skill
+- `email:emails:send` - needed for `send_email` tool to send emails
 - `settings:objects:read` - needed for reading ownership information and Guardians (SRG) from settings
 
   **Note**: Please ensure that `settings:objects:read` is used, and _not_ the similarly named scope `app-settings:objects:read`.
@@ -384,6 +400,18 @@ and extend them as needed. They're here to help you imagine how real-time observ
 
 ### **Basic Queries & AI Assistance**
 
+**Find a monitored entity**
+
+```
+Get all details of the entity 'my-service'
+```
+
+**Find error logs**
+
+```
+Show me error logs
+```
+
 **Write a DQL query from natural language:**
 
 ```
@@ -403,6 +431,12 @@ fetch logs | filter dt.source_entity == 'SERVICE-123' | summarize count(), by:{s
 How can I investigate slow database queries in Dynatrace?
 ```
 
+**Send email notifications:**
+
+```
+Send an email notification about the incident to the responsible team at team@example.com with CC to manager@example.com
+```
+
 ### **Advanced Incident Investigation**
 
 **Multi-phase incident response:**
@@ -602,51 +636,3 @@ To disable usage tracking, add this to your environment:
 ```bash
 DT_MCP_DISABLE_TELEMETRY=true
 ```
-
-## Development
-
-For local development purposes, you can use VSCode and GitHub Copilot.
-
-First, enable Copilot for your Workspace `.vscode/settings.json`:
-
-```json
-{
-  "github.copilot.enable": {
-    "*": true
-  }
-}
-```
-
-and make sure that you are using Agent Mode in Copilot.
-
-Second, add the MCP to `.vscode/mcp.json`:
-
-```json
-{
-  "servers": {
-    "my-dynatrace-mcp-server": {
-      "command": "node",
-      "args": ["--watch", "${workspaceFolder}/dist/index.js"],
-      "envFile": "${workspaceFolder}/.env"
-    }
-  }
-}
-```
-
-Third, create a `.env` file in this repository (you can copy from `.env.template`) and configure environment variables as [described above](#environment-variables).
-
-Finally, make changes to your code and compile it with `npm run build` or just run `npm run watch` and it auto-compiles.
-
-## Releasing
-
-When you are preparing for a release, you can use GitHub Copilot to guide you through the preparations.
-
-In Visual Studio Code, you can use `/release` in the chat with Copilot in Agent Mode, which will execute [release.prompt.md](.github/prompts/release.prompt.md).
-
-You may include additional information such as the version number. If not specified, you will be asked.
-
-This will
-
-- prepare the [changelog](CHANGELOG.md),
-- update the version number in [package.json](package.json),
-- commit the changes.

package/dist/capabilities/davis-copilot.js

@@ -1,7 +1,23 @@
 "use strict";
+/**
+ * Davis CoPilot API Integration
+ *
+ * This module provides access to Davis CoPilot AI capabilities including:
+ * - Natural Language to DQL conversion
+ * - DQL explanation in plain English
+ * - AI-powered conversation assistance
+ * - Feedback submission for continuous improvement
+ *
+ * Note: While Davis CoPilot AI is generally available (GA),
+ * the Davis CoPilot APIs are currently in preview.
+ * For more information: https://dt-url.net/copilot-community
+ *
+ * DQL (Dynatrace Query Language) is the most powerful way to query any data
+ * in Dynatrace, including problem events, security issues, logs, metrics, and spans.
+ */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.chatWithDavisCopilot = exports.explainDqlInNaturalLanguage = exports.generateDqlFromNaturalLanguage = void 0;
-// API Functions
+const client_davis_copilot_1 = require("@dynatrace-sdk/client-davis-copilot");
 /**
  * Generate DQL from natural language
  * Converts plain English descriptions into powerful Dynatrace Query Language (DQL) statements.
@@ -9,17 +25,10 @@ exports.chatWithDavisCopilot = exports.explainDqlInNaturalLanguage = exports.gen
  * security issues, logs, metrics, spans, and custom data.
  */
 const generateDqlFromNaturalLanguage = async (dtClient, text) => {
-    const request = { text };
-    const response = await dtClient.send({
-        method: 'POST',
-        url: '/platform/davis/copilot/v0.2/skills/nl2dql:generate',
-        headers: {
-            'Content-Type': 'application/json',
-            'Accept': 'application/json',
-        },
-        body: JSON.stringify(request),
+    const client = new client_davis_copilot_1.PublicClient(dtClient);
+    return await client.nl2dql({
+        body: { text },
     });
-    return await response.body('json');
 };
 exports.generateDqlFromNaturalLanguage = generateDqlFromNaturalLanguage;
 /**
@@ -29,35 +38,27 @@ exports.generateDqlFromNaturalLanguage = generateDqlFromNaturalLanguage;
  * queries for problem events, security issues, and performance metrics.
  */
 const explainDqlInNaturalLanguage = async (dtClient, dql) => {
-    const request = { dql };
-    const response = await dtClient.send({
-        method: 'POST',
-        url: '/platform/davis/copilot/v0.2/skills/dql2nl:explain',
-        headers: {
-            'Content-Type': 'application/json',
-            'Accept': 'application/json',
-        },
-        body: request, // Not sure why this does not need JSON.stringify, but it only works like this; once we have the SDK, this will be consistent
+    const client = new client_davis_copilot_1.PublicClient(dtClient);
+    return await client.dql2nl({
+        body: { dql },
     });
-    return await response.body('json');
 };
 exports.explainDqlInNaturalLanguage = explainDqlInNaturalLanguage;
 const chatWithDavisCopilot = async (dtClient, text, context, annotations, state) => {
-    const request = {
-        text,
-        context,
-        annotations,
-        state,
-    };
-    const response = await dtClient.send({
-        method: 'POST',
-        url: '/platform/davis/copilot/v0.2/skills/conversations:message',
-        headers: {
-            'Content-Type': 'application/json',
-            'Accept': 'application/json',
+    const client = new client_davis_copilot_1.PublicClient(dtClient);
+    const response = await client.recommenderConversation({
+        body: {
+            text,
+            context,
+            annotations,
+            state,
         },
-        body: JSON.stringify(request),
     });
-    return await response.body('json');
+    // Type guard: RecommenderResponse is ConversationResponse | EventArray
+    // In practice, the SDK defaults to non-streaming and returns ConversationResponse
+    if (Array.isArray(response)) {
+        throw new Error('Unexpected streaming response format. Please raise an issue at https://github.com/dynatrace-oss/dynatrace-mcp/issues.');
+    }
+    return response;
 };
 exports.chatWithDavisCopilot = chatWithDavisCopilot;

package/dist/capabilities/execute-dql.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.executeDql = exports.verifyDqlStatement = void 0;
 const client_query_1 = require("@dynatrace-sdk/client-query");
 const user_agent_1 = require("../utils/user-agent");
+const grail_budget_tracker_1 = require("../utils/grail-budget-tracker");
 const verifyDqlStatement = async (dtClient, dqlStatement) => {
     const queryAssistanceClient = new client_query_1.QueryAssistanceClient(dtClient);
     const response = await queryAssistanceClient.queryVerify({
@@ -17,17 +18,29 @@ exports.verifyDqlStatement = verifyDqlStatement;
  * Helper function to create a DQL execution result and log metadata information.
  * @param queryResult - The query result from Dynatrace API
  * @param logPrefix - Prefix for the log message (e.g., "DQL Execution Metadata" or "DQL Execution Metadata (Polled)")
+ * @param budgetLimitGB - Budget limit in GB for tracking purposes
  * @returns DqlExecutionResult with extracted metadata
  */
-const createResultAndLog = (queryResult, logPrefix) => {
+const createResultAndLog = (queryResult, logPrefix, budgetLimitGB) => {
+    const scannedBytes = queryResult.metadata?.grail?.scannedBytes || 0;
+    // Track budget if limit is provided
+    let budgetState;
+    let budgetWarning;
+    if (budgetLimitGB !== undefined) {
+        const tracker = (0, grail_budget_tracker_1.getGrailBudgetTracker)(budgetLimitGB);
+        budgetState = tracker.addBytesScanned(scannedBytes);
+        budgetWarning = (0, grail_budget_tracker_1.generateBudgetWarning)(budgetState, scannedBytes) || undefined;
+    }
     const result = {
         records: queryResult.records,
         metadata: queryResult.metadata,
-        scannedBytes: queryResult.metadata?.grail?.scannedBytes,
+        scannedBytes,
         scannedRecords: queryResult.metadata?.grail?.scannedRecords,
         executionTimeMilliseconds: queryResult.metadata?.grail?.executionTimeMilliseconds,
         queryId: queryResult.metadata?.grail?.queryId,
         sampled: queryResult.metadata?.grail?.sampled,
+        budgetState,
+        budgetWarning,
     };
     console.error(`${logPrefix} scannedBytes=${result.scannedBytes} scannedRecords=${result.scannedRecords} executionTime=${result.executionTimeMilliseconds} queryId=${result.queryId}`);
     return result;
@@ -38,9 +51,20 @@ const createResultAndLog = (queryResult, logPrefix) => {
  * If the result is not immediately available, it will poll for the result until it is available.
  * @param dtClient
  * @param body - Contains the DQL statement to execute, and optional parameters like maxResultRecords and maxResultBytes
+ * @param budgetLimitGB - Optional budget limit in GB for tracking bytes scanned
  * @returns the result with records, metadata and cost information, or undefined if the query failed or no result was returned.
  */
-const executeDql = async (dtClient, body) => {
+const executeDql = async (dtClient, body, budgetLimitGB) => {
+    // Check budget before executing the query if budget limit is provided
+    if (budgetLimitGB !== undefined) {
+        const tracker = (0, grail_budget_tracker_1.getGrailBudgetTracker)(budgetLimitGB);
+        const currentState = tracker.getState();
+        if (currentState.isBudgetExceeded) {
+            console.error('DQL execution aborted: Grail budget has been exceeded');
+            const budgetWarning = (0, grail_budget_tracker_1.generateBudgetWarning)(currentState, 0);
+            throw new Error(budgetWarning || 'DQL execution aborted: Grail budget has been exceeded');
+        }
+    }
     // create a Dynatrace QueryExecutionClient
     const queryExecutionClient = new client_query_1.QueryExecutionClient(dtClient);
     // and execute the query (part of body)
@@ -52,7 +76,7 @@ const executeDql = async (dtClient, body) => {
     // check if we already got a result back
     if (response.result) {
         // yes - return response result immediately
-        return createResultAndLog(response.result, 'execute_dql - Metadata:');
+        return createResultAndLog(response.result, 'execute_dql - Metadata:', budgetLimitGB);
     }
     // no result yet? we have wait and poll (this requires requestToken to be set)
     if (response.requestToken) {
@@ -68,7 +92,7 @@ const executeDql = async (dtClient, body) => {
             // check if we got a result from the polling endpoint
             if (pollResponse.result) {
                 // yes - let's return the polled result
-                return createResultAndLog(pollResponse.result, 'execute_dql Metadata (polled):');
+                return createResultAndLog(pollResponse.result, 'execute_dql Metadata (polled):', budgetLimitGB);
             }
         } while (pollResponse.state === 'RUNNING' || pollResponse.state === 'NOT_STARTED');
         // state != RUNNING and != NOT_STARTED - we should log that

package/dist/capabilities/execute-dql.test.js

@@ -0,0 +1,113 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const execute_dql_1 = require("./execute-dql");
+const client_query_1 = require("@dynatrace-sdk/client-query");
+const grail_budget_tracker_1 = require("../utils/grail-budget-tracker");
+// Mock the external dependencies
+jest.mock('@dynatrace-sdk/client-query');
+jest.mock('../utils/user-agent', () => ({
+    getUserAgent: () => 'test-user-agent',
+}));
+describe('executeDql Budget Check', () => {
+    let mockHttpClient;
+    let mockQueryExecutionClient;
+    beforeEach(() => {
+        // Reset budget tracker before each test
+        (0, grail_budget_tracker_1.resetGrailBudgetTracker)();
+        // Create mock HTTP client
+        mockHttpClient = {
+        // Add any necessary properties/methods for HttpClient mock
+        };
+        // Create mock QueryExecutionClient
+        mockQueryExecutionClient = {
+            queryExecute: jest.fn(),
+            queryPoll: jest.fn(),
+            queryCancel: jest.fn(),
+        };
+        // Mock the QueryExecutionClient constructor
+        client_query_1.QueryExecutionClient.mockImplementation(() => mockQueryExecutionClient);
+    });
+    afterEach(() => {
+        jest.clearAllMocks();
+        (0, grail_budget_tracker_1.resetGrailBudgetTracker)();
+    });
+    it('should prevent execution when budget is exceeded', async () => {
+        const budgetLimitGB = 0.001; // Very small budget limit (1 MB)
+        // First, exhaust the budget by adding bytes to tracker
+        const tracker = (0, grail_budget_tracker_1.getGrailBudgetTracker)(budgetLimitGB);
+        tracker.addBytesScanned(2 * 1000 * 1000); // Add 2 MB, exceeding the 1 MB limit
+        const dqlStatement = 'fetch logs | limit 10';
+        const body = { query: dqlStatement };
+        // Execute DQL with budget limit and expect it to throw
+        await expect((0, execute_dql_1.executeDql)(mockHttpClient, body, budgetLimitGB)).rejects.toThrow(/budget/);
+        // Verify that queryExecute was NOT called
+        expect(mockQueryExecutionClient.queryExecute).not.toHaveBeenCalled();
+    });
+    it('should allow execution when budget is not exceeded', async () => {
+        const budgetLimitGB = 1; // 1 GB budget limit
+        const dqlStatement = 'fetch logs | limit 10';
+        const body = { query: dqlStatement };
+        // Mock successful response
+        const mockResponse = {
+            state: 'RUNNING',
+            result: {
+                records: [{ field1: 'value1' }],
+                types: [],
+                metadata: {
+                    grail: {
+                        scannedBytes: 1000,
+                        scannedRecords: 1,
+                        executionTimeMilliseconds: 100,
+                        queryId: 'test-query-id',
+                    },
+                },
+            },
+        };
+        mockQueryExecutionClient.queryExecute.mockResolvedValue(mockResponse);
+        // Execute DQL with budget limit
+        const result = await (0, execute_dql_1.executeDql)(mockHttpClient, body, budgetLimitGB);
+        // Verify that queryExecute WAS called
+        expect(mockQueryExecutionClient.queryExecute).toHaveBeenCalledWith({
+            body,
+            dtClientContext: 'test-user-agent',
+        });
+        // Verify the result is returned correctly
+        expect(result).toBeDefined();
+        expect(result?.records).toEqual([{ field1: 'value1' }]);
+        expect(result?.scannedBytes).toBe(1000);
+        expect(result?.budgetState?.isBudgetExceeded).toBe(false);
+    });
+    it('should allow execution when no budget limit is provided', async () => {
+        const dqlStatement = 'fetch logs | limit 10';
+        const body = { query: dqlStatement };
+        // Mock successful response
+        const mockResponse = {
+            state: 'RUNNING',
+            result: {
+                records: [{ field1: 'value1' }],
+                types: [],
+                metadata: {
+                    grail: {
+                        scannedBytes: 1000000000, // 1 GB - would exceed small budgets
+                        scannedRecords: 1000,
+                        executionTimeMilliseconds: 100,
+                        queryId: 'test-query-id',
+                    },
+                },
+            },
+        };
+        mockQueryExecutionClient.queryExecute.mockResolvedValue(mockResponse);
+        // Execute DQL without budget limit
+        const result = await (0, execute_dql_1.executeDql)(mockHttpClient, body);
+        // Verify that queryExecute WAS called
+        expect(mockQueryExecutionClient.queryExecute).toHaveBeenCalledWith({
+            body,
+            dtClientContext: 'test-user-agent',
+        });
+        // Verify the result is returned correctly
+        expect(result).toBeDefined();
+        expect(result?.records).toEqual([{ field1: 'value1' }]);
+        expect(result?.scannedBytes).toBe(1000000000);
+        expect(result?.budgetState).toBeUndefined(); // No budget tracking
+    });
+});

package/dist/capabilities/send-email.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sendEmail = void 0;
+/**
+ * Send an email using the Dynatrace Email API
+ * @param dtClient - Dynatrace HTTP client
+ * @param emailRequest - Email request parameters
+ * @returns Structured email response with request ID and status
+ */
+const sendEmail = async (dtClient, emailRequest) => {
+    // Validate total recipients limit (10 max across TO, CC, and BCC)
+    const totalRecipients = emailRequest.toRecipients.emailAddresses.length +
+        (emailRequest.ccRecipients?.emailAddresses.length || 0) +
+        (emailRequest.bccRecipients?.emailAddresses.length || 0);
+    if (totalRecipients > 10) {
+        throw new Error(`Total recipients (${totalRecipients}) exceeds maximum limit of 10 across TO, CC, and BCC fields`);
+    }
+    try {
+        // Ensure contentType is set to 'text/plain' (our only supported format)
+        const requestBody = {
+            ...emailRequest,
+            body: {
+                ...emailRequest.body,
+                contentType: 'text/plain',
+            },
+        };
+        const response = await dtClient.send({
+            url: '/platform/email/v1/emails',
+            method: 'POST',
+            headers: {
+                'Accept': 'application/json',
+                'Content-Type': 'application/json;charset=UTF-8',
+            },
+            body: requestBody,
+            statusValidator: (status) => {
+                return status === 202; // Email API returns 202 for successful requests
+            },
+        });
+        const result = await response.body('json');
+        const sendResult = {
+            success: true,
+            requestId: result.requestId,
+            message: result.message,
+        };
+        if (result.invalidDestinations && result.invalidDestinations.length > 0) {
+            sendResult.invalidDestinations = result.invalidDestinations;
+        }
+        if (result.rejectedDestinations) {
+            if (result.rejectedDestinations.bouncingDestinations.length > 0) {
+                sendResult.bouncingDestinations = result.rejectedDestinations.bouncingDestinations;
+            }
+            if (result.rejectedDestinations.complainingDestinations.length > 0) {
+                sendResult.complainingDestinations = result.rejectedDestinations.complainingDestinations;
+            }
+        }
+        return sendResult;
+    }
+    catch (error) {
+        throw new Error(`Error sending email: ${error.message}`);
+    }
+};
+exports.sendEmail = sendEmail;

package/dist/getDynatraceEnv.js

@@ -11,17 +11,22 @@ function getDynatraceEnv(env = process.env) {
     const dtPlatformToken = env.DT_PLATFORM_TOKEN;
     const dtEnvironment = env.DT_ENVIRONMENT;
     const slackConnectionId = env.SLACK_CONNECTION_ID || 'fake-slack-connection-id';
+    const grailBudgetGB = parseFloat(env.DT_GRAIL_QUERY_BUDGET_GB || '1000'); // Default to 1000 GB
     if (!dtEnvironment) {
         throw new Error('Please set DT_ENVIRONMENT environment variable to your Dynatrace Platform Environment');
     }
     if (!oauthClientId && !oauthClientSecret && !dtPlatformToken) {
         throw new Error('Please set either OAUTH_CLIENT_ID and OAUTH_CLIENT_SECRET, or DT_PLATFORM_TOKEN environment variables');
     }
+    // ToDo: Allow the case of -1 for unlimited Budget
+    if (isNaN(grailBudgetGB) || (grailBudgetGB <= 0 && grailBudgetGB !== -1)) {
+        throw new Error('DT_GRAIL_QUERY_BUDGET_GB must be a positive number representing GB budget for Grail queries');
+    }
     if (!dtEnvironment.startsWith('https://')) {
         throw new Error('Please set DT_ENVIRONMENT to a valid Dynatrace Environment URL (e.g., https://<environment-id>.apps.dynatrace.com)');
     }
     if (!dtEnvironment.includes('apps.dynatrace.com') && !dtEnvironment.includes('apps.dynatracelabs.com')) {
         throw new Error('Please set DT_ENVIRONMENT to a valid Dynatrace Platform Environment URL (e.g., https://<environment-id>.apps.dynatrace.com)');
     }
-    return { oauthClientId, oauthClientSecret, dtPlatformToken, dtEnvironment, slackConnectionId };
+    return { oauthClientId, oauthClientSecret, dtPlatformToken, dtEnvironment, slackConnectionId, grailBudgetGB };
 }

package/dist/getDynatraceEnv.test.js

@@ -18,6 +18,7 @@ describe('getDynatraceEnv', () => {
             dtEnvironment: env.DT_ENVIRONMENT,
             dtPlatformToken: env.DT_PLATFORM_TOKEN,
             slackConnectionId: env.SLACK_CONNECTION_ID,
+            grailBudgetGB: 1000, // Default value
         });
     });
     it('uses default slackConnectionId if not set', () => {

package/dist/index.js

@@ -8,7 +8,6 @@ const streamableHttp_js_1 = require("@modelcontextprotocol/sdk/server/streamable
 const mcp_js_1 = require("@modelcontextprotocol/sdk/server/mcp.js");
 const dotenv_1 = require("dotenv");
 const node_http_1 = require("node:http");
-const node_crypto_1 = require("node:crypto");
 const commander_1 = require("commander");
 const zod_1 = require("zod");
 const version_1 = require("./utils/version");
@@ -22,10 +21,12 @@ const create_workflow_for_problem_notification_1 = require("./capabilities/creat
 const update_workflow_1 = require("./capabilities/update-workflow");
 const execute_dql_1 = require("./capabilities/execute-dql");
 const send_slack_message_1 = require("./capabilities/send-slack-message");
+const send_email_1 = require("./capabilities/send-email");
 const find_monitored_entity_by_name_1 = require("./capabilities/find-monitored-entity-by-name");
 const davis_copilot_1 = require("./capabilities/davis-copilot");
 const getDynatraceEnv_1 = require("./getDynatraceEnv");
 const telemetry_openkit_1 = require("./utils/telemetry-openkit");
+const grail_budget_tracker_1 = require("./utils/grail-budget-tracker");
 (0, dotenv_1.config)();
 let scopesBase = [
     'app-engine:apps:run', // needed for environmentInformationClient
@@ -49,21 +50,13 @@ function handleClientRequestError(error) {
     }
     return `Client Request Error: ${error.message} with HTTP status: ${error.response.status}. ${additionalErrorInformation} (body: ${JSON.stringify(error.body)})`;
 }
-const main = async () => {
-    // read Environment variables
-    let dynatraceEnv;
-    try {
-        dynatraceEnv = (0, getDynatraceEnv_1.getDynatraceEnv)();
-    }
-    catch (err) {
-        console.error(err.message);
-        process.exit(1);
-    }
-    console.error(`Initializing Dynatrace MCP Server v${(0, version_1.getPackageJsonVersion)()}...`);
-    const { oauthClientId, oauthClientSecret, dtEnvironment, dtPlatformToken, slackConnectionId } = dynatraceEnv;
-    // Test connection on startup
+/**
+ * Try to connect to Dynatrace environment with retries and exponential backoff.
+ */
+async function retryTestDynatraceConnection(dtEnvironment, oauthClientId, oauthClientSecret, dtPlatformToken) {
     let retryCount = 0;
-    const maxRetries = 5;
+    const maxRetries = 3; // Max retries
+    const delayMs = 2000; // Initial delay of 2 seconds
     while (true) {
         try {
             console.error(`Testing connection to Dynatrace environment: ${dtEnvironment}... (Attempt ${retryCount + 1} of ${maxRetries})`);
@@ -82,13 +75,36 @@ const main = async () => {
             retryCount++;
             if (retryCount >= maxRetries) {
                 console.error(`Fatal: Maximum number of connection retries (${maxRetries}) exceeded. Exiting.`);
-                process.exit(1);
+                throw new Error(`Failed to connect to Dynatrace environment ${dtEnvironment} after ${maxRetries} attempts. Most likely your configuration is incorrect. Last error: ${error.message}`, { cause: error });
             }
-            const delay = Math.pow(2, retryCount) * 1000; // Exponential backoff
+            const delay = Math.pow(2, retryCount) * delayMs; // Exponential backoff
             console.error(`Retrying in ${delay / 1000} seconds...`);
             await new Promise((resolve) => setTimeout(resolve, delay));
         }
     }
+}
+const main = async () => {
+    console.error(`Initializing Dynatrace MCP Server v${(0, version_1.getPackageJsonVersion)()}...`);
+    // read Environment variables
+    let dynatraceEnv;
+    try {
+        dynatraceEnv = (0, getDynatraceEnv_1.getDynatraceEnv)();
+    }
+    catch (err) {
+        console.error(err.message);
+        process.exit(1);
+    }
+    // Unpack environment variables
+    const { oauthClientId, oauthClientSecret, dtEnvironment, dtPlatformToken, slackConnectionId, grailBudgetGB } = dynatraceEnv;
+    // Test connection on startup
+    try {
+        await retryTestDynatraceConnection(dtEnvironment, oauthClientId, oauthClientSecret, dtPlatformToken);
+    }
+    catch (err) {
+        console.error(err.message);
+        process.exit(2);
+    }
+    // Ready to start the server
     console.error(`Starting Dynatrace MCP Server v${(0, version_1.getPackageJsonVersion)()}...`);
     // Initialize usage tracking
     const telemetry = (0, telemetry_openkit_1.createTelemetry)();
@@ -113,7 +129,7 @@ const main = async () => {
         },
     });
     // quick abstraction/wrapper to make it easier for tools to reply text instead of JSON
-    const tool = (name, description, paramsSchema, cb) => {
+    const tool = (name, description, paramsSchema, annotations, cb) => {
         const wrappedCb = async (args) => {
             // track starttime for telemetry
             const startTime = Date.now();
@@ -152,10 +168,12 @@ const main = async () => {
                     .catch((e) => console.warn('Failed to track tool usage:', e));
             }
         };
-        server.tool(name, description, paramsSchema, (args) => wrappedCb(args));
+        server.tool(name, description, paramsSchema, annotations, (args) => wrappedCb(args));
     };
     /** Tool Definitions below */
-    tool('get_environment_info', 'Get information about the connected Dynatrace Environment (Tenant) and verify the connection and authentication.', {}, async ({}) => {
+    tool('get_environment_info', 'Get information about the connected Dynatrace Environment (Tenant) and verify the connection and authentication.', {}, {
+        readOnlyHint: true,
+    }, async ({}) => {
         // create an oauth-client
         const dtClient = await (0, dynatrace_clients_1.createDtHttpClient)(dtEnvironment, scopesBase, oauthClientId, oauthClientSecret, dtPlatformToken);
         const environmentInformationClient = new client_platform_management_service_1.EnvironmentInformationClient(dtClient);
@@ -179,6 +197,8 @@ const main = async () => {
             .number()
             .default(25)
             .describe('Maximum number of vulnerabilities to display in the response.'),
+    }, {
+        readOnlyHint: true,
     }, async ({ riskScore, additionalFilter, maxVulnerabilitiesToDisplay }) => {
         const dtClient = await (0, dynatrace_clients_1.createDtHttpClient)(dtEnvironment, scopesBase.concat('storage:events:read', 'storage:buckets:read', 'storage:security.events:read'), oauthClientId, oauthClientSecret, dtPlatformToken);
         const result = await (0, list_vulnerabilities_1.listVulnerabilities)(dtClient, additionalFilter, riskScore);
@@ -220,6 +240,8 @@ const main = async () => {
             .optional()
             .describe('Additional filter for DQL statement for dt.davis.problems, e.g., \'entity_tags == array("dt.owner:team-foobar", "tag:tag")\''),
         maxProblemsToDisplay: zod_1.z.number().default(10).describe('Maximum number of problems to display in the response.'),
+    }, {
+        readOnlyHint: true,
     }, async ({ additionalFilter, maxProblemsToDisplay }) => {
         const dtClient = await (0, dynatrace_clients_1.createDtHttpClient)(dtEnvironment, scopesBase.concat('storage:events:read', 'storage:buckets:read'), oauthClientId, oauthClientSecret, dtPlatformToken);
         // get problems (uses fetch)
@@ -254,6 +276,8 @@ const main = async () => {
     });
     tool('find_entity_by_name', 'Get the entityId of a monitored entity (service, host, process-group, application, kubernetes-node, ...) within the topology based on the name of the entity on Dynatrace', {
         entityName: zod_1.z.string().describe('Name of the entity to search for, e.g., "my-service" or "my-host"'),
+    }, {
+        readOnlyHint: true,
     }, async ({ entityName }) => {
         const dtClient = await (0, dynatrace_clients_1.createDtHttpClient)(dtEnvironment, scopesBase.concat('storage:entities:read'), oauthClientId, oauthClientSecret, dtPlatformToken);
         const entityResponse = await (0, find_monitored_entity_by_name_1.findMonitoredEntityByName)(dtClient, entityName);
@@ -261,6 +285,8 @@ const main = async () => {
     });
     tool('get_entity_details', 'Get details of a monitored entity based on the entityId on Dynatrace', {
         entityId: zod_1.z.string().optional(),
+    }, {
+        readOnlyHint: true,
     }, async ({ entityId }) => {
         const dtClient = await (0, dynatrace_clients_1.createDtHttpClient)(dtEnvironment, scopesBase.concat('storage:entities:read'), oauthClientId, oauthClientSecret, dtPlatformToken);
         const entityDetails = await (0, get_monitored_entity_details_1.getMonitoredEntityDetails)(dtClient, entityId);
@@ -298,6 +324,9 @@ const main = async () => {
     tool('send_slack_message', 'Sends a Slack message to a dedicated Slack Channel via Slack Connector on Dynatrace', {
         channel: zod_1.z.string().optional(),
         message: zod_1.z.string().optional(),
+    }, {
+        // not read-only, not open-world, not destructive
+        readOnlyHint: false,
     }, async ({ channel, message }) => {
         const dtClient = await (0, dynatrace_clients_1.createDtHttpClient)(dtEnvironment, scopesBase.concat('app-settings:objects:read'), oauthClientId, oauthClientSecret, dtPlatformToken);
         const response = await (0, send_slack_message_1.sendSlackMessage)(dtClient, slackConnectionId, channel, message);
@@ -305,6 +334,9 @@ const main = async () => {
     });
     tool('verify_dql', 'Verify a Dynatrace Query Language (DQL) statement on Dynatrace GRAIL before executing it. This step is recommended for DQL statements that have been dynamically created by non-expert tools. For statements coming from the `generate_dql_from_natural_language` tool as well as from documentation, this step can be omitted.', {
         dqlStatement: zod_1.z.string(),
+    }, {
+        readOnlyHint: true,
+        idempotentHint: true, // same input always yields same output
     }, async ({ dqlStatement }) => {
         const dtClient = await (0, dynatrace_clients_1.createDtHttpClient)(dtEnvironment, scopesBase, oauthClientId, oauthClientSecret, dtPlatformToken);
         const response = await (0, execute_dql_1.verifyDqlStatement)(dtClient, dqlStatement);
@@ -329,6 +361,12 @@ const main = async () => {
         dqlStatement: zod_1.z
             .string()
             .describe('DQL Statement (Ex: "fetch [logs, spans, events] | filter <some-filter> | summarize count(), by:{some-fields}.", or for metrics: "timeseries { avg(<metric-name>), value.A = avg(<metric-name>, scalar: true) }")'),
+    }, {
+        // not readonly (DQL statements may modify things), not idempotent (may change over time)
+        readOnlyHint: false,
+        idempotentHint: false,
+        // while we are not strictly talking to the open world here, the response from execute DQL could interpreted as a web-search, which often is referred to open-world
+        openWorldHint: true,
     }, async ({ dqlStatement }) => {
         // Create a HTTP Client that has all storage:*:read scopes
         const dtClient = await (0, dynatrace_clients_1.createDtHttpClient)(dtEnvironment, scopesBase.concat('storage:buckets:read', // Read all system data stored on Grail
@@ -342,11 +380,15 @@ const main = async () => {
         'storage:user.events:read', // Read User events from Grail
         'storage:user.sessions:read', // Read User sessions from Grail
         'storage:security.events:read'), oauthClientId, oauthClientSecret, dtPlatformToken);
-        const response = await (0, execute_dql_1.executeDql)(dtClient, { query: dqlStatement });
+        const response = await (0, execute_dql_1.executeDql)(dtClient, { query: dqlStatement }, grailBudgetGB);
         if (!response) {
             return 'DQL execution failed or returned no result.';
         }
         let result = `📊 **DQL Query Results**\n\n`;
+        // Budget warning comes first if present
+        if (response.budgetWarning) {
+            result += `${response.budgetWarning}\n\n`;
+        }
         // Cost and Performance Information
         if (response.scannedRecords !== undefined) {
             result += `- **Scanned Records:** ${response.scannedRecords.toLocaleString()}\n`;
@@ -354,18 +396,23 @@ const main = async () => {
         if (response.scannedBytes !== undefined) {
             const scannedGB = response.scannedBytes / (1000 * 1000 * 1000);
             result += `- **Scanned Bytes:** ${scannedGB.toFixed(2)} GB`;
-            // Cost warning based on scanned bytes
+            // Show budget status if available
+            if (response.budgetState) {
+                const usagePercentage = (response.budgetState.totalBytesScanned / response.budgetState.budgetLimitBytes) * 100;
+                result += ` (Session total: ${(response.budgetState.totalBytesScanned / (1000 * 1000 * 1000)).toFixed(2)} GB / ${response.budgetState.budgetLimitGB} GB budget, ${usagePercentage.toFixed(1)}% used)`;
+            }
+            result += '\n';
             if (scannedGB > 500) {
-                result += `\n    ⚠️ **Very High Data Usage Warning:** This query scanned ${scannedGB.toFixed(1)} GB of data, which may impact your Dynatrace consumption. Please take measures to optimize your query, like limiting the timeframe or selecting a bucket.\n`;
+                result += `    ⚠️ **Very High Data Usage Warning:** This query scanned ${scannedGB.toFixed(1)} GB of data, which may impact your Dynatrace consumption. Please take measures to optimize your query, like limiting the timeframe or selecting a bucket.\n`;
             }
             else if (scannedGB > 50) {
-                result += `\n    ⚠️ **High Data Usage Warning:** This query scanned ${scannedGB.toFixed(2)} GB of data, which may impact your Dynatrace consumption.\n`;
+                result += `    ⚠️ **High Data Usage Warning:** This query scanned ${scannedGB.toFixed(2)} GB of data, which may impact your Dynatrace consumption.\n`;
             }
             else if (scannedGB > 5) {
-                result += `\n    💡 **Moderate Data Usage:** This query scanned ${scannedGB.toFixed(2)} GB of data.\n`;
+                result += `    💡 **Moderate Data Usage:** This query scanned ${scannedGB.toFixed(2)} GB of data.\n`;
             }
             else if (response.scannedBytes === 0) {
-                result += `\n    💡 **No Data consumed:** This query did not consume any data.\n`;
+                result += `    💡 **No Data consumed:** This query did not consume any data.\n`;
             }
         }
         if (response.sampled !== undefined && response.sampled) {
@@ -379,6 +426,9 @@ const main = async () => {
         text: zod_1.z
             .string()
             .describe('Natural language description of what you want to query. Be specific and include time ranges, entities, and metrics of interest.'),
+    }, {
+        readOnlyHint: true,
+        idempotentHint: true,
     }, async ({ text }) => {
         const dtClient = await (0, dynatrace_clients_1.createDtHttpClient)(dtEnvironment, scopesBase.concat('davis-copilot:nl2dql:execute'), oauthClientId, oauthClientSecret, dtPlatformToken);
         const response = await (0, davis_copilot_1.generateDqlFromNaturalLanguage)(dtClient, text);
@@ -405,6 +455,9 @@ const main = async () => {
     });
     tool('explain_dql_in_natural_language', 'Explain Dynatrace Query Language (DQL) statements in natural language using Davis CoPilot AI.', {
         dql: zod_1.z.string().describe('The DQL statement to explain'),
+    }, {
+        readOnlyHint: true,
+        idempotentHint: true,
     }, async ({ dql }) => {
         const dtClient = await (0, dynatrace_clients_1.createDtHttpClient)(dtEnvironment, scopesBase.concat('davis-copilot:dql2nl:execute'), oauthClientId, oauthClientSecret, dtPlatformToken);
         const response = await (0, davis_copilot_1.explainDqlInNaturalLanguage)(dtClient, dql);
@@ -426,6 +479,10 @@ const main = async () => {
         text: zod_1.z.string().describe('Your question or request for Davis CoPilot'),
         context: zod_1.z.string().optional().describe('Optional context to provide additional information'),
         instruction: zod_1.z.string().optional().describe('Optional instruction for how to format the response'),
+    }, {
+        readOnlyHint: true,
+        idempotentHint: true,
+        openWorldHint: true, // web-search like characteristics
     }, async ({ text, context, instruction }) => {
         const dtClient = await (0, dynatrace_clients_1.createDtHttpClient)(dtEnvironment, scopesBase.concat('davis-copilot:conversations:execute'), oauthClientId, oauthClientSecret, dtPlatformToken);
         const conversationContext = [];
@@ -475,6 +532,10 @@ const main = async () => {
         teamName: zod_1.z.string().optional(),
         channel: zod_1.z.string().optional(),
         isPrivate: zod_1.z.boolean().optional().default(false),
+    }, {
+        // not read only, not idempotent
+        readOnlyHint: false,
+        idempotentHint: false, // creating the same workflow multiple times is possible
     }, async ({ problemType, teamName, channel, isPrivate }) => {
         const dtClient = await (0, dynatrace_clients_1.createDtHttpClient)(dtEnvironment, scopesBase.concat('automation:workflows:write', 'automation:workflows:read', 'automation:workflows:run'), oauthClientId, oauthClientSecret, dtPlatformToken);
         const response = await (0, create_workflow_for_problem_notification_1.createWorkflowForProblemNotification)(dtClient, teamName, channel, problemType, isPrivate);
@@ -492,6 +553,10 @@ const main = async () => {
     });
     tool('make_workflow_public', 'Modify a workflow and make it publicly available to everyone on the Dynatrace Environment', {
         workflowId: zod_1.z.string().optional(),
+    }, {
+        // not read only, but idempotent
+        readOnlyHint: false,
+        idempotentHint: true, // making the same workflow public multiple times yields the same result
     }, async ({ workflowId }) => {
         const dtClient = await (0, dynatrace_clients_1.createDtHttpClient)(dtEnvironment, scopesBase.concat('automation:workflows:write', 'automation:workflows:read', 'automation:workflows:run'), oauthClientId, oauthClientSecret, dtPlatformToken);
         const response = await (0, update_workflow_1.updateWorkflow)(dtClient, workflowId, {
@@ -504,6 +569,8 @@ const main = async () => {
             .string()
             .optional()
             .describe(`The Kubernetes (K8s) Cluster Id, referred to as k8s.cluster.uid (this is NOT the Dynatrace environment)`),
+    }, {
+        readOnlyHint: true,
     }, async ({ clusterId }) => {
         const dtClient = await (0, dynatrace_clients_1.createDtHttpClient)(dtEnvironment, scopesBase.concat('storage:events:read'), oauthClientId, oauthClientSecret, dtPlatformToken);
         const events = await (0, get_events_for_cluster_1.getEventsForCluster)(dtClient, clusterId);
@@ -511,6 +578,8 @@ const main = async () => {
     });
     tool('get_ownership', 'Get detailed Ownership information for one or multiple entities on Dynatrace', {
         entityIds: zod_1.z.string().optional().describe('Comma separated list of entityIds'),
+    }, {
+        readOnlyHint: true,
     }, async ({ entityIds }) => {
         const dtClient = await (0, dynatrace_clients_1.createDtHttpClient)(dtEnvironment, scopesBase.concat('environment-api:entities:read', 'settings:objects:read'), oauthClientId, oauthClientSecret, dtPlatformToken);
         console.error(`Fetching ownership for ${entityIds}`);
@@ -520,6 +589,71 @@ const main = async () => {
         resp += JSON.stringify(ownershipInformation);
         return resp;
     });
+    tool('reset_grail_budget', 'Reset the Grail query budget after it was exhausted, allowing new queries to be executed. This clears all tracked bytes scanned in the current session.', {}, {
+        readonlyHint: false, // modifies state
+        idempotentHint: true, // multiple resets yield the same result
+    }, async ({}) => {
+        // Reset the global tracker
+        (0, grail_budget_tracker_1.resetGrailBudgetTracker)();
+        // Get a fresh tracker to show the reset state
+        const freshTracker = (0, grail_budget_tracker_1.getGrailBudgetTracker)(grailBudgetGB);
+        const state = freshTracker.getState();
+        return `✅ **Grail Budget Reset Successfully!**
+
+Budget status after reset:
+- Total bytes scanned: ${state.totalBytesScanned} bytes (0 GB)
+- Budget limit: ${state.budgetLimitGB} GB
+- Remaining budget: ${state.budgetLimitGB} GB
+- Budget exceeded: ${state.isBudgetExceeded ? 'Yes' : 'No'}
+
+You can now execute new Grail queries (DQL, etc.) again. If this happens more often, please consider
+
+- Optimizing your queries (timeframes, bucket selection, filters)
+- Creating or optimizing bucket configurations that fit your queries (see https://docs.dynatrace.com/docs/analyze-explore-automate/logs/lma-bucket-assignment for details)
+- Increasing \`DT_GRAIL_QUERY_BUDGET_GB\` in your environment configuration
+`;
+    });
+    tool('send_email', 'Send an email using the Dynatrace Email API. The sender will be no-reply@apps.dynatrace.com. Maximum 10 recipients total across TO, CC, and BCC.', {
+        toRecipients: zod_1.z.array(zod_1.z.string().email()).describe('Array of email addresses for TO recipients'),
+        ccRecipients: zod_1.z.array(zod_1.z.string().email()).optional().describe('Array of email addresses for CC recipients'),
+        bccRecipients: zod_1.z.array(zod_1.z.string().email()).optional().describe('Array of email addresses for BCC recipients'),
+        subject: zod_1.z.string().describe('Subject line of the email'),
+        body: zod_1.z.string().describe('Body content of the email (plain text only)'),
+    }, {
+        openWorldHint: true, // email is as close to the open-world as we can get with our system
+    }, async ({ toRecipients, ccRecipients, bccRecipients, subject, body }) => {
+        // Validate total recipients limit (10 max across TO, CC, and BCC)
+        const totalRecipients = toRecipients.length + (ccRecipients?.length || 0) + (bccRecipients?.length || 0);
+        if (totalRecipients > 10) {
+            throw new Error(`Total recipients (${totalRecipients}) exceeds maximum limit of 10 across TO, CC, and BCC fields`);
+        }
+        const dtClient = await (0, dynatrace_clients_1.createDtHttpClient)(dtEnvironment, scopesBase.concat('email:emails:send'), oauthClientId, oauthClientSecret, dtPlatformToken);
+        const emailRequest = {
+            toRecipients: { emailAddresses: toRecipients },
+            ...(ccRecipients && { ccRecipients: { emailAddresses: ccRecipients } }),
+            ...(bccRecipients && { bccRecipients: { emailAddresses: bccRecipients } }),
+            subject,
+            body: {
+                contentType: 'text/plain',
+                body,
+            },
+        };
+        const result = await (0, send_email_1.sendEmail)(dtClient, emailRequest);
+        // Format the structured response into a user-friendly string
+        let responseMessage = `Email send request accepted. Request ID: ${result.requestId}\n`;
+        responseMessage += `Message: ${result.message}\n`;
+        if (result.invalidDestinations && result.invalidDestinations.length > 0) {
+            responseMessage += `Invalid destinations: ${result.invalidDestinations.join(', ')}\n`;
+        }
+        if (result.bouncingDestinations && result.bouncingDestinations.length > 0) {
+            responseMessage += `Bouncing destinations: ${result.bouncingDestinations.join(', ')}\n`;
+        }
+        if (result.complainingDestinations && result.complainingDestinations.length > 0) {
+            responseMessage += `Complaining destinations: ${result.complainingDestinations.join(', ')}\n`;
+        }
+        responseMessage += `\nNext Steps:\n- Delivery is asynchronous.\n- Investigate any invalid, bouncing, or complaining destinations before retrying.`;
+        return responseMessage;
+    });
     // Parse command line arguments using commander
     const program = new commander_1.Command();
     program
@@ -535,14 +669,23 @@ const main = async () => {
     const httpMode = options.http || options.server;
     const httpPort = parseInt(options.port, 10);
     const host = options.host || '0.0.0.0';
+    // HTTP server mode (Stateless)
     if (httpMode) {
-        // HTTP server mode
-        const httpTransport = new streamableHttp_js_1.StreamableHTTPServerTransport({
-            sessionIdGenerator: () => (0, node_crypto_1.randomUUID)(),
-        });
         const httpServer = (0, node_http_1.createServer)(async (req, res) => {
             // Parse request body for POST requests
             let body;
+            // Create a new Stateless HTTP Transport
+            const httpTransport = new streamableHttp_js_1.StreamableHTTPServerTransport({
+                sessionIdGenerator: undefined, // No Session ID needed
+            });
+            res.on('close', () => {
+                // close transport and server, but not the httpServer itself
+                httpTransport.close();
+                server.close();
+            });
+            // Connecting MCP-server to HTTP transport
+            await server.connect(httpTransport);
+            // Handle POST Requests for this endpoint
             if (req.method === 'POST') {
                 const chunks = [];
                 for await (const chunk of req) {
@@ -560,8 +703,6 @@ const main = async () => {
             }
             await httpTransport.handleRequest(req, res, body);
         });
-        console.error('Connecting server to HTTP transport...');
-        await server.connect(httpTransport);
         // Start HTTP Server on the specified host and port
         httpServer.listen(httpPort, host, () => {
             console.error(`Dynatrace MCP Server running on HTTP at http://${host}:${httpPort}`);

package/dist/utils/grail-budget-tracker.js

@@ -0,0 +1,139 @@
+"use strict";
+/**
+ * Grail Budget Tracker - tracks and limits bytes scanned by Grail queries (DQL, etc.)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getGrailBudgetTracker = getGrailBudgetTracker;
+exports.resetGrailBudgetTracker = resetGrailBudgetTracker;
+exports.createGrailBudgetTracker = createGrailBudgetTracker;
+exports.formatBytesAsGB = formatBytesAsGB;
+exports.generateBudgetWarning = generateBudgetWarning;
+/**
+ * In-memory tracker for Grail budget across the session
+ */
+class GrailBudgetTrackerImpl {
+    _totalBytesScanned = 0;
+    _budgetLimitBytes;
+    _budgetLimitGB;
+    _unlimited;
+    constructor(budgetLimitGB) {
+        this._budgetLimitGB = budgetLimitGB;
+        this._unlimited = budgetLimitGB === -1;
+        this._budgetLimitBytes = this._unlimited ? Number.POSITIVE_INFINITY : budgetLimitGB * 1000 * 1000 * 1000; // Convert GB to bytes (base 1000)
+    }
+    get totalBytesScanned() {
+        return this._totalBytesScanned;
+    }
+    get budgetLimitBytes() {
+        return this._unlimited ? -1 : this._budgetLimitBytes;
+    }
+    get budgetLimitGB() {
+        return this._budgetLimitGB;
+    }
+    get isBudgetExceeded() {
+        return this._unlimited ? false : this._totalBytesScanned >= this._budgetLimitBytes;
+    }
+    get remainingBudgetBytes() {
+        return this._unlimited ? -1 : Math.max(0, this._budgetLimitBytes - this._totalBytesScanned);
+    }
+    get remainingBudgetGB() {
+        return this._unlimited ? -1 : this.remainingBudgetBytes / (1000 * 1000 * 1000);
+    }
+    /**
+     * Add bytes scanned to the tracker
+     * @param bytesScanned Number of bytes scanned in the Grail query
+     * @returns Updated tracker state
+     */
+    addBytesScanned(bytesScanned) {
+        this._totalBytesScanned += bytesScanned;
+        return this.getState();
+    }
+    /**
+     * Get current state of the tracker
+     */
+    getState() {
+        return {
+            totalBytesScanned: this.totalBytesScanned,
+            budgetLimitBytes: this.budgetLimitBytes,
+            budgetLimitGB: this.budgetLimitGB,
+            isBudgetExceeded: this.isBudgetExceeded,
+            remainingBudgetBytes: this.remainingBudgetBytes,
+            remainingBudgetGB: this.remainingBudgetGB,
+        };
+    }
+    /**
+     * Reset the tracker (for testing purposes)
+     */
+    reset() {
+        this._totalBytesScanned = 0;
+    }
+}
+// Global instance for the current session
+let globalBudgetTracker = null;
+/**
+ * Initialize or get the global Grail budget tracker
+ * @param budgetLimitGB Budget limit in GB (base 1000). If not provided and tracker doesn't exist, defaults to 1000 GB
+ * @returns Grail budget tracker instance
+ */
+function getGrailBudgetTracker(budgetLimitGB) {
+    if (!globalBudgetTracker) {
+        const defaultBudget = budgetLimitGB ?? 1000; // Default to 1000 GB if not specified
+        globalBudgetTracker = new GrailBudgetTrackerImpl(defaultBudget);
+    }
+    return globalBudgetTracker;
+}
+/**
+ * Reset the global Grail budget tracker (primarily for testing)
+ */
+function resetGrailBudgetTracker() {
+    globalBudgetTracker = null;
+}
+/**
+ * Create a new Grail budget tracker instance (for testing)
+ * @param budgetLimitGB Budget limit in GB (base 1000)
+ * @returns New Grail budget tracker instance
+ */
+function createGrailBudgetTracker(budgetLimitGB) {
+    return new GrailBudgetTrackerImpl(budgetLimitGB);
+}
+/**
+ * Format bytes as GB with appropriate precision
+ * @param bytes Number of bytes
+ * @returns Formatted string with GB value
+ */
+function formatBytesAsGB(bytes) {
+    const gb = bytes / (1000 * 1000 * 1000);
+    if (gb >= 10) {
+        return gb.toFixed(1);
+    }
+    else if (gb >= 1) {
+        return gb.toFixed(2);
+    }
+    else if (gb >= 0.1) {
+        return gb.toFixed(3);
+    }
+    else {
+        return gb.toFixed(4);
+    }
+}
+/**
+ * Generate a budget warning message based on current state
+ * @param budgetState Current budget tracker state
+ * @param currentQueryBytes Bytes scanned in the current query
+ * @returns Warning message or null if no warning needed
+ */
+function generateBudgetWarning(budgetState, currentQueryBytes) {
+    if (budgetState.isBudgetExceeded) {
+        const totalGB = formatBytesAsGB(budgetState.totalBytesScanned);
+        const currentGB = formatBytesAsGB(currentQueryBytes);
+        return `🚨 **Grail Budget Exceeded:** This query scanned ${currentGB} GB. Total session usage: ${totalGB} GB / ${budgetState.budgetLimitGB} GB budget limit. You will not be able to perform any more queries in this session.`;
+    }
+    // Warning when approaching budget (80% threshold)
+    const usagePercentage = (budgetState.totalBytesScanned / budgetState.budgetLimitBytes) * 100;
+    if (usagePercentage >= 80) {
+        const remainingGB = formatBytesAsGB(budgetState.remainingBudgetBytes);
+        const totalGB = formatBytesAsGB(budgetState.totalBytesScanned);
+        return `⚠️ **Grail Budget Warning:** Session usage: ${totalGB} GB / ${budgetState.budgetLimitGB} GB (${usagePercentage.toFixed(1)}%). Remaining: ${remainingGB} GB.`;
+    }
+    return null;
+}

package/dist/utils/grail-budget-tracker.test.js

@@ -0,0 +1,182 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const grail_budget_tracker_1 = require("./grail-budget-tracker");
+describe('Grail Budget Tracker', () => {
+    describe('unlimited budget (-1)', () => {
+        it('should never exceed budget and always allow queries when budget is -1', () => {
+            const tracker = (0, grail_budget_tracker_1.createGrailBudgetTracker)(-1);
+            expect(tracker.getState().budgetLimitGB).toBe(-1);
+            expect(tracker.getState().budgetLimitBytes).toBe(-1);
+            expect(tracker.getState().isBudgetExceeded).toBe(false);
+            expect(tracker.getState().remainingBudgetBytes).toBe(-1);
+            expect(tracker.getState().remainingBudgetGB).toBe(-1);
+            // Add a huge number of bytes, should still not be exceeded
+            tracker.addBytesScanned(1e15);
+            expect(tracker.getState().isBudgetExceeded).toBe(false);
+            expect(tracker.getState().remainingBudgetBytes).toBe(-1);
+            expect(tracker.getState().remainingBudgetGB).toBe(-1);
+        });
+    });
+    beforeEach(() => {
+        (0, grail_budget_tracker_1.resetGrailBudgetTracker)();
+    });
+    describe('createGrailBudgetTracker', () => {
+        it('should create a tracker with the specified budget limit', () => {
+            const tracker = (0, grail_budget_tracker_1.createGrailBudgetTracker)(5);
+            const state = tracker.getState();
+            expect(state.budgetLimitGB).toBe(5);
+            expect(state.budgetLimitBytes).toBe(5000000000); // 5 GB in bytes (base 1000)
+            expect(state.totalBytesScanned).toBe(0);
+            expect(state.isBudgetExceeded).toBe(false);
+            expect(state.remainingBudgetGB).toBe(5);
+        });
+        it('should correctly track bytes scanned', () => {
+            const tracker = (0, grail_budget_tracker_1.createGrailBudgetTracker)(1); // 1 GB limit
+            const bytesToScan = 500000000; // 0.5 GB
+            const state = tracker.addBytesScanned(bytesToScan);
+            expect(state.totalBytesScanned).toBe(bytesToScan);
+            expect(state.remainingBudgetBytes).toBe(500000000); // 0.5 GB remaining
+            expect(state.remainingBudgetGB).toBe(0.5);
+            expect(state.isBudgetExceeded).toBe(false);
+        });
+        it('should detect when budget is exceeded', () => {
+            const tracker = (0, grail_budget_tracker_1.createGrailBudgetTracker)(1); // 1 GB limit
+            const bytesToScan = 1500000000; // 1.5 GB
+            const state = tracker.addBytesScanned(bytesToScan);
+            expect(state.totalBytesScanned).toBe(bytesToScan);
+            expect(state.isBudgetExceeded).toBe(true);
+            expect(state.remainingBudgetBytes).toBe(0);
+            expect(state.remainingBudgetGB).toBe(0);
+        });
+        it('should accumulate bytes scanned across multiple calls', () => {
+            const tracker = (0, grail_budget_tracker_1.createGrailBudgetTracker)(2); // 2 GB limit
+            tracker.addBytesScanned(500000000); // 0.5 GB
+            tracker.addBytesScanned(700000000); // 0.7 GB
+            const state = tracker.addBytesScanned(300000000); // 0.3 GB
+            expect(state.totalBytesScanned).toBe(1500000000); // 1.5 GB total
+            expect(state.remainingBudgetBytes).toBe(500000000); // 0.5 GB remaining
+            expect(state.isBudgetExceeded).toBe(false);
+        });
+        it('should reset tracker correctly', () => {
+            const tracker = (0, grail_budget_tracker_1.createGrailBudgetTracker)(1);
+            tracker.addBytesScanned(500000000);
+            tracker.reset();
+            const state = tracker.getState();
+            expect(state.totalBytesScanned).toBe(0);
+            expect(state.remainingBudgetGB).toBe(1);
+            expect(state.isBudgetExceeded).toBe(false);
+        });
+    });
+    describe('getGrailBudgetTracker', () => {
+        it('should create a global tracker with default budget when called first time', () => {
+            const tracker = (0, grail_budget_tracker_1.getGrailBudgetTracker)();
+            const state = tracker.getState();
+            expect(state.budgetLimitGB).toBe(1000); // Default budget
+        });
+        it('should create a global tracker with specified budget when called first time', () => {
+            const tracker = (0, grail_budget_tracker_1.getGrailBudgetTracker)(15);
+            const state = tracker.getState();
+            expect(state.budgetLimitGB).toBe(15);
+        });
+        it('should return the same global tracker instance on subsequent calls', () => {
+            const tracker1 = (0, grail_budget_tracker_1.getGrailBudgetTracker)(5);
+            const tracker2 = (0, grail_budget_tracker_1.getGrailBudgetTracker)(20); // Different budget, but should return existing
+            expect(tracker1).toBe(tracker2);
+            expect(tracker1.getState().budgetLimitGB).toBe(5); // Should keep original budget
+        });
+        it('should persist state across getGrailBudgetTracker calls', () => {
+            const tracker1 = (0, grail_budget_tracker_1.getGrailBudgetTracker)(3);
+            tracker1.addBytesScanned(1000000000); // 1 GB
+            const tracker2 = (0, grail_budget_tracker_1.getGrailBudgetTracker)();
+            const state = tracker2.getState();
+            expect(state.totalBytesScanned).toBe(1000000000);
+            expect(state.budgetLimitGB).toBe(3);
+        });
+    });
+    describe('formatBytesAsGB', () => {
+        it('should format large GB values with 1 decimal place', () => {
+            expect((0, grail_budget_tracker_1.formatBytesAsGB)(15000000000)).toBe('15.0'); // 15 GB
+            expect((0, grail_budget_tracker_1.formatBytesAsGB)(123456789000)).toBe('123.5'); // ~123.5 GB
+        });
+        it('should format medium GB values with 2 decimal places', () => {
+            expect((0, grail_budget_tracker_1.formatBytesAsGB)(1500000000)).toBe('1.50'); // 1.5 GB
+            expect((0, grail_budget_tracker_1.formatBytesAsGB)(5230000000)).toBe('5.23'); // 5.23 GB
+        });
+        it('should format small GB values with 3 decimal places', () => {
+            expect((0, grail_budget_tracker_1.formatBytesAsGB)(150000000)).toBe('0.150'); // 0.15 GB
+            expect((0, grail_budget_tracker_1.formatBytesAsGB)(523000000)).toBe('0.523'); // 0.523 GB
+        });
+        it('should format very small GB values with 4 decimal places', () => {
+            expect((0, grail_budget_tracker_1.formatBytesAsGB)(15000000)).toBe('0.0150'); // 0.015 GB
+            expect((0, grail_budget_tracker_1.formatBytesAsGB)(1500000)).toBe('0.0015'); // 0.0015 GB
+        });
+        it('should handle zero bytes', () => {
+            expect((0, grail_budget_tracker_1.formatBytesAsGB)(0)).toBe('0.0000');
+        });
+    });
+    describe('generateBudgetWarning', () => {
+        it('should return budget exceeded warning when budget is exceeded', () => {
+            const tracker = (0, grail_budget_tracker_1.createGrailBudgetTracker)(1); // 1 GB limit
+            tracker.addBytesScanned(1200000000); // 1.2 GB
+            const state = tracker.getState();
+            const warning = (0, grail_budget_tracker_1.generateBudgetWarning)(state, 200000000); // Current query: 0.2 GB
+            expect(warning).toContain('🚨 **Grail Budget Exceeded:**');
+            expect(warning).toContain('1.20 GB');
+            expect(warning).toContain('1 GB budget limit');
+            expect(warning).toContain('0.200 GB');
+        });
+        it('should return warning when approaching budget (80% threshold)', () => {
+            const tracker = (0, grail_budget_tracker_1.createGrailBudgetTracker)(1); // 1 GB limit
+            tracker.addBytesScanned(850000000); // 0.85 GB (85%)
+            const state = tracker.getState();
+            const warning = (0, grail_budget_tracker_1.generateBudgetWarning)(state, 50000000); // Current query: 0.05 GB
+            expect(warning).toContain('⚠️ **Grail Budget Warning:**');
+            expect(warning).toContain('85.0%');
+            expect(warning).toContain('0.150 GB'); // Remaining
+        });
+        it('should return no warning when well below budget', () => {
+            const tracker = (0, grail_budget_tracker_1.createGrailBudgetTracker)(1); // 1 GB limit
+            tracker.addBytesScanned(300000000); // 0.3 GB (30%)
+            const state = tracker.getState();
+            const warning = (0, grail_budget_tracker_1.generateBudgetWarning)(state, 100000000); // Current query: 0.1 GB
+            expect(warning).toBeNull();
+        });
+        it('should return warning when exactly at 80% threshold', () => {
+            const tracker = (0, grail_budget_tracker_1.createGrailBudgetTracker)(1); // 1 GB limit
+            tracker.addBytesScanned(800000000); // 0.8 GB (80%)
+            const state = tracker.getState();
+            const warning = (0, grail_budget_tracker_1.generateBudgetWarning)(state, 0);
+            expect(warning).toContain('⚠️ **Grail Budget Warning:**');
+            expect(warning).toContain('80.0%');
+        });
+        it('should prioritize exceeded warning over approaching warning', () => {
+            const tracker = (0, grail_budget_tracker_1.createGrailBudgetTracker)(1); // 1 GB limit
+            tracker.addBytesScanned(1100000000); // 1.1 GB (110% - exceeded)
+            const state = tracker.getState();
+            const warning = (0, grail_budget_tracker_1.generateBudgetWarning)(state, 100000000);
+            expect(warning).toContain('🚨 **Grail Budget Exceeded:**');
+            expect(warning).not.toContain('⚠️ **Grail Budget Warning:**');
+        });
+    });
+    describe('edge cases', () => {
+        it('should handle fractional GB budgets', () => {
+            const tracker = (0, grail_budget_tracker_1.createGrailBudgetTracker)(0.5); // 0.5 GB limit
+            const state = tracker.getState();
+            expect(state.budgetLimitGB).toBe(0.5);
+            expect(state.budgetLimitBytes).toBe(500000000); // 0.5 GB in bytes
+        });
+        it('should handle very large budgets', () => {
+            const tracker = (0, grail_budget_tracker_1.createGrailBudgetTracker)(1000); // 1TB limit
+            const state = tracker.getState();
+            expect(state.budgetLimitGB).toBe(1000);
+            expect(state.budgetLimitBytes).toBe(1000000000000); // 1TB in bytes
+        });
+        it('should handle zero bytes scanned', () => {
+            const tracker = (0, grail_budget_tracker_1.createGrailBudgetTracker)(1);
+            const state = tracker.addBytesScanned(0);
+            expect(state.totalBytesScanned).toBe(0);
+            expect(state.isBudgetExceeded).toBe(false);
+            expect(state.remainingBudgetGB).toBe(1);
+        });
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dynatrace-oss/dynatrace-mcp-server",
-  "version": "0.6.0-rc.1",
+  "version": "0.6.0",
   "mcpName": "io.github.dynatrace-oss/Dynatrace-mcp",
   "description": "Model Context Protocol (MCP) server for Dynatrace",
   "keywords": [
@@ -48,6 +48,7 @@
   "license": "MIT",
   "dependencies": {
     "@dynatrace-sdk/client-automation": "^5.3.0",
+    "@dynatrace-sdk/client-davis-copilot": "^1.0.0",
     "@dynatrace-sdk/client-platform-management-service": "^1.6.3",
     "@dynatrace-sdk/client-query": "^1.18.1",
     "@dynatrace-sdk/shared-errors": "^1.0.0",