@dynatrace-oss/dynatrace-mcp-server 0.4.0 → 0.5.0-rc.2

package/README.md

@@ -7,10 +7,10 @@ Bring real-time observability data directly into your development workflow.
 
 ## Use cases
 
-- Real-time observability, fetch production-level data for early detection.
-- Fix issues in the context from monitored exceptions, logs, and anomalies.
-- More context on security level issues
-- Natural language to query log data
+- **Real-time observability** - Fetch production-level data for early detection and proactive monitoring
+- **Contextual debugging** - Fix issues with full context from monitored exceptions, logs, and anomalies
+- **Security insights** - Get detailed vulnerability analysis and security problem tracking
+- **Natural language queries** - Use AI-powered DQL generation and explanation
 
 ## Capabilities
 
@@ -22,9 +22,16 @@ Bring real-time observability data directly into your development workflow.
 - Get more information about a monitored entity
 - Get Ownership of an entity
 
-## Quickstart
+### AI-Powered Assistance (Preview)
+
+- **Natural Language to DQL** - Convert plain English queries to Dynatrace Query Language
+- **DQL Explanation** - Get plain English explanations of complex DQL queries
+- **AI Chat Assistant** - Get contextual help and guidance for Dynatrace questions
+- **Feedback System** - Provide feedback to improve AI responses over time
 
-**Work in progress**
+> **Note:** While Davis CoPilot AI is generally available (GA), the Davis CoPilot APIs are currently in preview. For more information, visit the [Davis CoPilot Preview Community](https://dt-url.net/copilot-community).
+
+## Quickstart
 
 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`.
 
@@ -106,45 +113,76 @@ This configuration should be stored in `<your-repo>/.amazonq/mcp.json`.
 
 ## Environment Variables
 
-A **Dynatrace OAuth Client** is needed to communicate with your Dynatrace Environment. Please follow the documentation about
-[creating an Oauth Client in Dynatrace](https://docs.dynatrace.com/docs/manage/identity-access-management/access-tokens-and-oauth-clients/oauth-clients),
-and set up the following environment variables in order for this MCP to work:
+You can set up authentication via **OAuth Client** or **Platform Tokens** (v0.5.0 and newer) 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`)
 - `OAUTH_CLIENT_ID` (string, e.g., `dt0s02.SAMPLE`) - Dynatrace OAuth Client ID
 - `OAUTH_CLIENT_SECRET` (string, e.g., `dt0s02.SAMPLE.abcd1234`) - Dynatrace OAuth Client Secret
