@salesforce/mcp 0.3.0 → 0.4.1

package/README.md

@@ -4,9 +4,9 @@ MCP Server for Interacting with Salesforce Orgs
 
 [![NPM](https://img.shields.io/npm/v/@salesforce/mcp.svg?label=@salesforce/mcp)](https://www.npmjs.com/package/@salesforce/mcp) [![License](https://img.shields.io/badge/License-Apache--2.0-blue.svg)](https://opensource.org/license/apache-2-0)
 
-## Overview of the Salesforce MCP Server (Developer Preview)
+## Overview of the Salesforce DX MCP Server (Developer Preview)
 
-The Salesforce MCP Server is a specialized Model Context Protocol (MCP) implementation designed to facilitate seamless interaction between large language models (LLMs) and Salesforce orgs. This MCP server provides a robust set of tools and capabilities that enable LLMs to read, manage, and operate Salesforce resources securely.
+The Salesforce DX MCP Server is a specialized Model Context Protocol (MCP) implementation designed to facilitate seamless interaction between large language models (LLMs) and Salesforce orgs. This MCP server provides a robust set of tools and capabilities that enable LLMs to read, manage, and operate Salesforce resources securely.
 
 Key Features:
 
@@ -16,11 +16,11 @@ Key Features:
 - Granular access control with org allowlisting.
 - Modular tool architecture for easy extensibility.
 
-**NOTE**: The Salesforce MCP Server is available as a developer preview. The feature isn’t generally available unless or until Salesforce announces its general availability in documentation or in press releases or public statements. All commands, parameters, and other features are subject to change or deprecation at any time, with or without notice. Don't implement functionality developed with these commands or tools. As we continue to enhance and refine the implementation, the available functionality and tools may evolve. We welcome feedback and contributions to help shape the future of this project.
+**NOTE**: The Salesforce DX MCP Server is available as a developer preview. The feature isn’t generally available unless or until Salesforce announces its general availability in documentation or in press releases or public statements. All commands, parameters, and other features are subject to change or deprecation at any time, with or without notice. Don't implement functionality developed with these commands or tools. As we continue to enhance and refine the implementation, the available functionality and tools may evolve. We welcome feedback and contributions to help shape the future of this project.
 
 ### Security Features
 
-The Salesforce MCP Server was designed with security as a top priority.
+The Salesforce DX MCP Server was designed with security as a top priority.
 
 - **Uses TypeScript libraries directly**
 
@@ -47,9 +47,9 @@ The Salesforce MCP Server was designed with security as a top priority.
 
 Want to jump in and see what all the fuss is about? Read on!
 
-This example uses Visual Studio Code (VS Code) as the MCP client because it's a standard Salesforce DX development tool. After you configure it with the Salesforce MCP server, you then use GitHub Copilot and natural language to easily execute typical Salesforce DX development tasks, such as listing your authorized orgs, viewing org records, and deploying or retrieving metadata.
+This example uses Visual Studio Code (VS Code) as the MCP client because it's a standard Salesforce DX development tool. After you configure it with the Salesforce DX MCP Server, you then use GitHub Copilot and natural language to easily execute typical Salesforce DX development tasks, such as listing your authorized orgs, viewing org records, and deploying or retrieving metadata.
 
-But you're not limited to using only VS Code and Copilot! You can [configure many other clients](README.md#configure-other-clients-to-use-the-salesforce-mcp-server) to use the Salesforce MCP server, such as Cursor, Cline, Claude Desktop, Zed, Windsurf, and more.
+But you're not limited to using only VS Code and Copilot! You can [configure many other clients](README.md#configure-other-clients-to-use-the-salesforce-mcp-server) to use the Salesforce DX MCP Server, such as Cursor, Cline, Claude Desktop, Zed, Windsurf, and more.
 
 **Before You Begin**
 
@@ -104,7 +104,7 @@ For the best getting-started experience, make sure that you have a Salesforce DX
 
 ## Configure Orgs and Toolsets
 
-You configure the Salesforce MCP server by specifying at least one authorized org and an optional list of MCP toolsets.
+You configure the Salesforce DX MCP Server by specifying at least one authorized org and an optional list of MCP toolsets.
 
 ### Configure Orgs
 
@@ -147,9 +147,9 @@ This sample snippet shows how to configure access to two orgs for which you spec
 
 ### Configure Toolsets
 
-The Salesforce MCP Server supports **toolsets** - a way to selectively enable different groups of MCP tools based on your needs. This allows you to run the MCP server with only the tools you require, which in turn reduces the context.
+The Salesforce DX MCP Server supports **toolsets** - a way to selectively enable different groups of MCP tools based on your needs. This allows you to run the MCP server with only the tools you require, which in turn reduces the context.
 
-Use the `--toolsets` (or short name `-t`) argument to specify the toolsets when you configure the Salesforce MCP server. Separate multiple toolsets with commas. The `--toolsets` argument is optional; if you don't specify it, the MCP server is configured with all toolsets.
+Use the `--toolsets` (or short name `-t`) argument to specify the toolsets when you configure the Salesforce DX MCP Server. Separate multiple toolsets with commas. The `--toolsets` argument is optional; if you don't specify it, the MCP server is configured with all toolsets.
 
 These are the available toolsets:
 
@@ -204,11 +204,11 @@ Includes these tools:
 - `sf-deploy-metadata` - Deploys metadata from your DX project to an org.
 - `sf-retrieve-metadata` - Retrieves metadata from your org to your DX project.
 
-## Configure Other Clients to Use the Salesforce MCP Server
+## Configure Other Clients to Use the Salesforce DX MCP Server
 
 **Cursor**
 
-To configure [Cursor](https://www.cursor.com/) to work with Salesforce MCP server, add this snippet to your Cursor `mcp.json` file:
+To configure [Cursor](https://www.cursor.com/) to work with Salesforce DX MCP Server, add this snippet to your Cursor `mcp.json` file:
 
 ```json
 {

package/lib/index.d.ts

@@ -6,10 +6,13 @@ export default class McpServerCommand extends Command {
         orgs: import("@oclif/core/interfaces").OptionFlag<string[], import("@oclif/core/interfaces").CustomOptions>;
         toolsets: import("@oclif/core/interfaces").OptionFlag<("data" | "metadata" | "all" | "users" | "orgs")[], import("@oclif/core/interfaces").CustomOptions>;
         version: import("@oclif/core/interfaces").BooleanFlag<void>;
+        'no-telemetry': import("@oclif/core/interfaces").BooleanFlag<boolean>;
     };
     static examples: {
         description: string;
         command: string;
     }[];
+    private telemetry?;
     run(): Promise<void>;
+    protected catch(error: Error): Promise<void>;
 }

package/lib/index.js

@@ -14,7 +14,6 @@
  * limitations under the License.
  */
 /* eslint-disable no-console */
-import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import { Command, Flags, ux } from '@oclif/core';
 import * as core from './tools/core/index.js';
@@ -23,7 +22,26 @@ import * as data from './tools/data/index.js';
 import * as users from './tools/users/index.js';
 import * as metadata from './tools/metadata/index.js';
 import Cache from './shared/cache.js';
+import { Telemetry } from './telemetry.js';
+import { SfMcpServer } from './sf-mcp-server.js';
 const TOOLSETS = ['all', 'orgs', 'data', 'users', 'metadata'];
+/**
+ * Sanitizes an array of org usernames by replacing specific orgs with a placeholder.
+ * Special values (DEFAULT_TARGET_ORG, DEFAULT_TARGET_DEV_HUB, ALLOW_ALL_ORGS) are preserved.
+ *
+ * @param {string[]} input - Array of org identifiers to sanitize
+ * @returns {string} Comma-separated string of sanitized org identifiers
+ */
+function sanitizeOrgInput(input) {
+    return input
+        .map((org) => {
+        if (org === 'DEFAULT_TARGET_ORG' || org === 'DEFAULT_TARGET_DEV_HUB' || org === 'ALLOW_ALL_ORGS') {
+            return org;
+        }
+        return 'SANITIZED_ORG';
+    })
+        .join(', ');
+}
 export default class McpServerCommand extends Command {
     static summary = 'Start the Salesforce MCP server';
     static description = `This command starts the Model Context Protocol (MCP) server for Salesforce, allowing access to various tools and orgs.
@@ -45,7 +63,7 @@ You can also use special values to control access to orgs:
             delimiter: ',',
             parse: async (input) => {
                 if (input === 'ALLOW_ALL_ORGS') {
-                    ux.warn('WARNING: ALLOW_ALL_ORGS is set. This allows access to all authenticated orgs. Use with caution.');
+                    ux.warn('ALLOW_ALL_ORGS is set. This allows access to all authenticated orgs. Use with caution.');
                 }
                 if (input === 'DEFAULT_TARGET_ORG' ||
                     input === 'DEFAULT_TARGET_DEV_HUB' ||
@@ -65,6 +83,9 @@ You can also use special values to control access to orgs:
             default: ['all'],
         })(),
         version: Flags.version(),
+        'no-telemetry': Flags.boolean({
+            summary: 'Disable telemetry',
+        }),
     };
     static examples = [
         {
@@ -80,18 +101,30 @@ You can also use special values to control access to orgs:
             command: '<%= config.bin %> --orgs test-org@example.com,my-dev-hub,my-alias',
         },
     ];
+    telemetry;
     async run() {
         const { flags } = await this.parse(McpServerCommand);
+        if (!flags['no-telemetry']) {
+            this.telemetry = new Telemetry(this.config, {
+                toolsets: flags.toolsets.join(', '),
+                orgs: sanitizeOrgInput(flags.orgs),
+            });
+            await this.telemetry.start();
+            process.stdin.on('close', (err) => {
+                this.telemetry?.sendEvent(err ? 'SERVER_STOPPED_ERROR' : 'SERVER_STOPPED_SUCCESS');
+                this.telemetry?.stop();
+            });
+        }
         Cache.getInstance().set('allowedOrgs', new Set(flags.orgs));
         this.logToStderr(`Allowed orgs:\n${flags.orgs.map((org) => `- ${org}`).join('\n')}`);
-        const server = new McpServer({
+        const server = new SfMcpServer({
             name: 'sf-mcp-server',
             version: this.config.version,
             capabilities: {
                 resources: {},
                 tools: {},
             },
-        });
+        }, { telemetry: this.telemetry });
         // // TODO: Should we add annotations to our tools? https://modelcontextprotocol.io/docs/concepts/tools#tool-definition-structure
         // // TODO: Move tool names into a shared file, that way if we reference them in multiple places, we can update them in one place
         const enabledToolsets = new Set(flags.toolsets);
@@ -135,5 +168,16 @@ You can also use special values to control access to orgs:
         await server.connect(transport);
         console.error(`✅ Salesforce MCP Server v${this.config.version} running on stdio`);
     }
+    async catch(error) {
+        if (!this.telemetry && !process.argv.includes('--no-telemetry')) {
+            this.telemetry = new Telemetry(this.config);
+            await this.telemetry.start();
+        }
+        this.telemetry?.sendEvent('START_ERROR', {
+            error: error.message,
+            stack: error.stack,
+        });
+        await super.catch(error);
+    }
 }
 //# sourceMappingURL=index.js.map

package/lib/sf-mcp-server.d.ts

@@ -0,0 +1,32 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { Implementation } from '@modelcontextprotocol/sdk/types.js';
+import { ServerOptions } from '@modelcontextprotocol/sdk/server/index.js';
+import { Telemetry } from './telemetry.js';
+type ToolMethodSignatures = {
+    tool: McpServer['tool'];
+    connect: McpServer['connect'];
+};
+/**
+ * A server implementation that extends the base MCP server with telemetry capabilities.
+ *
+ * The method overloads for `tool` are taken directly from the source code for the original McpServer. They're
+ * copied here so that the types don't get lost.
+ *
+ * @extends {McpServer}
+ */
+export declare class SfMcpServer extends McpServer implements ToolMethodSignatures {
+    /** Optional telemetry instance for tracking server events */
+    private telemetry?;
+    /**
+     * Creates a new SfMcpServer instance
+     *
+     * @param {Implementation} serverInfo - The server implementation details
+     * @param {ServerOptions & { telemetry?: Telemetry }} [options] - Optional server configuration including telemetry
+     */
+    constructor(serverInfo: Implementation, options?: ServerOptions & {
+        telemetry?: Telemetry;
+    });
+    connect: McpServer['connect'];
+    tool: McpServer['tool'];
+}
+export {};

package/lib/sf-mcp-server.js

@@ -0,0 +1,82 @@
+/*
+ * Copyright 2025, Salesforce, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+/**
+ * A server implementation that extends the base MCP server with telemetry capabilities.
+ *
+ * The method overloads for `tool` are taken directly from the source code for the original McpServer. They're
+ * copied here so that the types don't get lost.
+ *
+ * @extends {McpServer}
+ */
+export class SfMcpServer extends McpServer {
+    /** Optional telemetry instance for tracking server events */
+    telemetry;
+    /**
+     * Creates a new SfMcpServer instance
+     *
+     * @param {Implementation} serverInfo - The server implementation details
+     * @param {ServerOptions & { telemetry?: Telemetry }} [options] - Optional server configuration including telemetry
+     */
+    constructor(serverInfo, options) {
+        super(serverInfo, options);
+        this.telemetry = options?.telemetry;
+        this.server.oninitialized = () => {
+            const clientInfo = this.server.getClientVersion();
+            if (clientInfo) {
+                this.telemetry?.addAttributes({
+                    clientName: clientInfo.name,
+                    clientVersion: clientInfo.version,
+                });
+            }
+            this.telemetry?.sendEvent('SERVER_START_SUCCESS');
+        };
+    }
+    connect = async (transport) => {
+        try {
+            await super.connect(transport);
+            if (!this.isConnected()) {
+                this.telemetry?.sendEvent('SERVER_START_ERROR', {
+                    error: 'Server not connected',
+                });
+            }
+        }
+        catch (error) {
+            this.telemetry?.sendEvent('SERVER_START_ERROR', {
+                error: error instanceof Error ? error.message : 'Unknown error',
+                stack: error instanceof Error ? error.stack : undefined,
+            });
+        }
+    };
+    tool = (name, ...rest) => {
+        // Given the signature of the tool function, the last argument is always the callback
+        const cb = rest[rest.length - 1];
+        const wrappedCb = async (args) => {
+            const startTime = Date.now();
+            const result = await cb(args);
+            const runtimeMs = Date.now() - startTime;
+            this.telemetry?.sendEvent('TOOL_CALLED', {
+                name,
+                runtimeMs,
+                isError: result.isError,
+            });
+            return result;
+        };
+        // @ts-expect-error because we no longer know what the type of rest is
+        return super.tool(name, ...rest.slice(0, -1), wrappedCb);
+    };
+}
+//# sourceMappingURL=sf-mcp-server.js.map

package/lib/telemetry.d.ts

@@ -0,0 +1,22 @@
+import { Attributes } from '@salesforce/telemetry';
+import { Config } from '@oclif/core';
+export declare class Telemetry {
+    private readonly config;
+    private attributes;
+    /**
+     * A unique identifier for the session.
+     */
+    private sessionId;
+    /**
+     * The unique identifier generated for the user by the `sf` CLI.
+     * If it doesn't exist, or we can't read it, we'll generate a new one.
+     */
+    private cliId;
+    private started;
+    private reporter?;
+    constructor(config: Config, attributes?: Attributes);
+    addAttributes(attributes: Attributes): void;
+    sendEvent(eventName: string, attributes?: Attributes): void;
+    start(): Promise<void>;
+    stop(): void;
+}

package/lib/telemetry.js

@@ -0,0 +1,129 @@
+/*
+ * Copyright 2025, Salesforce, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { randomBytes } from 'node:crypto';
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { TelemetryReporter } from '@salesforce/telemetry';
+import { warn } from '@oclif/core/ux';
+const PROJECT = 'salesforce-mcp-server';
+const APP_INSIGHTS_KEY = 'InstrumentationKey=2ca64abb-6123-4c7b-bd9e-4fe73e71fe9c;IngestionEndpoint=https://eastus-1.in.applicationinsights.azure.com/;LiveEndpoint=https://eastus.livediagnostics.monitor.azure.com/;ApplicationId=ecd8fa7a-0e0d-4109-94db-4d7878ada862';
+const generateRandomId = () => randomBytes(20).toString('hex');
+const getCliId = (cacheDir) => {
+    // We need to find sf's cache directory and read the CLIID.txt file from there.
+    // The problem is that sf's cache directory is OS specific and we don't want to
+    // hardcode all the potential paths. oclif does this for us already during startup
+    // so we can simply replace sf-mcp-server with sf in the cache directory path and
+    // end up with the correct OS specific path.
+    //
+    // The only downside to this approach is that the user could have a different
+    // cache directory set via env var. In that case, we'll just generate a new CLIID.
+    // This is a very rare case and we can live with it for now.
+    const sfCacheDir = cacheDir.replace('sf-mcp-server', 'sf');
+    const cliIdPath = join(sfCacheDir, 'CLIID.txt');
+    try {
+        return readFileSync(cliIdPath, 'utf-8');
+    }
+    catch {
+        return generateRandomId();
+    }
+};
+class McpTelemetryReporter extends TelemetryReporter {
+    /**
+     * TelemetryReporter references sf's config to determine if telemetry is enabled.
+     * We want to always send telemetry events, so we override the method to always return true.
+     * This is okay to do since the Telemetry class won't be instantiated in the MCP server if telemetry is disabled.
+     *
+     * @returns true
+     */
+    // eslint-disable-next-line class-methods-use-this
+    isSfdxTelemetryEnabled() {
+        return true;
+    }
+}
+export class Telemetry {
+    config;
+    attributes;
+    /**
+     * A unique identifier for the session.
+     */
+    sessionId;
+    /**
+     * The unique identifier generated for the user by the `sf` CLI.
+     * If it doesn't exist, or we can't read it, we'll generate a new one.
+     */
+    cliId;
+    started = false;
+    reporter;
+    constructor(config, attributes = {}) {
+        this.config = config;
+        this.attributes = attributes;
+        warn('You acknowledge and agree that the MCP server may collect usage information, user environment, and crash reports for the purposes of providing services or functions that are relevant to use of the MCP server and product improvements.');
+        this.sessionId = generateRandomId();
+        this.cliId = getCliId(config.cacheDir);
+    }
+    addAttributes(attributes) {
+        this.attributes = { ...this.attributes, ...attributes };
+    }
+    sendEvent(eventName, attributes) {
+        try {
+            this.reporter?.sendTelemetryEvent(eventName, {
+                ...this.attributes,
+                ...attributes,
+                // Identifiers
+                sessionId: this.sessionId,
+                cliId: this.cliId,
+                // System information
+                version: this.config.version,
+                platform: this.config.platform,
+                arch: this.config.arch,
+                nodeVersion: process.version,
+                nodeEnv: process.env.NODE_ENV,
+                origin: this.config.userAgent,
+                // Timestamps
+                date: new Date().toUTCString(),
+                timestamp: String(Date.now()),
+                processUptime: process.uptime() * 1000,
+            });
+        }
+        catch {
+            /* empty */
+        }
+    }
+    async start() {
+        if (this.started)
+            return;
+        this.started = true;
+        try {
+            this.reporter = await McpTelemetryReporter.create({
+                project: PROJECT,
+                key: APP_INSIGHTS_KEY,
+                userId: this.cliId,
+                waitForConnection: true,
+            });
+            this.reporter.start();
+        }
+        catch {
+            // connection probably failed, but we can continue without telemetry
+        }
+    }
+    stop() {
+        if (!this.started)
+            return;
+        this.started = false;
+        this.reporter?.stop();
+    }
+}
+//# sourceMappingURL=telemetry.js.map

package/lib/tools/core/sf-get-username.d.ts

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { SfMcpServer } from '../../sf-mcp-server.js';
 export declare const getUsernameParamsSchema: z.ZodObject<{
     defaultTargetOrg: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
     defaultDevHub: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
@@ -14,4 +14,4 @@ export declare const getUsernameParamsSchema: z.ZodObject<{
     defaultDevHub?: boolean | undefined;
 }>;
 export type GetUsernameParamsSchema = z.infer<typeof getUsernameParamsSchema>;
-export declare const registerToolGetUsername: (server: McpServer) => void;
+export declare const registerToolGetUsername: (server: SfMcpServer) => void;

package/lib/tools/data/sf-query-org.d.ts

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { SfMcpServer } from '../../sf-mcp-server.js';
 export declare const queryOrgParamsSchema: z.ZodObject<{
     query: z.ZodString;
     usernameOrAlias: z.ZodString;
@@ -14,4 +14,4 @@ export declare const queryOrgParamsSchema: z.ZodObject<{
     usernameOrAlias: string;
 }>;
 export type QueryOrgOptions = z.infer<typeof queryOrgParamsSchema>;
-export declare const registerToolQueryOrg: (server: McpServer) => void;
+export declare const registerToolQueryOrg: (server: SfMcpServer) => void;

package/lib/tools/metadata/sf-deploy-metadata.d.ts

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { SfMcpServer } from '../../sf-mcp-server.js';
 declare const deployMetadataParams: z.ZodObject<{
     sourceDir: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
     manifest: z.ZodOptional<z.ZodString>;
@@ -23,5 +23,5 @@ declare const deployMetadataParams: z.ZodObject<{
     apexTests?: string[] | undefined;
 }>;
 export type DeployMetadata = z.infer<typeof deployMetadataParams>;
-export declare const registerToolDeployMetadata: (server: McpServer) => void;
+export declare const registerToolDeployMetadata: (server: SfMcpServer) => void;
 export {};

package/lib/tools/metadata/sf-retrieve-metadata.d.ts

@@ -1,2 +1,2 @@
-import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
-export declare const registerToolRetrieveMetadata: (server: McpServer) => void;
+import { SfMcpServer } from '../../sf-mcp-server.js';
+export declare const registerToolRetrieveMetadata: (server: SfMcpServer) => void;

package/lib/tools/users/sf-assign-permission-set.d.ts

@@ -1,5 +1,5 @@
-import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { z } from 'zod';
+import { SfMcpServer } from '../../sf-mcp-server.js';
 export declare const assignPermissionSetParamsSchema: z.ZodObject<{
     permissionSetName: z.ZodString;
     usernameOrAlias: z.ZodString;
@@ -17,4 +17,4 @@ export declare const assignPermissionSetParamsSchema: z.ZodObject<{
     onBehalfOf?: string | undefined;
 }>;
 export type AssignPermissionSetOptions = z.infer<typeof assignPermissionSetParamsSchema>;
-export declare const registerToolAssignPermissionSet: (server: McpServer) => void;
+export declare const registerToolAssignPermissionSet: (server: SfMcpServer) => void;