mongodb-mcp-server 0.1.0 → 0.1.2

package/src/tools/atlas/create/createDBUser.ts

@@ -3,6 +3,7 @@ import { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
 import { AtlasToolBase } from "../atlasTool.js";
 import { ToolArgs, OperationType } from "../../tool.js";
 import { CloudDatabaseUser, DatabaseUserRole } from "../../../common/atlas/openapi.js";
+import { generateSecurePassword } from "../../../common/atlas/generatePassword.js";
 
 export class CreateDBUserTool extends AtlasToolBase {
     protected name = "atlas-create-db-user";
@@ -11,7 +12,16 @@ export class CreateDBUserTool extends AtlasToolBase {
     protected argsShape = {
         projectId: z.string().describe("Atlas project ID"),
         username: z.string().describe("Username for the new user"),
-        password: z.string().describe("Password for the new user"),
+        // Models will generate overly simplistic passwords like SecurePassword123 or
+        // AtlasPassword123, which are easily guessable and exploitable. We're instructing
+        // the model not to try and generate anything and instead leave the field unset.
+        password: z
+            .string()
+            .optional()
+            .nullable()
+            .describe(
+                "Password for the new user. If the user hasn't supplied an explicit password, leave it unset and under no circumstances try to generate a random one. A secure password will be generated by the MCP server if necessary."
+            ),
         roles: z
             .array(
                 z.object({
@@ -34,6 +44,11 @@ export class CreateDBUserTool extends AtlasToolBase {
         roles,
         clusters,
     }: ToolArgs<typeof this.argsShape>): Promise<CallToolResult> {
+        const shouldGeneratePassword = !password;
+        if (shouldGeneratePassword) {
+            password = await generateSecurePassword();
+        }
+
         const input = {
             groupId: projectId,
             awsIAMType: "NONE",
@@ -62,7 +77,12 @@ export class CreateDBUserTool extends AtlasToolBase {
         });
 
         return {
-            content: [{ type: "text", text: `User "${username}" created sucessfully.` }],
+            content: [
+                {
+                    type: "text",
+                    text: `User "${username}" created successfully${shouldGeneratePassword ? ` with password: \`${password}\`` : ""}.`,
+                },
+            ],
         };
     }
 }

package/src/tools/atlas/create/createProject.ts

@@ -28,7 +28,13 @@ export class CreateProjectTool extends AtlasToolBase {
                         "No organizations were found in your MongoDB Atlas account. Please create an organization first."
                     );
                 }
-                organizationId = organizations.results[0].id;
+                const firstOrg = organizations.results[0];
+                if (!firstOrg?.id) {
+                    throw new Error(
+                        "The first organization found does not have an ID. Please check your Atlas account."
+                    );
+                }
+                organizationId = firstOrg.id;
                 assumedOrg = true;
             } catch {
                 throw new Error(

package/src/tools/atlas/metadata/connectCluster.ts

@@ -2,24 +2,15 @@ import { z } from "zod";
 import { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
 import { AtlasToolBase } from "../atlasTool.js";
 import { ToolArgs, OperationType } from "../../tool.js";
-import { randomBytes } from "crypto";
-import { promisify } from "util";
+import { generateSecurePassword } from "../../../common/atlas/generatePassword.js";
 import logger, { LogId } from "../../../logger.js";
+import { inspectCluster } from "../../../common/atlas/cluster.js";
 
 const EXPIRY_MS = 1000 * 60 * 60 * 12; // 12 hours
 
-const randomBytesAsync = promisify(randomBytes);
-
-async function generateSecurePassword(): Promise<string> {
-    const buf = await randomBytesAsync(16);
-    const pass = buf.toString("base64url");
-    return pass;
-}
-
 function sleep(ms: number): Promise<void> {
     return new Promise((resolve) => setTimeout(resolve, ms));
 }
-
 export class ConnectClusterTool extends AtlasToolBase {
     protected name = "atlas-connect-cluster";
     protected description = "Connect to MongoDB Atlas cluster";
@@ -32,22 +23,9 @@ export class ConnectClusterTool extends AtlasToolBase {
     protected async execute({ projectId, clusterName }: ToolArgs<typeof this.argsShape>): Promise<CallToolResult> {
         await this.session.disconnect();
 
-        const cluster = await this.session.apiClient.getCluster({
-            params: {
-                path: {
-                    groupId: projectId,
-                    clusterName,
-                },
-            },
-        });
-
-        if (!cluster) {
-            throw new Error("Cluster not found");
-        }
-
-        const baseConnectionString = cluster.connectionStrings?.standardSrv || cluster.connectionStrings?.standard;
+        const cluster = await inspectCluster(this.session.apiClient, projectId, clusterName);
 
-        if (!baseConnectionString) {
+        if (!cluster.connectionString) {
             throw new Error("Connection string not available");
         }
 
@@ -99,7 +77,7 @@ export class ConnectClusterTool extends AtlasToolBase {
             expiryDate,
         };
 
-        const cn = new URL(baseConnectionString);
+        const cn = new URL(cluster.connectionString);
         cn.username = username;
         cn.password = password;
         cn.searchParams.set("authSource", "admin");

package/src/tools/atlas/read/inspectCluster.ts

@@ -2,7 +2,7 @@ import { z } from "zod";
 import { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
 import { AtlasToolBase } from "../atlasTool.js";
 import { ToolArgs, OperationType } from "../../tool.js";
-import { ClusterDescription20240805 } from "../../../common/atlas/openapi.js";
+import { Cluster, inspectCluster } from "../../../common/atlas/cluster.js";
 
 export class InspectClusterTool extends AtlasToolBase {
     protected name = "atlas-inspect-cluster";
@@ -14,55 +14,19 @@ export class InspectClusterTool extends AtlasToolBase {
     };
 
     protected async execute({ projectId, clusterName }: ToolArgs<typeof this.argsShape>): Promise<CallToolResult> {
-        const cluster = await this.session.apiClient.getCluster({
-            params: {
-                path: {
-                    groupId: projectId,
-                    clusterName,
-                },
-            },
-        });
+        const cluster = await inspectCluster(this.session.apiClient, projectId, clusterName);
 
         return this.formatOutput(cluster);
     }
 
-    private formatOutput(cluster?: ClusterDescription20240805): CallToolResult {
-        if (!cluster) {
-            throw new Error("Cluster not found");
-        }
-
-        const regionConfigs = (cluster.replicationSpecs || [])
-            .map(
-                (replicationSpec) =>
-                    (replicationSpec.regionConfigs || []) as {
-                        providerName: string;
-                        electableSpecs?: {
-                            instanceSize: string;
-                        };
-                        readOnlySpecs?: {
-                            instanceSize: string;
-                        };
-                    }[]
-            )
-            .flat()
-            .map((regionConfig) => {
-                return {
-                    providerName: regionConfig.providerName,
-                    instanceSize: regionConfig.electableSpecs?.instanceSize || regionConfig.readOnlySpecs?.instanceSize,
-                };
-            });
-
-        const instanceSize = (regionConfigs.length <= 0 ? undefined : regionConfigs[0].instanceSize) || "UNKNOWN";
-
-        const clusterInstanceType = instanceSize == "M0" ? "FREE" : "DEDICATED";
-
+    private formatOutput(formattedCluster: Cluster): CallToolResult {
         return {
             content: [
                 {
                     type: "text",
                     text: `Cluster Name | Cluster Type | Tier | State | MongoDB Version | Connection String
 ----------------|----------------|----------------|----------------|----------------|----------------
-${cluster.name} | ${clusterInstanceType} | ${clusterInstanceType == "DEDICATED" ? instanceSize : "N/A"} | ${cluster.stateName} | ${cluster.mongoDBVersion || "N/A"} | ${cluster.connectionStrings?.standardSrv || cluster.connectionStrings?.standard || "N/A"}`,
+${formattedCluster.name || "Unknown"} | ${formattedCluster.instanceType} | ${formattedCluster.instanceSize || "N/A"} | ${formattedCluster.state || "UNKNOWN"} | ${formattedCluster.mongoDBVersion || "N/A"} | ${formattedCluster.connectionString || "N/A"}`,
                 },
             ],
         };

package/src/tools/atlas/read/listAlerts.ts

@@ -0,0 +1,45 @@
+import { z } from "zod";
+import { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
+import { AtlasToolBase } from "../atlasTool.js";
+import { ToolArgs, OperationType } from "../../tool.js";
+
+export class ListAlertsTool extends AtlasToolBase {
+    protected name = "atlas-list-alerts";
+    protected description = "List MongoDB Atlas alerts";
+    protected operationType: OperationType = "read";
+    protected argsShape = {
+        projectId: z.string().describe("Atlas project ID to list alerts for"),
+    };
+
+    protected async execute({ projectId }: ToolArgs<typeof this.argsShape>): Promise<CallToolResult> {
+        const data = await this.session.apiClient.listAlerts({
+            params: {
+                path: {
+                    groupId: projectId,
+                },
+            },
+        });
+
+        if (!data?.results?.length) {
+            return { content: [{ type: "text", text: "No alerts found in your MongoDB Atlas project." }] };
+        }
+
+        // Format alerts as a table
+        const output =
+            `Alert ID | Status | Created | Updated | Type | Comment
+----------|---------|----------|----------|------|--------
+` +
+            data.results
+                .map((alert) => {
+                    const created = alert.created ? new Date(alert.created).toLocaleString() : "N/A";
+                    const updated = alert.updated ? new Date(alert.updated).toLocaleString() : "N/A";
+                    const comment = alert.acknowledgementComment ?? "N/A";
+                    return `${alert.id} | ${alert.status} | ${created} | ${updated} | ${alert.eventTypeName} | ${comment}`;
+                })
+                .join("\n");
+
+        return {
+            content: [{ type: "text", text: output }],
+        };
+    }
+}

package/src/tools/atlas/read/listClusters.ts

@@ -2,7 +2,13 @@ import { z } from "zod";
 import { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
 import { AtlasToolBase } from "../atlasTool.js";
 import { ToolArgs, OperationType } from "../../tool.js";
-import { PaginatedClusterDescription20240805, PaginatedOrgGroupView, Group } from "../../../common/atlas/openapi.js";
+import {
+    PaginatedClusterDescription20240805,
+    PaginatedOrgGroupView,
+    Group,
+    PaginatedFlexClusters20241113,
+} from "../../../common/atlas/openapi.js";
+import { formatCluster, formatFlexCluster } from "../../../common/atlas/cluster.js";
 
 export class ListClustersTool extends AtlasToolBase {
     protected name = "atlas-list-clusters";
@@ -73,43 +79,20 @@ ${rows}`,
         };
     }
 
-    private formatClustersTable(project: Group, clusters?: PaginatedClusterDescription20240805): CallToolResult {
-        if (!clusters?.results?.length) {
+    private formatClustersTable(
+        project: Group,
+        clusters?: PaginatedClusterDescription20240805,
+        flexClusters?: PaginatedFlexClusters20241113
+    ): CallToolResult {
+        // Check if both traditional clusters and flex clusters are absent
+        if (!clusters?.results?.length && !flexClusters?.results?.length) {
             throw new Error("No clusters found.");
         }
-        const rows = clusters.results
-            .map((cluster) => {
-                const connectionString =
-                    cluster.connectionStrings?.standardSrv || cluster.connectionStrings?.standard || "N/A";
-                const mongoDBVersion = cluster.mongoDBVersion || "N/A";
-                const regionConfigs = (cluster.replicationSpecs || [])
-                    .map(
-                        (replicationSpec) =>
-                            (replicationSpec.regionConfigs || []) as {
-                                providerName: string;
-                                electableSpecs?: {
-                                    instanceSize: string;
-                                };
-                                readOnlySpecs?: {
-                                    instanceSize: string;
-                                };
-                            }[]
-                    )
-                    .flat()
-                    .map((regionConfig) => {
-                        return {
-                            providerName: regionConfig.providerName,
-                            instanceSize:
-                                regionConfig.electableSpecs?.instanceSize || regionConfig.readOnlySpecs?.instanceSize,
-                        };
-                    });
-
-                const instanceSize =
-                    (regionConfigs.length <= 0 ? undefined : regionConfigs[0].instanceSize) || "UNKNOWN";
-
-                const clusterInstanceType = instanceSize == "M0" ? "FREE" : "DEDICATED";
-
-                return `${cluster.name} | ${clusterInstanceType} | ${clusterInstanceType == "DEDICATED" ? instanceSize : "N/A"} | ${cluster.stateName} | ${mongoDBVersion} | ${connectionString}`;
+        const formattedClusters = clusters?.results?.map((cluster) => formatCluster(cluster)) || [];
+        const formattedFlexClusters = flexClusters?.results?.map((cluster) => formatFlexCluster(cluster)) || [];
+        const rows = [...formattedClusters, ...formattedFlexClusters]
+            .map((formattedCluster) => {
+                return `${formattedCluster.name || "Unknown"} | ${formattedCluster.instanceType} | ${formattedCluster.instanceSize || "N/A"} | ${formattedCluster.state || "UNKNOWN"} | ${formattedCluster.mongoDBVersion || "N/A"} | ${formattedCluster.connectionString || "N/A"}`;
             })
             .join("\n");
         return {

package/src/tools/atlas/read/listProjects.ts

@@ -21,7 +21,8 @@ export class ListProjectsTool extends AtlasToolBase {
 
         const orgs: Record<string, string> = orgData.results
             .map((org) => [org.id || "", org.name])
-            .reduce((acc, [id, name]) => ({ ...acc, [id]: name }), {});
+            .filter(([id]) => id)
+            .reduce((acc, [id, name]) => ({ ...acc, [id as string]: name }), {});
 
         const data = orgId
             ? await this.session.apiClient.listOrganizationProjects({
@@ -41,7 +42,8 @@ export class ListProjectsTool extends AtlasToolBase {
         const rows = data.results
             .map((project) => {
                 const createdAt = project.created ? new Date(project.created).toLocaleString() : "N/A";
-                return `${project.name} | ${project.id} | ${orgs[project.orgId]} | ${project.orgId} | ${createdAt}`;
+                const orgName = orgs[project.orgId] ?? "N/A";
+                return `${project.name} | ${project.id} | ${orgName} | ${project.orgId} | ${createdAt}`;
             })
             .join("\n");
         const formattedProjects = `Project Name | Project ID | Organization Name | Organization ID | Created At

package/src/tools/atlas/tools.ts

@@ -9,6 +9,7 @@ import { CreateDBUserTool } from "./create/createDBUser.js";
 import { CreateProjectTool } from "./create/createProject.js";
 import { ListOrganizationsTool } from "./read/listOrgs.js";
 import { ConnectClusterTool } from "./metadata/connectCluster.js";
+import { ListAlertsTool } from "./read/listAlerts.js";
 
 export const AtlasTools = [
     ListClustersTool,
@@ -22,4 +23,5 @@ export const AtlasTools = [
     CreateProjectTool,
     ListOrganizationsTool,
     ConnectClusterTool,
+    ListAlertsTool,
 ];

package/src/tools/mongodb/metadata/listDatabases.ts

@@ -7,7 +7,6 @@ export class ListDatabasesTool extends MongoDBToolBase {
     protected name = "list-databases";
     protected description = "List all databases for a MongoDB connection";
     protected argsShape = {};
-
     protected operationType: OperationType = "metadata";
 
     protected async execute(): Promise<CallToolResult> {

package/src/tools/mongodb/read/count.ts

@@ -8,13 +8,14 @@ export const CountArgs = {
         .record(z.string(), z.unknown())
         .optional()
         .describe(
-            "The query filter to count documents. Matches the syntax of the filter argument of db.collection.count()"
+            "A filter/query parameter. Allows users to filter the documents to count. Matches the syntax of the filter argument of db.collection.count()."
         ),
 };
 
 export class CountTool extends MongoDBToolBase {
     protected name = "count";
-    protected description = "Gets the number of documents in a MongoDB collection";
+    protected description =
+        "Gets the number of documents in a MongoDB collection using db.collection.count() and query as an optional filter parameter";
     protected argsShape = {
         ...DbOperationArgs,
         ...CountArgs,

package/src/tools/mongodb/tools.ts

@@ -1,5 +1,4 @@
-// TODO: https://github.com/mongodb-js/mongodb-mcp-server/issues/141 - reenable when the connect tool is reenabled
-// import { ConnectTool } from "./metadata/connect.js";
+import { ConnectTool } from "./metadata/connect.js";
 import { ListCollectionsTool } from "./metadata/listCollections.js";
 import { CollectionIndexesTool } from "./read/collectionIndexes.js";
 import { ListDatabasesTool } from "./metadata/listDatabases.js";
@@ -21,8 +20,7 @@ import { CreateCollectionTool } from "./create/createCollection.js";
 import { LogsTool } from "./metadata/logs.js";
 
 export const MongoDbTools = [
-    // TODO: https://github.com/mongodb-js/mongodb-mcp-server/issues/141 - reenable when the connect tool is reenabled
-    // ConnectTool,
+    ConnectTool,
     ListCollectionsTool,
     ListDatabasesTool,
     CollectionIndexesTool,

package/src/tools/tool.ts

@@ -1,6 +1,6 @@
 import { z, type ZodRawShape, type ZodNever, AnyZodObject } from "zod";
 import type { McpServer, RegisteredTool, ToolCallback } from "@modelcontextprotocol/sdk/server/mcp.js";
-import type { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
+import type { CallToolResult, ToolAnnotations } from "@modelcontextprotocol/sdk/types.js";
 import { Session } from "../session.js";
 import logger, { LogId } from "../logger.js";
 import { Telemetry } from "../telemetry/telemetry.js";
@@ -27,6 +27,34 @@ export abstract class ToolBase {
 
     protected abstract argsShape: ZodRawShape;
 
+    protected get annotations(): ToolAnnotations {
+        const annotations: ToolAnnotations = {
+            title: this.name,
+            description: this.description,
+        };
+
+        switch (this.operationType) {
+            case "read":
+            case "metadata":
+                annotations.readOnlyHint = true;
+                annotations.destructiveHint = false;
+                break;
+            case "delete":
+                annotations.readOnlyHint = false;
+                annotations.destructiveHint = true;
+                break;
+            case "create":
+            case "update":
+                annotations.destructiveHint = false;
+                annotations.readOnlyHint = false;
+                break;
+            default:
+                break;
+        }
+
+        return annotations;
+    }
+
     protected abstract execute(...args: Parameters<ToolCallback<typeof this.argsShape>>): Promise<CallToolResult>;
 
     constructor(
@@ -43,20 +71,20 @@ export abstract class ToolBase {
         const callback: ToolCallback<typeof this.argsShape> = async (...args) => {
             const startTime = Date.now();
             try {
-                logger.debug(LogId.toolExecute, "tool", `Executing ${this.name} with args: ${JSON.stringify(args)}`);
+                logger.debug(LogId.toolExecute, "tool", `Executing tool ${this.name}`);
 
                 const result = await this.execute(...args);
-                await this.emitToolEvent(startTime, result, ...args).catch(() => {});
+                this.emitToolEvent(startTime, result, ...args);
                 return result;
             } catch (error: unknown) {
                 logger.error(LogId.toolExecuteFailure, "tool", `Error executing ${this.name}: ${error as string}`);
                 const toolResult = await this.handleError(error, args[0] as ToolArgs<typeof this.argsShape>);
-                await this.emitToolEvent(startTime, toolResult, ...args).catch(() => {});
+                this.emitToolEvent(startTime, toolResult, ...args);
                 return toolResult;
             }
         };
 
-        server.tool(this.name, this.description, this.argsShape, callback);
+        server.tool(this.name, this.description, this.argsShape, this.annotations, callback);
 
         // This is very similar to RegisteredTool.update, but without the bugs around the name.
         // In the upstream update method, the name is captured in the closure and not updated when
@@ -66,13 +94,22 @@ export abstract class ToolBase {
             const tools = server["_registeredTools"] as { [toolName: string]: RegisteredTool };
             const existingTool = tools[this.name];
 
+            if (!existingTool) {
+                logger.warning(LogId.toolUpdateFailure, "tool", `Tool ${this.name} not found in update`);
+                return;
+            }
+
+            existingTool.annotations = this.annotations;
+
             if (updates.name && updates.name !== this.name) {
+                existingTool.annotations.title = updates.name;
                 delete tools[this.name];
                 this.name = updates.name;
                 tools[this.name] = existingTool;
             }
 
             if (updates.description) {
+                existingTool.annotations.description = updates.description;
                 existingTool.description = updates.description;
                 this.description = updates.description;
             }
@@ -142,11 +179,11 @@ export abstract class ToolBase {
      * @param result - Whether the command succeeded or failed
      * @param args - The arguments passed to the tool
      */
-    private async emitToolEvent(
+    private emitToolEvent(
         startTime: number,
         result: CallToolResult,
         ...args: Parameters<ToolCallback<typeof this.argsShape>>
-    ): Promise<void> {
+    ): void {
         if (!this.telemetry.isTelemetryEnabled()) {
             return;
         }
@@ -172,6 +209,6 @@ export abstract class ToolBase {
             event.properties.project_id = metadata.projectId;
         }
 
-        await this.telemetry.emitEvents([event]);
+        this.telemetry.emitEvents([event]);
     }
 }

package/src/types/mongodb-connection-string-url.d.ts

@@ -0,0 +1,69 @@
+declare module "mongodb-connection-string-url" {
+    import { URL } from "whatwg-url";
+    import { redactConnectionString, ConnectionStringRedactionOptions } from "./redact";
+    export { redactConnectionString, ConnectionStringRedactionOptions };
+    declare class CaseInsensitiveMap<K extends string = string> extends Map<K, string> {
+        delete(name: K): boolean;
+        get(name: K): string | undefined;
+        has(name: K): boolean;
+        set(name: K, value: any): this;
+        _normalizeKey(name: any): K;
+    }
+    declare abstract class URLWithoutHost extends URL {
+        abstract get host(): never;
+        abstract set host(value: never);
+        abstract get hostname(): never;
+        abstract set hostname(value: never);
+        abstract get port(): never;
+        abstract set port(value: never);
+        abstract get href(): string;
+        abstract set href(value: string);
+    }
+    export interface ConnectionStringParsingOptions {
+        looseValidation?: boolean;
+    }
+    export declare class ConnectionString extends URLWithoutHost {
+        _hosts: string[];
+        constructor(uri: string, options?: ConnectionStringParsingOptions);
+        get host(): never;
+        set host(_ignored: never);
+        get hostname(): never;
+        set hostname(_ignored: never);
+        get port(): never;
+        set port(_ignored: never);
+        get href(): string;
+        set href(_ignored: string);
+        get isSRV(): boolean;
+        get hosts(): string[];
+        set hosts(list: string[]);
+        toString(): string;
+        clone(): ConnectionString;
+        redact(options?: ConnectionStringRedactionOptions): ConnectionString;
+        typedSearchParams<T extends {}>(): {
+            append(name: keyof T & string, value: any): void;
+            delete(name: keyof T & string): void;
+            get(name: keyof T & string): string | null;
+            getAll(name: keyof T & string): string[];
+            has(name: keyof T & string): boolean;
+            set(name: keyof T & string, value: any): void;
+            keys(): IterableIterator<keyof T & string>;
+            values(): IterableIterator<string>;
+            entries(): IterableIterator<[keyof T & string, string]>;
+            _normalizeKey(name: keyof T & string): string;
+            [Symbol.iterator](): IterableIterator<[keyof T & string, string]>;
+            sort(): void;
+            forEach<THIS_ARG = void>(
+                callback: (this: THIS_ARG, value: string, name: string, searchParams: any) => void,
+                thisArg?: THIS_ARG | undefined
+            ): void;
+            readonly [Symbol.toStringTag]: "URLSearchParams";
+        };
+    }
+    export declare class CommaAndColonSeparatedRecord<
+        K extends {} = Record<string, unknown>,
+    > extends CaseInsensitiveMap<keyof K & string> {
+        constructor(from?: string | null);
+        toString(): string;
+    }
+    export default ConnectionString;
+}

package/tests/integration/helpers.ts

@@ -5,7 +5,9 @@ import { UserConfig } from "../../src/config.js";
 import { McpError } from "@modelcontextprotocol/sdk/types.js";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { Session } from "../../src/session.js";
+import { Telemetry } from "../../src/telemetry/telemetry.js";
 import { config } from "../../src/config.js";
+import { jest } from "@jest/globals";
 
 interface ParameterInfo {
     name: string;
@@ -56,14 +58,27 @@ export function setupIntegrationTest(getUserConfig: () => UserConfig): Integrati
             apiClientSecret: userConfig.apiClientSecret,
         });
 
+        // Mock hasValidAccessToken for tests
+        if (userConfig.apiClientId && userConfig.apiClientSecret) {
+            const mockFn = jest.fn<() => Promise<boolean>>().mockResolvedValue(true);
+            // @ts-expect-error accessing private property for testing
+            session.apiClient.validateAccessToken = mockFn;
+        }
+
+        userConfig.telemetry = "disabled";
+
+        const telemetry = Telemetry.create(session, userConfig);
+
         mcpServer = new Server({
             session,
             userConfig,
+            telemetry,
             mcpServer: new McpServer({
                 name: "test-server",
                 version: "5.2.3",
             }),
         });
+
         await mcpServer.connect(serverTransport);
         await mcpClient.connect(clientTransport);
     });
@@ -117,7 +132,7 @@ export function getResponseElements(content: unknown | { content: unknown }): {
         content = (content as { content: unknown }).content;
     }
 
-    expect(Array.isArray(content)).toBe(true);
+    expect(content).toBeArray();
 
     const response = content as { type: string; text: string }[];
     for (const item of response) {
@@ -191,6 +206,7 @@ export function validateToolMetadata(
         expectDefined(tool);
         expect(tool.description).toBe(description);
 
+        validateToolAnnotations(tool, name, description);
         const toolParameters = getParameters(tool);
         expect(toolParameters).toHaveLength(parameters.length);
         expect(toolParameters).toIncludeAllMembers(parameters);
@@ -221,6 +237,29 @@ export function validateThrowsForInvalidArguments(
 }
 
 /** Expects the argument being defined and asserts it */
-export function expectDefined<T>(arg: T): asserts arg is Exclude<T, undefined> {
+export function expectDefined<T>(arg: T): asserts arg is Exclude<T, undefined | null> {
     expect(arg).toBeDefined();
+    expect(arg).not.toBeNull();
+}
+
+function validateToolAnnotations(tool: ToolInfo, name: string, description: string): void {
+    expectDefined(tool.annotations);
+    expect(tool.annotations.title).toBe(name);
+    expect(tool.annotations.description).toBe(description);
+
+    switch (tool.operationType) {
+        case "read":
+        case "metadata":
+            expect(tool.annotations.readOnlyHint).toBe(true);
+            expect(tool.annotations.destructiveHint).toBe(false);
+            break;
+        case "delete":
+            expect(tool.annotations.readOnlyHint).toBe(false);
+            expect(tool.annotations.destructiveHint).toBe(true);
+            break;
+        case "create":
+        case "update":
+            expect(tool.annotations.readOnlyHint).toBe(false);
+            expect(tool.annotations.destructiveHint).toBe(false);
+    }
 }