-- OAuth Client Scopes:
-  - `app-engine:apps:run` - needed for environmentInformationClient
-  - `app-engine:functions:run` - needed for environmentInformationClient
-  - `hub:catalog:read` - get details about installed Apps on Dynatrace Environment
-  - `environment-api:security-problems:read` - needed for reading security problems
-  - `environment-api:entities:read` - read monitored entities
-  - `environment-api:problems:read` - get problems
-  - `environment-api:metrics:read` - read metrics
-  - `environment-api:slo:read` - read SLOs
-  - `storage:buckets:read` - Read all system data stored on Grail
-  - `storage:logs:read` - Read logs for reliability guardian validations
-  - `storage:metrics:read` - Read metrics for reliability guardian validations
-  - `storage:bizevents:read` - Read bizevents for reliability guardian validations
-  - `storage:spans:read` - Read spans from Grail
-  - `storage:entities:read` - Read Entities from Grail
-  - `storage:events:read` - Read Events from Grail
-  - `storage:system:read` - Read System Data from Grail
-  - `storage:user.events:read` - Read User events from Grail
-  - `storage:user.sessions:read` - Read User sessions from Grail
-  - `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`.
+- With v0.5.0 and newer: `DT_PLATFORM_TOKEN` (string, e.g., `dt0s16.SAMPLE.abcd1234`) - Dynatrace Platform Token (limited support, as not all scopes are available; see below)
+
+For more information, please have a look at the documentation about
+[creating an Oauth Client in Dynatrace](https://docs.dynatrace.com/docs/manage/identity-access-management/access-tokens-and-oauth-clients/oauth-clients), as well as
+[creating a Platform Token in Dynatrace](https://docs.dynatrace.com/docs/manage/identity-access-management/access-tokens-and-oauth-clients/platform-tokens).
 
 In addition, depending on the features you use, the following variables can be configured:
 
 - `SLACK_CONNECTION_ID` (string) - connection ID of a [Slack Connection](https://docs.dynatrace.com/docs/analyze-explore-automate/workflows/actions/slack)
 
+### Scopes for Authentication
+
+Depending on the features you are using, the following scopes are needed:
+
+- `app-engine:apps:run` - needed for almost all tools
+- `app-engine:functions:run` - needed for for almost all tools
+- `environment-api:security-problems:read` - needed for reading security problems (_currently not available for Platform Tokens_)
+- `environment-api:entities:read` - read monitored entities (_currently not available for Platform Tokens_)
+- `environment-api:metrics:read` - read metrics (_currently not available for Platform Tokens_)
+- `environment-api:slo:read` - read SLOs (_currently not available for Platform Tokens_)
+- `automation:workflows:read` - read Workflows
+- `automation:workflows:write` - create and update Workflows
+- `automation:workflows:run` - run Workflows
+- `storage:buckets:read` - needed for `execute_dql` tool to read all system data stored on Grail
+- `storage:logs:read` - needed for `execute_dql` tool to read logs for reliability guardian validations
+- `storage:metrics:read` - needed for `execute_dql` tool to read metrics for reliability guardian validations
+- `storage:bizevents:read` - needed for `execute_dql` tool to read bizevents for reliability guardian validations
+- `storage:spans:read` - needed for `execute_dql` tool to read spans from Grail
+- `storage:entities:read` - needed for `execute_dql` tool to read Entities from Grail
+- `storage:events:read` - needed for `execute_dql` tool to read Events from Grail
+- `storage:security.events:read`- needed for `execute_dql` tool to read Security Events from Grail
+- `storage:system:read` - needed for `execute_dql` tool to read System Data from Grail
+- `storage:user.events:read` - needed for `execute_dql` tool to read User events from Grail
+- `storage:user.sessions:read` - needed for `execute_dql` tool to read User sessions from Grail
+- `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
+- `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`.
+
 ## ✨ Example prompts ✨
 
 Use these example prompts as a starting point. Just copy them into your IDE or agent setup, adapt them to your services/stack/architecture,
 and extend them as needed. They’re here to help you imagine how real-time observability and automation work together in the MCP context in your IDE.
 
+**Write a DQL query from natural language:**
+
+```
+Show me error rates for the payment service in the last hour
+```
+
+**Explain a DQL query:**
+
+```
+What does this DQL do?
+fetch logs | filter dt.source_entity == 'SERVICE-123' | summarize count(), by:{severity} | sort count() desc
+```
+
+**Chat with Davis CoPilot:**
+
+```
+How can I investigate slow database queries in Dynatrace?
+```
+
 **Find open vulnerabilities on production, setup alert.**
 
 ```
@@ -246,6 +284,8 @@ First, enable Copilot for your Workspace `.vscode/settings.json`:
 }
 ```
 
+and make sure that you are using Agent Mode in CoPilot.
+
 Second, add the MCP to `.vscode/mcp.json`:
 
 ```json
@@ -253,7 +293,7 @@ Second, add the MCP to `.vscode/mcp.json`:
   "servers": {
     "my-dynatrace-mcp-server": {
       "command": "node",
-      "args": ["${workspaceFolder}/dist/index.js"],
+      "args": ["--watch", "${workspaceFolder}/dist/index.js"],
       "envFile": "${workspaceFolder}/.env"
     }
   }
@@ -262,7 +302,7 @@ Second, add the MCP to `.vscode/mcp.json`:
 
 Third, create a `.env` file in this repository (you can copy from `.env.template`) and configure environment variables as [described above](#environment-variables).
 
-Last but not least, switch to Agent Mode in CoPilot and reload tools.
+Finally, make changes to your code and compile it with `npm run build` or just run `npm run watch` and it auto-compiles.
 
 ## Notes
 

package/dist/authentication/dynatrace-clients.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createOAuthClient = exports.ExtendedOauthClient = void 0;
+exports.createDtHttpClient = void 0;
 const http_client_1 = require("@dynatrace-sdk/http-client");
 const dt_app_1 = require("dt-app");
 const package_json_1 = require("../../package.json");
@@ -34,29 +34,40 @@ const requestToken = async (clientId, clientSecret, ssoAuthUrl, scopes) => {
     return await res.json();
 };
 /**
- * ExtendedOAuthClient that takes parameters for clientId, secret, scopes, environmentUrl, authUrl, and the version of the dynatrace-mcp-server
+ * Create a Dynatrace Http Client (from the http-client SDK) based on the provided authentication credentails
+ * @param environmentUrl
+ * @param scopes
+ * @param clientId
+ * @param clientSecret
+ * @param dtPlatformToken
+ * @returns
  */
-class ExtendedOauthClient extends http_client_1._OAuthHttpClient {
-    userAgent;
-    constructor(config, userAgent) {
-        super(config);
-        this.userAgent = userAgent;
+const createDtHttpClient = async (environmentUrl, scopes, clientId, clientSecret, dtPlatformToken) => {
+    if (clientId && clientSecret) {
+        // create an OAuth client if clientId and clientSecret are provided
+        return createOAuthHttpClient(environmentUrl, scopes, clientId, clientSecret);
     }
-    send(options) {
-        // add the user-agent header to the request
-        options.headers = {
-            ...options.headers,
-            'User-Agent': this.userAgent,
-        };
-        // call the parent send method
-        return super.send(options);
+    if (dtPlatformToken) {
+        // create a simple HTTP client if only the platform token is provided
+        return createBearerTokenHttpClient(environmentUrl, dtPlatformToken);
     }
-}
-exports.ExtendedOauthClient = ExtendedOauthClient;
+    throw new Error('Failed to create Dynatrace HTTP Client: Please provide either clientId and clientSecret or dtPlatformToken');
+};
+exports.createDtHttpClient = createDtHttpClient;
+/** Creates an HTTP Client based on environmentUrl and a platform token */
+const createBearerTokenHttpClient = async (environmentUrl, dtPlatformToken) => {
+    return new http_client_1.PlatformHttpClient({
+        baseUrl: environmentUrl,
+        defaultHeaders: {
+            'Authorization': `Bearer ${dtPlatformToken}`,
+            'User-Agent': `dynatrace-mcp-server/v${package_json_1.version} (${process.platform}-${process.arch})`,
+        },
+    });
+};
 /** Create an Oauth Client based on clientId, clientSecret, environmentUrl and scopes
  * This uses a client-credentials flow to request a token from the SSO endpoint.
  */
-const createOAuthClient = async (clientId, clientSecret, environmentUrl, scopes) => {
+const createOAuthHttpClient = async (environmentUrl, scopes, clientId, clientSecret) => {
     if (!clientId) {
         throw new Error('Failed to retrieve OAuth client id from env "DT_APP_OAUTH_CLIENT_ID"');
     }
@@ -77,13 +88,5 @@ const createOAuthClient = async (clientId, clientSecret, environmentUrl, scopes)
         throw new Error(`Failed to retrieve OAuth token (IssueId: ${tokenResponse.issueId}): ${tokenResponse.error} - ${tokenResponse.error_description}. Note: Your OAuth client is most likely not configured correctly and/or is missing scopes.`);
     }
     console.error(`Successfully retrieved token from SSO!`);
-    const userAgent = `dynatrace-mcp-server/v${package_json_1.version} (${process.platform}-${process.arch})`;
-    return new ExtendedOauthClient({
-        scopes,
-        clientId,
-        secret: clientSecret,
-        environmentUrl,
-        authUrl: ssoAuthUrl,
-    }, userAgent);
+    return createBearerTokenHttpClient(environmentUrl, tokenResponse.access_token);
 };
-exports.createOAuthClient = createOAuthClient;

package/dist/authentication/dynatrace-clients.test.js

@@ -0,0 +1,189 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const dynatrace_clients_1 = require("./dynatrace-clients");
+const http_client_1 = require("@dynatrace-sdk/http-client");
+const dt_app_1 = require("dt-app");
+// Mock external dependencies
+jest.mock('@dynatrace-sdk/http-client');
+jest.mock('dt-app');
+jest.mock('../../package.json', () => ({
+    version: '1.0.0-test',
+}));
+// Mock fetch globally
+global.fetch = jest.fn();
+const mockPlatformHttpClient = http_client_1.PlatformHttpClient;
+const mockGetSSOUrl = dt_app_1.getSSOUrl;
+const mockFetch = global.fetch;
+describe('dynatrace-clients', () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+        // Reset console.error mock
+        jest.spyOn(console, 'error').mockImplementation(() => { });
+    });
+    afterEach(() => {
+        jest.restoreAllMocks();
+    });
+    describe('createDtHttpClient', () => {
+        const environmentUrl = 'https://test123.apps.dynatrace.com';
+        const scopes = ['scope1', 'scope2'];
+        describe('with OAuth credentials', () => {
+            const clientId = 'test-client-id';
+            const clientSecret = 'test-client-secret';
+            const platformToken = 'test-platform-token';
+            beforeEach(() => {
+                mockGetSSOUrl.mockResolvedValue('https://sso.dynatrace.com');
+            });
+            it('should create OAuth client successfully', async () => {
+                const mockTokenResponse = {
+                    access_token: 'test-access-token',
+                    token_type: 'Bearer',
+                    expires_in: 3600,
+                    scope: 'scope1 scope2',
+                };
+                mockFetch.mockResolvedValueOnce({
+                    ok: true,
+                    json: async () => mockTokenResponse,
+                });
+                const result = await (0, dynatrace_clients_1.createDtHttpClient)(environmentUrl, scopes, clientId, clientSecret);
+                expect(mockGetSSOUrl).toHaveBeenCalledWith(environmentUrl);
+                expect(mockFetch).toHaveBeenCalledWith('https://sso.dynatrace.com/sso/oauth2/token', {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/x-www-form-urlencoded',
+                    },
+                    body: new URLSearchParams({
+                        grant_type: 'client_credentials',
+                        client_id: clientId,
+                        client_secret: clientSecret,
+                        scope: scopes.join(' '),
+                    }),
+                });
+                expect(mockPlatformHttpClient).toHaveBeenCalledWith({
+                    baseUrl: environmentUrl,
+                    defaultHeaders: {
+                        'Authorization': 'Bearer test-access-token',
+                        'User-Agent': 'dynatrace-mcp-server/v1.0.0-test (linux-x64)',
+                    },
+                });
+                expect(result).toBeInstanceOf(http_client_1.PlatformHttpClient);
+            });
+            it('should throw error when clientId, clientSecret and platformToken are missing', async () => {
+                await expect((0, dynatrace_clients_1.createDtHttpClient)(environmentUrl, scopes, undefined, undefined, undefined)).rejects.toThrow('Failed to create Dynatrace HTTP Client: Please provide either clientId and clientSecret or dtPlatformToken');
+            });
+            it('should throw error when environmentUrl is missing', async () => {
+                await expect((0, dynatrace_clients_1.createDtHttpClient)('', scopes, clientId, clientSecret)).rejects.toThrow('Failed to retrieve environment URL from env "DT_ENVIRONMENT"');
+            });
+            it('should throw error when token request fails with HTTP error', async () => {
+                mockFetch.mockResolvedValueOnce({
+                    ok: false,
+                    status: 401,
+                    statusText: 'Unauthorized',
+                    json: async () => ({
+                        error: 'invalid_client',
+                        error_description: 'Invalid client credentials',
+                    }),
+                });
+                await expect((0, dynatrace_clients_1.createDtHttpClient)(environmentUrl, scopes, clientId, clientSecret)).rejects.toThrow('Failed to retrieve OAuth token');
+                expect(console.error).toHaveBeenCalledWith('Failed to fetch token: 401 Unauthorized');
+            });
+            it('should throw error when token response contains error', async () => {
+                const mockErrorResponse = {
+                    error: 'invalid_scope',
+                    error_description: 'The requested scope is invalid',
+                    issueId: 'issue-123',
+                };
+                mockFetch.mockResolvedValueOnce({
+                    ok: true,
+                    json: async () => mockErrorResponse,
+                });
+                await expect((0, dynatrace_clients_1.createDtHttpClient)(environmentUrl, scopes, clientId, clientSecret)).rejects.toThrow('Failed to retrieve OAuth token (IssueId: issue-123): invalid_scope - The requested scope is invalid');
+            });
+            it('should throw error when token response is missing access_token', async () => {
+                const mockIncompleteResponse = {
+                    token_type: 'Bearer',
+                    expires_in: 3600,
+                };
+                mockFetch.mockResolvedValueOnce({
+                    ok: true,
+                    json: async () => mockIncompleteResponse,
+                });
+                await expect((0, dynatrace_clients_1.createDtHttpClient)(environmentUrl, scopes, clientId, clientSecret)).rejects.toThrow('Failed to retrieve OAuth token');
+            });
+            it('should log authentication details', async () => {
+                const mockTokenResponse = {
+                    access_token: 'test-access-token',
+                    token_type: 'Bearer',
+                    expires_in: 3600,
+                };
+                mockFetch.mockResolvedValueOnce({
+                    ok: true,
+                    json: async () => mockTokenResponse,
+                });
+                await (0, dynatrace_clients_1.createDtHttpClient)(environmentUrl, scopes, clientId, clientSecret);
+                expect(console.error).toHaveBeenCalledWith(`Trying to authenticate API Calls to ${environmentUrl} via OAuthClientId ${clientId} with the following scopes: ${scopes.join(', ')}`);
+            });
+        });
+        describe('with Bearer token', () => {
+            const dtPlatformToken = 'test-platform-token';
+            it('should create Bearer token client successfully', async () => {
+                const result = await (0, dynatrace_clients_1.createDtHttpClient)(environmentUrl, scopes, undefined, undefined, dtPlatformToken);
+                expect(mockPlatformHttpClient).toHaveBeenCalledWith({
+                    baseUrl: environmentUrl,
+                    defaultHeaders: {
+                        'Authorization': `Bearer ${dtPlatformToken}`,
+                        'User-Agent': 'dynatrace-mcp-server/v1.0.0-test (linux-x64)',
+                    },
+                });
+                expect(result).toBeInstanceOf(http_client_1.PlatformHttpClient);
+            });
+        });
+        describe('with no authentication', () => {
+            it('should throw error when no authentication method is provided', async () => {
+                await expect((0, dynatrace_clients_1.createDtHttpClient)(environmentUrl, scopes)).rejects.toThrow('Failed to create Dynatrace HTTP Client: Please provide either clientId and clientSecret or dtPlatformToken');
+            });
+        });
+    });
+    describe('requestToken function (indirectly tested)', () => {
+        it('should handle fetch errors gracefully', async () => {
+            mockGetSSOUrl.mockResolvedValue('https://sso.dynatrace.com');
+            // Mock fetch to throw an error
+            mockFetch.mockRejectedValueOnce(new Error('Network error'));
+            await expect((0, dynatrace_clients_1.createDtHttpClient)('https://test.apps.dynatrace.com', ['scope1'], 'client-id', 'client-secret')).rejects.toThrow('Network error');
+        });
+        it('should format request body correctly', async () => {
+            mockGetSSOUrl.mockResolvedValue('https://sso.dynatrace.com');
+            const mockTokenResponse = {
+                access_token: 'test-token',
+            };
+            mockFetch.mockResolvedValueOnce({
+                ok: true,
+                json: async () => mockTokenResponse,
+            });
+            await (0, dynatrace_clients_1.createDtHttpClient)('https://test.apps.dynatrace.com', ['scope1', 'scope2'], 'test-client', 'test-secret');
+            const expectedBody = new URLSearchParams({
+                grant_type: 'client_credentials',
+                client_id: 'test-client',
+                client_secret: 'test-secret',
+                scope: 'scope1 scope2',
+            });
+            expect(mockFetch).toHaveBeenCalledWith(expect.any(String), expect.objectContaining({
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/x-www-form-urlencoded',
+                },
+                body: expectedBody,
+            }));
+        });
+    });
+    describe('User-Agent header', () => {
+        it('should include correct User-Agent format', async () => {
+            const dtPlatformToken = 'test-token';
+            await (0, dynatrace_clients_1.createDtHttpClient)('https://test.apps.dynatrace.com', ['scope1'], undefined, undefined, dtPlatformToken);
+            expect(mockPlatformHttpClient).toHaveBeenCalledWith(expect.objectContaining({
+                defaultHeaders: expect.objectContaining({
+                    'User-Agent': expect.stringMatching(/^dynatrace-mcp-server\/v\d+\.\d+\.\d+(-\w+)? \(\w+-\w+\)$/),
+                }),
+            }));
+        });
+    });
+});

package/dist/capabilities/davis-copilot.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.chatWithDavisCopilot = exports.explainDqlInNaturalLanguage = exports.generateDqlFromNaturalLanguage = void 0;
+// API Functions
+/**
+ * Generate DQL from natural language
+ * Converts plain English descriptions into powerful Dynatrace Query Language (DQL) statements.
+ * DQL is the most powerful way to query any data in Dynatrace, including problem events,
+ * 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),
+    });
+    return await response.body('json');
+};
+exports.generateDqlFromNaturalLanguage = generateDqlFromNaturalLanguage;
+/**
+ * Explain DQL in natural language
+ * Provides plain English explanations of complex DQL queries.
+ * Helps users understand what powerful DQL statements do, including
+ * 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
+    });
+    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',
+        },
+        body: JSON.stringify(request),
+    });
+    return await response.body('json');
+};
+exports.chatWithDavisCopilot = chatWithDavisCopilot;

package/dist/capabilities/execute-dql.js

@@ -12,13 +12,17 @@ const verifyDqlStatement = async (dtClient, dqlStatement) => {
     return response;
 };
 exports.verifyDqlStatement = verifyDqlStatement;
-const executeDql = async (dtClient, dqlStatement) => {
+/**
+ * Execute a DQL statement against the Dynatrace API.
+ * If the result is immediately available, it will be returned.
+ * 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
+ * @returns the result without metadata and without notifications, or undefined if the query failed or no result was returned.
+ */
+const executeDql = async (dtClient, body) => {
     const queryExecutionClient = new client_query_1.QueryExecutionClient(dtClient);
-    const response = await queryExecutionClient.queryExecute({
-        body: {
-            query: dqlStatement,
-        },
-    });
+    const response = await queryExecutionClient.queryExecute({ body });
     if (response.result) {
         // return response result immediately
         return response.result.records;

package/dist/capabilities/find-monitored-entity-by-name.js

@@ -8,7 +8,7 @@ const findMonitoredEntityByName = async (dtClient, entityName) => {
                 | append [fetch dt.entity.host | search "*${entityName}*" | fieldsAdd entity.type]
                 | append [fetch dt.entity.process_group | search "*${entityName}*" | fieldsAdd entity.type]
                 | append [fetch dt.entity.cloud_application | search "*${entityName}*" | fieldsAdd entity.type]`;
-    const dqlResponse = await (0, execute_dql_1.executeDql)(dtClient, dql);
+    const dqlResponse = await (0, execute_dql_1.executeDql)(dtClient, { query: dql });
     if (dqlResponse && dqlResponse.length > 0) {
         let resp = 'The following monitored entities were found:\n';
         // iterate over dqlResponse and create a string with the entity names

package/dist/capabilities/get-events-for-cluster.js

@@ -8,6 +8,6 @@ const getEventsForCluster = async (dtClient, clusterId) => {
         // if no clusterId is provided, we need to fetch all events
         dql = `fetch events | filter isNotNull(k8s.cluster.uid)`;
     }
-    return (0, execute_dql_1.executeDql)(dtClient, dql);
+    return (0, execute_dql_1.executeDql)(dtClient, { query: dql });
 };
 exports.getEventsForCluster = getEventsForCluster;

package/dist/capabilities/get-logs-for-entity.js

@@ -4,6 +4,6 @@ exports.getLogsForEntity = void 0;
 const execute_dql_1 = require("./execute-dql");
 const getLogsForEntity = async (dtClient, entityId) => {
     const dql = `fetch logs | filter dt.source_entity == "${entityId}"`;
-    return (0, execute_dql_1.executeDql)(dtClient, dql);
+    return (0, execute_dql_1.executeDql)(dtClient, { query: dql });
 };
 exports.getLogsForEntity = getLogsForEntity;

package/dist/capabilities/list-problems.js

@@ -1,15 +1,28 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.listProblems = void 0;
-const client_classic_environment_v2_1 = require("@dynatrace-sdk/client-classic-environment-v2");
-const listProblems = async (dtClient) => {
-    const problemsClient = new client_classic_environment_v2_1.ProblemsClient(dtClient);
-    const securityProblems = await problemsClient.getProblems({
-        pageSize: 100,
-    });
-    const problems = securityProblems.problems?.map((problem) => {
-        return `${problem.displayId} (please refer to this problem with \`problemId\` ${problem.problemId}): ${problem.title}`;
-    });
-    return problems;
+const execute_dql_1 = require("./execute-dql");
+const listProblems = async (dtClient, additionalFilter) => {
+    // DQL Statement from Problems App to fetch all Davis Problems for the last 12 hours to now
+    const dql = `fetch dt.davis.problems, from: now()-12h, to: now()
+| filter isNull(dt.davis.is_duplicate) OR not(dt.davis.is_duplicate)
+${additionalFilter ? `| filter ${additionalFilter}` : ''}
+| fieldsAdd
+   duration = coalesce(event.end, now()) - event.start,
+   affected_entities_count = arraySize(affected_entity_ids),
+   event_count = arraySize(dt.davis.event_ids),
+   affected_users_count = dt.davis.affected_users_count,
+   problem_id = event.id
+| fields display_id, event.name, event.description, event.status, event.category, event.start, event.end,
+         root_cause_entity_id, root_cause_entity_name, duration, affected_entities_count,
+         event_count, affected_users_count, problem_id, dt.davis.mute.status, dt.davis.mute.user,
+         entity_tags, labels.alerting_profile, maintenance.is_under_maintenance,
+         aws.account.id, azure.resource.group, azure.subscription, cloud.provider, cloud.region,
+         dt.cost.costcenter, dt.cost.product, dt.host_group.id, dt.security_context, gcp.project.id,
+         host.name,
+         k8s.cluster.name, k8s.cluster.uid, k8s.container.name, k8s.namespace.name, k8s.node.name, k8s.pod.name, k8s.service.name, k8s.workload.kind, k8s.workload.name
+| sort event.status asc, event.start desc
+`;
+    return await (0, execute_dql_1.executeDql)(dtClient, { query: dql, maxResultRecords: 5000, maxResultBytes: /* 5 MB */ 5000000 });
 };
 exports.listProblems = listProblems;

package/dist/getDynatraceEnv.js

@@ -6,12 +6,16 @@ exports.getDynatraceEnv = getDynatraceEnv;
  * Throws an Error if validation fails.
  */
 function getDynatraceEnv(env = process.env) {
-    const oauthClient = env.OAUTH_CLIENT_ID;
+    const oauthClientId = env.OAUTH_CLIENT_ID;
     const oauthClientSecret = env.OAUTH_CLIENT_SECRET;
+    const dtPlatformToken = env.DT_PLATFORM_TOKEN;
     const dtEnvironment = env.DT_ENVIRONMENT;
     const slackConnectionId = env.SLACK_CONNECTION_ID || 'fake-slack-connection-id';
-    if (!oauthClient || !oauthClientSecret || !dtEnvironment) {
-        throw new Error('Please set OAUTH_CLIENT_ID and OAUTH_CLIENT_SECRET and DT_ENVIRONMENT environment variables');
+    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');
     }
     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)');
@@ -19,5 +23,5 @@ function getDynatraceEnv(env = process.env) {
     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 { oauthClient, oauthClientSecret, dtEnvironment, slackConnectionId };
+    return { oauthClientId, oauthClientSecret, dtPlatformToken, dtEnvironment, slackConnectionId };
 }

package/dist/getDynatraceEnv.test.js

@@ -6,15 +6,17 @@ describe('getDynatraceEnv', () => {
         OAUTH_CLIENT_ID: 'dt0s02.SAMPLE',
         OAUTH_CLIENT_SECRET: 'dt0s02.SAMPLE.abcd1234',
         DT_ENVIRONMENT: 'https://abc123.apps.dynatrace.com',
+        DT_PLATFORM_TOKEN: 'dt0s16.SAMPLE.abcd1234',
         SLACK_CONNECTION_ID: 'slack-conn-id',
     };
     it('returns all required values when environment is valid', () => {
         const env = { ...baseEnv };
         const result = (0, getDynatraceEnv_1.getDynatraceEnv)(env);
         expect(result).toEqual({
-            oauthClient: env.OAUTH_CLIENT_ID,
+            oauthClientId: env.OAUTH_CLIENT_ID,
             oauthClientSecret: env.OAUTH_CLIENT_SECRET,
             dtEnvironment: env.DT_ENVIRONMENT,
+            dtPlatformToken: env.DT_PLATFORM_TOKEN,
             slackConnectionId: env.SLACK_CONNECTION_ID,
         });
     });
@@ -23,14 +25,15 @@ describe('getDynatraceEnv', () => {
         const result = (0, getDynatraceEnv_1.getDynatraceEnv)(env);
         expect(result.slackConnectionId).toBe('fake-slack-connection-id');
     });
-    it('throws if OAUTH_CLIENT_ID is missing', () => {
-        const env = { ...baseEnv, OAUTH_CLIENT_ID: undefined };
+    it('throws if environment variables for auth credentials are missing', () => {
+        const env = {
+            ...baseEnv,
+            OAUTH_CLIENT_ID: undefined,
+            OAUTH_CLIENT_SECRET: undefined,
+            DT_PLATFORM_TOKEN: undefined,
+        };
         expect(() => (0, getDynatraceEnv_1.getDynatraceEnv)(env)).toThrow(/OAUTH_CLIENT_ID/);
     });
-    it('throws if OAUTH_CLIENT_SECRET is missing', () => {
-        const env = { ...baseEnv, OAUTH_CLIENT_SECRET: undefined };
-        expect(() => (0, getDynatraceEnv_1.getDynatraceEnv)(env)).toThrow(/OAUTH_CLIENT_SECRET/);
-    });
     it('throws if DT_ENVIRONMENT is missing', () => {
         const env = { ...baseEnv, DT_ENVIRONMENT: undefined };
         expect(() => (0, getDynatraceEnv_1.getDynatraceEnv)(env)).toThrow(/DT_ENVIRONMENT/);

package/dist/index.js

@@ -11,7 +11,6 @@ const package_json_1 = require("../package.json");
 const dynatrace_clients_1 = require("./authentication/dynatrace-clients");
 const list_vulnerabilities_1 = require("./capabilities/list-vulnerabilities");
 const list_problems_1 = require("./capabilities/list-problems");
-const get_problem_details_1 = require("./capabilities/get-problem-details");
 const get_monitored_entity_details_1 = require("./capabilities/get-monitored-entity-details");
 const get_ownership_information_1 = require("./capabilities/get-ownership-information");
 const get_logs_for_entity_1 = require("./capabilities/get-logs-for-entity");
@@ -22,6 +21,7 @@ const get_vulnerability_details_1 = require("./capabilities/get-vulnerability-de
 const execute_dql_1 = require("./capabilities/execute-dql");
 const send_slack_message_1 = require("./capabilities/send-slack-message");
 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");
 (0, dotenv_1.config)();
 let scopesBase = [
@@ -38,7 +38,8 @@ const main = async () => {
         console.error(err.message);
         process.exit(1);
     }
-    const { oauthClient, oauthClientSecret, dtEnvironment, slackConnectionId } = dynatraceEnv;
+    console.error(`Initializing Dynatrace MCP Server v${package_json_1.version}...`);
+    const { oauthClientId, oauthClientSecret, dtEnvironment, dtPlatformToken, slackConnectionId } = dynatraceEnv;
     console.error(`Starting Dynatrace MCP Server v${package_json_1.version}...`);
     const server = new mcp_js_1.McpServer({
         name: 'Dynatrace MCP Server',
@@ -88,7 +89,7 @@ const main = async () => {
     };
     tool('get_environment_info', 'Get information about the connected Dynatrace Environment (Tenant)', {}, async ({}) => {
         // create an oauth-client
-        const dtClient = await (0, dynatrace_clients_1.createOAuthClient)(oauthClient, oauthClientSecret, dtEnvironment, scopesBase);
+        const dtClient = await (0, dynatrace_clients_1.createDtHttpClient)(dtEnvironment, scopesBase, oauthClientId, oauthClientSecret, dtPlatformToken);
         const environmentInformationClient = new client_platform_management_service_1.EnvironmentInformationClient(dtClient);
         const environmentInfo = await environmentInformationClient.getEnvironmentInformation();
         let resp = `Environment Information (also referred to as tenant):
@@ -97,7 +98,7 @@ const main = async () => {
         return resp;
     });
     tool('list_vulnerabilities', 'List all vulnerabilities from Dynatrace', {}, async ({}) => {
-        const dtClient = await (0, dynatrace_clients_1.createOAuthClient)(oauthClient, oauthClientSecret, dtEnvironment, scopesBase.concat('environment-api:security-problems:read'));
+        const dtClient = await (0, dynatrace_clients_1.createDtHttpClient)(dtEnvironment, scopesBase.concat('environment-api:security-problems:read'), oauthClientId, oauthClientSecret, dtPlatformToken);
         const result = await (0, list_vulnerabilities_1.listVulnerabilities)(dtClient);
         if (!result || result.length === 0) {
             return 'No vulnerabilities found';
@@ -112,7 +113,7 @@ const main = async () => {
     tool('get_vulnerabilty_details', 'Get details of a vulnerability by `securityProblemId` on Dynatrace', {
         securityProblemId: zod_1.z.string().optional(),
     }, async ({ securityProblemId }) => {
-        const dtClient = await (0, dynatrace_clients_1.createOAuthClient)(oauthClient, oauthClientSecret, dtEnvironment, scopesBase.concat('environment-api:security-problems:read'));
+        const dtClient = await (0, dynatrace_clients_1.createDtHttpClient)(dtEnvironment, scopesBase.concat('environment-api:security-problems:read'), oauthClientId, oauthClientSecret, dtPlatformToken);
         const result = await (0, get_vulnerability_details_1.getVulnerabilityDetails)(dtClient, securityProblemId);
         let resp = `The Security Problem (Vulnerability) ${result.displayId} with securityProblemId ${result.securityProblemId} has the title ${result.title}.\n`;
         resp += `The related CVEs are ${result.cveIds?.join(',') || 'unknown'}.\n`;
@@ -157,49 +158,55 @@ const main = async () => {
         resp += `Tell the user to access the link ${dtEnvironment}/ui/apps/dynatrace.security.vulnerabilities/vulnerabilities/${result.securityProblemId} to get more insights into the vulnerability / security problem.\n`;
         return resp;
     });
-    tool('list_problems', 'List all problems known on Dynatrace', {}, async ({}) => {
-        const dtClient = await (0, dynatrace_clients_1.createOAuthClient)(oauthClient, oauthClientSecret, dtEnvironment, scopesBase.concat('environment-api:problems:read'));
-        const result = await (0, list_problems_1.listProblems)(dtClient);
-        if (!result || result.length === 0) {
-            return 'No problems found';
-        }
-        return `Found these problems: ${result.join(',')}`;
-    });
-    tool('get_problem_details', 'Get details of a problem on Dynatrace', {
-        problemId: zod_1.z.string().optional(),
-    }, async ({ problemId }) => {
-        const dtClient = await (0, dynatrace_clients_1.createOAuthClient)(oauthClient, oauthClientSecret, dtEnvironment, scopesBase.concat('environment-api:problems:read'));
-        const result = await (0, get_problem_details_1.getProblemDetails)(dtClient, problemId);
-        let resp = `The problem ${result.displayId} with the title ${result.title} (ID: ${result.problemId}).` +
-            `The severity is ${result.severityLevel}, and it affects ${result.affectedEntities.length} entities:`;
-        for (const entity of result.affectedEntities) {
-            resp += `\n- ${entity.name} (please refer to this entity with \`entityId\` ${entity.entityId?.id})`;
-        }
-        resp += `The problem first appeared at ${result.startTime}\n`;
-        if (result.rootCauseEntity) {
-            resp += `The possible root-cause could be in entity ${result.rootCauseEntity?.name} with \`entityId\` ${result.rootCauseEntity?.entityId?.id}.\n`;
-        }
-        if (result.impactAnalysis) {
-            let estimatedAffectedUsers = 0;
-            result.impactAnalysis.impacts.forEach((impact) => {
-                estimatedAffectedUsers += impact.estimatedAffectedUsers;
+    tool('list_problems', 'List all problems (dt.davis.problems) known on Dynatrace, sorted by their recency, for the last 12h. An additional filter can be provided using DQL filter.', {
+        additionalFilter: zod_1.z
+            .string()
+            .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.'),
+    }, 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)
+        const result = await (0, list_problems_1.listProblems)(dtClient, additionalFilter);
+        if (result && result.length > 0) {
+            let resp = `Found ${result.length} problems! Displaying the top ${maxProblemsToDisplay} problems:\n`;
+            // iterate over dqlResponse and create a string with the problem details, but only show the top maxProblemsToDisplay problems
+            result.slice(0, maxProblemsToDisplay).forEach((problem) => {
+                if (problem) {
+                    resp += `Problem ${problem['display_id']} (please refer to this problem with \`problemId\` or \`event.id\` ${problem['problem_id']}))
+                  with event.status ${problem['event.status']}, event.category ${problem['event.category']}: ${problem['event.name']} -
+                  affects ${problem['affected_users_count']} users and ${problem['affected_entity_count']} entities for a duration of ${problem['duration']}\n`;
+                }
             });
-            resp += `The problem is estimated to affect ${estimatedAffectedUsers} users.\n`;
+            resp +=
+                `\nNext Steps:` +
+                    `\n1. Use "execute_dql" tool with the following query to get more details about a specific problem:
+          "fetch dt.davis.problems, from: now()-10h, to: now() | filter event.id == \"<problem-id>\" | fields event.description, event.status, event.category, event.start, event.end,
+            root_cause_entity_id, root_cause_entity_name, duration, affected_entities_count,
+            event_count, affected_users_count, problem_id, dt.davis.mute.status, dt.davis.mute.user,
+            entity_tags, labels.alerting_profile, maintenance.is_under_maintenance,
+            aws.account.id, azure.resource.group, azure.subscription, cloud.provider, cloud.region,
+            dt.cost.costcenter, dt.cost.product, dt.host_group.id, dt.security_context, gcp.project.id,
+            host.name, k8s.cluster.name, k8s.cluster.uid, k8s.container.name, k8s.namespace.name, k8s.node.name, k8s.pod.name, k8s.service.name, k8s.workload.kind, k8s.workload.name"` +
+                    `\n2. Use "chat_with_davis_copilot" tool and provide \`problemId\` as context, to get insights about a specific problem via Davis Copilot.` +
+                    `\n3. Tell the user to visit ${dtEnvironment}/ui/apps/dynatrace.davis.problems/problem/<problem-id> for more details.`;
+            return resp;
+        }
+        else {
+            return 'No problems found';
         }
-        resp += `Tell the user to access the link ${dtEnvironment}/ui/apps/dynatrace.davis.problems/problem/${result.problemId} to get more insights into the problem.\n`;
-        return resp;
     });
     tool('find_entity_by_name', 'Get the entityId of a monitored entity based on the name of the entity on Dynatrace', {
         entityName: zod_1.z.string(),
     }, async ({ entityName }) => {
-        const dtClient = await (0, dynatrace_clients_1.createOAuthClient)(oauthClient, oauthClientSecret, dtEnvironment, scopesBase.concat('environment-api:entities:read', 'storage:entities:read'));
+        const dtClient = await (0, dynatrace_clients_1.createDtHttpClient)(dtEnvironment, scopesBase.concat('environment-api:entities:read', 'storage:entities:read'), oauthClientId, oauthClientSecret, dtPlatformToken);
         const entityResponse = await (0, find_monitored_entity_by_name_1.findMonitoredEntityByName)(dtClient, entityName);
         return entityResponse;
     });
     tool('get_entity_details', 'Get details of a monitored entity based on the entityId on Dynatrace', {
         entityId: zod_1.z.string().optional(),
     }, async ({ entityId }) => {
-        const dtClient = await (0, dynatrace_clients_1.createOAuthClient)(oauthClient, oauthClientSecret, dtEnvironment, scopesBase.concat('environment-api:entities:read'));
+        const dtClient = await (0, dynatrace_clients_1.createDtHttpClient)(dtEnvironment, scopesBase.concat('environment-api:entities:read'), oauthClientId, oauthClientSecret, dtPlatformToken);
         const entityDetails = await (0, get_monitored_entity_details_1.getMonitoredEntityDetails)(dtClient, entityId);
         let resp = `Entity ${entityDetails.displayName} of type ${entityDetails.type} with \`entityId\` ${entityDetails.entityId}\n` +
             `Properties: ${JSON.stringify(entityDetails.properties)}\n`;
@@ -221,21 +228,21 @@ const main = async () => {
         channel: zod_1.z.string().optional(),
         message: zod_1.z.string().optional(),
     }, async ({ channel, message }) => {
-        const dtClient = await (0, dynatrace_clients_1.createOAuthClient)(oauthClient, oauthClientSecret, dtEnvironment, scopesBase.concat('app-settings:objects:read'));
+        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);
         return `Message sent to Slack channel: ${JSON.stringify(response)}`;
     });
     tool('get_logs_for_entity', 'Get Logs for a monitored entity based on name of the entity on Dynatrace', {
         entityName: zod_1.z.string().optional(),
     }, async ({ entityName }) => {
-        const dtClient = await (0, dynatrace_clients_1.createOAuthClient)(oauthClient, oauthClientSecret, dtEnvironment, scopesBase.concat('storage:logs:read'));
+        const dtClient = await (0, dynatrace_clients_1.createDtHttpClient)(dtEnvironment, scopesBase.concat('storage:logs:read'), oauthClientId, oauthClientSecret, dtPlatformToken);
         const logs = await (0, get_logs_for_entity_1.getLogsForEntity)(dtClient, entityName);
         return `Logs:\n${JSON.stringify(logs?.map((logLine) => (logLine ? logLine.content : 'Empty log')))}`;
     });
     tool('verify_dql', 'Verify a Dynatrace Query Language (DQL) statement on Dynatrace GRAIL before executing it. This is useful to ensure that the DQL statement is valid and can be executed without errors.', {
         dqlStatement: zod_1.z.string(),
     }, async ({ dqlStatement }) => {
-        const dtClient = await (0, dynatrace_clients_1.createOAuthClient)(oauthClient, oauthClientSecret, dtEnvironment, scopesBase);
+        const dtClient = await (0, dynatrace_clients_1.createDtHttpClient)(dtEnvironment, scopesBase, oauthClientId, oauthClientSecret, dtPlatformToken);
         const response = await (0, execute_dql_1.verifyDqlStatement)(dtClient, dqlStatement);
         let resp = 'DQL Statement Verification:\n';
         if (response.notifications && response.notifications.length > 0) {
@@ -255,7 +262,7 @@ const main = async () => {
     tool('execute_dql', 'Get Logs, Metrics, Spans or Events from Dynatrace GRAIL by executing a Dynatrace Query Language (DQL) statement. Always use "verify_dql" tool before you execute a DQL statement. A valid statement looks like this: "fetch [logs, metrics, spans, events] | filter <some-filter> | summarize count(), by:{some-fields}. Adapt filters for certain attributes: `traceId` could be `trace_id` or `trace.id`.', {
         dqlStatement: zod_1.z.string(),
     }, async ({ dqlStatement }) => {
-        const dtClient = await (0, dynatrace_clients_1.createOAuthClient)(oauthClient, oauthClientSecret, dtEnvironment, scopesBase.concat('storage:buckets:read', // Read all system data stored on Grail
+        const dtClient = await (0, dynatrace_clients_1.createDtHttpClient)(dtEnvironment, scopesBase.concat('storage:buckets:read', // Read all system data stored on Grail
         'storage:logs:read', // Read logs for reliability guardian validations
         'storage:metrics:read', // Read metrics for reliability guardian validations
         'storage:bizevents:read', // Read bizevents for reliability guardian validations
@@ -265,17 +272,102 @@ const main = async () => {
         'storage:system:read', // Read System Data from Grail
         'storage:user.events:read', // Read User events from Grail
         'storage:user.sessions:read', // Read User sessions from Grail
-        'storage:security.events:read'));
-        const response = await (0, execute_dql_1.executeDql)(dtClient, dqlStatement);
+        'storage:security.events:read'), oauthClientId, oauthClientSecret, dtPlatformToken);
+        const response = await (0, execute_dql_1.executeDql)(dtClient, { query: dqlStatement });
         return `DQL Response: ${JSON.stringify(response)}`;
     });
+    tool('generate_dql_from_natural_language', "Convert natural language queries to Dynatrace Query Language (DQL) using Davis CoPilot AI. You can ask for problem events, security issues, logs, metrics, spans, and custom data. Workflow: 1) Generate DQL, 2) Verify with verify_dql tool, 3) Execute with execute_dql tool, 4) Iterate if results don't match expectations.", {
+        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.'),
+    }, 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);
+        let resp = `🔤 Natural Language to DQL:\n\n`;
+        resp += `**Query:** "${text}"\n\n`;
+        resp += `**Generated DQL:**\n\`\`\`\n${response.dql}\n\`\`\`\n\n`;
+        resp += `**Status:** ${response.status}\n`;
+        resp += `**Message Token:** ${response.messageToken}\n`;
+        if (response.metadata?.notifications && response.metadata.notifications.length > 0) {
+            resp += `\n**Notifications:**\n`;
+            response.metadata.notifications.forEach((notification) => {
+                resp += `- ${notification.severity}: ${notification.message}\n`;
+            });
+        }
+        resp += `\n💡 **Next Steps:**\n`;
+        resp += `1. Use "verify_dql" tool to validate this query\n`;
+        resp += `2. Use "execute_dql" tool to run the query\n`;
+        resp += `3. If results don't match expectations, refine your natural language description and try again\n`;
+        return resp;
+    });
+    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'),
+    }, 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);
+        let resp = `📝 DQL to Natural Language:\n\n`;
+        resp += `**DQL Query:**\n\`\`\`\n${dql}\n\`\`\`\n\n`;
+        resp += `**Summary:** ${response.summary}\n\n`;
+        resp += `**Detailed Explanation:**\n${response.explanation}\n\n`;
+        resp += `**Status:** ${response.status}\n`;
+        resp += `**Message Token:** ${response.messageToken}\n`;
+        if (response.metadata?.notifications && response.metadata.notifications.length > 0) {
+            resp += `\n**Notifications:**\n`;
+            response.metadata.notifications.forEach((notification) => {
+                resp += `- ${notification.severity}: ${notification.message}\n`;
+            });
+        }
+        return resp;
+    });
+    tool('chat_with_davis_copilot', 'Use this tool in case no specific tool is available. Get an answer to any Dynatrace related question as well as troubleshooting, and guidance. *(Note: Davis CoPilot AI is GA, but the Davis CoPilot APIs are in preview)*', {
+        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'),
+    }, async ({ text, context, instruction }) => {
+        const dtClient = await (0, dynatrace_clients_1.createDtHttpClient)(dtEnvironment, scopesBase.concat('davis-copilot:conversations:execute'), oauthClientId, oauthClientSecret, dtPlatformToken);
+        const conversationContext = [];
+        if (context) {
+            conversationContext.push({
+                type: 'supplementary',
+                value: context,
+            });
+        }
+        if (instruction) {
+            conversationContext.push({
+                type: 'instruction',
+                value: instruction,
+            });
+        }
+        const response = await (0, davis_copilot_1.chatWithDavisCopilot)(dtClient, text, conversationContext);
+        let resp = `🤖 Davis CoPilot Response:\n\n`;
+        resp += `**Your Question:** "${text}"\n\n`;
+        resp += `**Answer:**\n${response.text}\n\n`;
+        resp += `**Status:** ${response.status}\n`;
+        resp += `**Message Token:** ${response.messageToken}\n`;
+        if (response.metadata?.sources && response.metadata.sources.length > 0) {
+            resp += `\n**Sources:**\n`;
+            response.metadata.sources.forEach((source) => {
+                resp += `- ${source.title || 'Untitled'}: ${source.url || 'No URL'}\n`;
+            });
+        }
+        if (response.metadata?.notifications && response.metadata.notifications.length > 0) {
+            resp += `\n**Notifications:**\n`;
+            response.metadata.notifications.forEach((notification) => {
+                resp += `- ${notification.severity}: ${notification.message}\n`;
+            });
+        }
+        if (response.state?.conversationId) {
+            resp += `\n**Conversation ID:** ${response.state.conversationId}`;
+        }
+        return resp;
+    });
     tool('create_workflow_for_notification', 'Create a notification for a team based on a problem type within Workflows in Dynatrace', {
         problemType: zod_1.z.string().optional(),
         teamName: zod_1.z.string().optional(),
         channel: zod_1.z.string().optional(),
         isPrivate: zod_1.z.boolean().optional().default(false),
     }, async ({ problemType, teamName, channel, isPrivate }) => {
-        const dtClient = await (0, dynatrace_clients_1.createOAuthClient)(oauthClient, oauthClientSecret, dtEnvironment, scopesBase.concat('automation:workflows:write', 'automation:workflows:read', 'automation:workflows:run'));
+        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);
         let resp = `Workflow Created: ${response?.id} with name ${response?.title}.\nYou can access the Workflow via the following link: ${dtEnvironment}/ui/apps/dynatrace.automations/workflows/${response?.id}.\nTell the user to inspect the Workflow by visiting the link.\n`;
         if (response.type == 'SIMPLE') {
@@ -292,7 +384,7 @@ 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(),
     }, async ({ workflowId }) => {
-        const dtClient = await (0, dynatrace_clients_1.createOAuthClient)(oauthClient, oauthClientSecret, dtEnvironment, scopesBase.concat('automation:workflows:write', 'automation:workflows:read', 'automation:workflows:run'));
+        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, {
             isPrivate: false,
         });
@@ -304,14 +396,14 @@ const main = async () => {
             .optional()
             .describe(`The Kubernetes (K8s) Cluster Id, referred to as k8s.cluster.uid (this is NOT the Dynatrace environment)`),
     }, async ({ clusterId }) => {
-        const dtClient = await (0, dynatrace_clients_1.createOAuthClient)(oauthClient, oauthClientSecret, dtEnvironment, scopesBase.concat('storage:events:read'));
+        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);
         return `Kubernetes Events:\n${JSON.stringify(events)}`;
     });
     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'),
     }, async ({ entityIds }) => {
-        const dtClient = await (0, dynatrace_clients_1.createOAuthClient)(oauthClient, oauthClientSecret, dtEnvironment, scopesBase.concat('environment-api:entities:read', 'settings:objects:read'));
+        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}`);
         const ownershipInformation = await (0, get_ownership_information_1.getOwnershipInformation)(dtClient, entityIds);
         console.error(`Done!`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dynatrace-oss/dynatrace-mcp-server",
-  "version": "0.4.0",
+  "version": "0.5.0-rc.2",
   "description": "Model Context Protocol (MCP) server for Dynatrace",
   "keywords": [
     "Dynatrace",
@@ -38,6 +38,8 @@
     "prepare": "npm run build",
     "watch": "tsc --watch",
     "test": "jest",
+    "test:unit": "jest --selectProjects unit",
+    "test:integration": "jest --selectProjects integration --runInBand",
     "prettier": "prettier --check .",
     "prettier:fix": "prettier --write ."
   },