@salesforce/mcp 0.11.4 → 0.13.0

package/README.md

@@ -174,6 +174,12 @@ This example shows how to enable the `data`, `orgs`, and `metadata` toolsets whe
      }
 ```
 
+#### Dynamic Tools (Experimental)
+
+The `--dynamic-tools` flag enables dynamic tool discovery and loading. When this flag is set, the MCP server starts with a minimal set of core tools and will load new tools as the need arises. This is useful for reducing initial context size and improving LLM performance.
+
+**NOTE:** This feature works in VSCode and Cline but may not work in other environments.
+
 #### Core Toolset (always enabled)
 
 Includes this tool:

package/lib/index.d.ts

@@ -4,10 +4,11 @@ export default class McpServerCommand extends Command {
     static description: string;
     static flags: {
         orgs: import("@oclif/core/interfaces").OptionFlag<string[], import("@oclif/core/interfaces").CustomOptions>;
-        toolsets: import("@oclif/core/interfaces").OptionFlag<("data" | "experimental" | "metadata" | "all" | "users" | "orgs" | "testing")[], import("@oclif/core/interfaces").CustomOptions>;
+        toolsets: import("@oclif/core/interfaces").OptionFlag<("data" | "experimental" | "metadata" | "all" | "users" | "orgs" | "testing")[] | undefined, import("@oclif/core/interfaces").CustomOptions>;
         version: import("@oclif/core/interfaces").BooleanFlag<void>;
         'no-telemetry': import("@oclif/core/interfaces").BooleanFlag<boolean>;
         debug: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        'dynamic-tools': import("@oclif/core/interfaces").BooleanFlag<boolean>;
     };
     static examples: {
         description: string;

package/lib/index.js

@@ -22,10 +22,11 @@ import * as data from './tools/data/index.js';
 import * as users from './tools/users/index.js';
 import * as testing from './tools/testing/index.js';
 import * as metadata from './tools/metadata/index.js';
+import * as dynamic from './tools/dynamic/index.js';
 import Cache from './shared/cache.js';
 import { Telemetry } from './telemetry.js';
 import { SfMcpServer } from './sf-mcp-server.js';
-const TOOLSETS = ['all', 'testing', 'orgs', 'data', 'users', 'metadata', 'experimental'];
+import { determineToolsetsToEnable, TOOLSETS } from './shared/tools.js';
 /**
  * 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.
@@ -76,12 +77,12 @@ You can also use special values to control access to orgs:
             },
         }),
         toolsets: Flags.option({
-            options: TOOLSETS,
+            options: ['all', ...TOOLSETS],
             char: 't',
             summary: 'Toolset to enable',
             multiple: true,
             delimiter: ',',
-            default: ['all'],
+            exclusive: ['dynamic-toolsets'],
         })(),
         version: Flags.version(),
         'no-telemetry': Flags.boolean({
@@ -90,6 +91,11 @@ You can also use special values to control access to orgs:
         debug: Flags.boolean({
             summary: 'Enable debug logging',
         }),
+        'dynamic-tools': Flags.boolean({
+            summary: 'Enable dynamic toolsets',
+            char: 'd',
+            exclusive: ['toolsets'],
+        }),
     };
     static examples = [
         {
@@ -110,7 +116,7 @@ You can also use special values to control access to orgs:
         const { flags } = await this.parse(McpServerCommand);
         if (!flags['no-telemetry']) {
             this.telemetry = new Telemetry(this.config, {
-                toolsets: flags.toolsets.join(', '),
+                toolsets: (flags.toolsets ?? []).join(', '),
                 orgs: sanitizeOrgInput(flags.orgs),
             });
             await this.telemetry.start();
@@ -119,7 +125,7 @@ You can also use special values to control access to orgs:
                 this.telemetry?.stop();
             });
         }
-        Cache.getInstance().set('allowedOrgs', new Set(flags.orgs));
+        await Cache.safeSet('allowedOrgs', new Set(flags.orgs));
         this.logToStderr(`Allowed orgs:\n${flags.orgs.map((org) => `- ${org}`).join('\n')}`);
         const server = new SfMcpServer({
             name: 'sf-mcp-server',
@@ -128,20 +134,34 @@ You can also use special values to control access to orgs:
                 resources: {},
                 tools: {},
             },
-        }, { telemetry: this.telemetry });
-        const enabledToolsets = new Set(flags.toolsets);
-        const all = enabledToolsets.has('all');
+        }, {
+            telemetry: this.telemetry,
+            dynamicTools: flags['dynamic-tools'] ?? false,
+        });
+        const toolsetsToEnable = determineToolsetsToEnable(flags.toolsets ?? ['all'], flags['dynamic-tools'] ?? false);
         // ************************
         // CORE TOOLS (always on)
+        // If you're adding a new tool to the core toolset, you MUST add it to the `CORE_TOOLS` array in shared/tools.ts
+        // otherwise SfMcpServer will not register it.
+        //
+        // Long term, we will want to consider a more elegant solution for registering core tools.
         // ************************
         this.logToStderr('Registering core tools');
         // get username
         core.registerToolGetUsername(server);
         core.registerToolResume(server);
+        // DYNAMIC TOOLSETS
+        // ************************
+        if (toolsetsToEnable.dynamic) {
+            this.logToStderr('Registering dynamic tools');
+            // Individual tool management
+            dynamic.registerToolEnableTool(server);
+            dynamic.registerToolListTools(server);
+        }
         // ************************
         // ORG TOOLS
         // ************************
-        if (all || enabledToolsets.has('orgs')) {
+        if (toolsetsToEnable.orgs) {
             this.logToStderr('Registering org tools');
             // list all orgs
             orgs.registerToolListAllOrgs(server);
@@ -149,7 +169,7 @@ You can also use special values to control access to orgs:
         // ************************
         // DATA TOOLS
         // ************************
-        if (all || enabledToolsets.has('data')) {
+        if (toolsetsToEnable.data) {
             this.logToStderr('Registering data tools');
             // query org
             data.registerToolQueryOrg(server);
@@ -157,7 +177,7 @@ You can also use special values to control access to orgs:
         // ************************
         // USER TOOLS
         // ************************
-        if (all || enabledToolsets.has('users')) {
+        if (toolsetsToEnable.users) {
             this.logToStderr('Registering user tools');
             // assign permission set
             users.registerToolAssignPermissionSet(server);
@@ -165,7 +185,7 @@ You can also use special values to control access to orgs:
         // ************************
         // testing TOOLS
         // ************************
-        if (all || enabledToolsets.has('testing')) {
+        if (toolsetsToEnable.testing) {
             this.logToStderr('Registering testing tools');
             testing.registerToolTestApex(server);
             testing.registerToolTestAgent(server);
@@ -173,7 +193,7 @@ You can also use special values to control access to orgs:
         // ************************
         // METADATA TOOLS
         // ************************
-        if (all || enabledToolsets.has('metadata')) {
+        if (toolsetsToEnable.metadata) {
             this.logToStderr('Registering metadata tools');
             // deploy metadata
             metadata.registerToolDeployMetadata(server);
@@ -186,8 +206,9 @@ You can also use special values to control access to orgs:
         // This toolset needs to be explicitly enabled ('all' will not include it)
         // Tools don't need to be in an 'experimental' directory, only registered here
         // ************************
-        if (enabledToolsets.has('experimental')) {
+        if (toolsetsToEnable.experimental) {
             this.logToStderr('Registering experimental tools');
+            orgs.registerToolOrgOpen(server);
             // Add any experimental tools here
         }
         const transport = new StdioServerTransport();

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

@@ -15,6 +15,8 @@ export type SfMcpServerOptions = ServerOptions & {
     telemetry?: Telemetry;
     /** Optional rate limiting configuration */
     rateLimit?: Partial<RateLimitConfig>;
+    /** Enable dynamic tool loading */
+    dynamicTools?: boolean;
 };
 /**
  * A server implementation that extends the base MCP server with telemetry and rate limiting capabilities.
@@ -28,6 +30,7 @@ export declare class SfMcpServer extends McpServer implements ToolMethodSignatur
     private logger;
     /** Optional telemetry instance for tracking server events */
     private telemetry?;
+    private dynamicTools;
     /** Rate limiter for controlling tool call frequency */
     private rateLimiter?;
     /**

package/lib/sf-mcp-server.js

@@ -15,6 +15,7 @@
  */
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { Logger } from '@salesforce/core';
+import { addTool, CORE_TOOLS } from './shared/tools.js';
 import { createRateLimiter } from './shared/rate-limiter.js';
 /**
  * A server implementation that extends the base MCP server with telemetry and rate limiting capabilities.
@@ -28,6 +29,7 @@ export class SfMcpServer extends McpServer {
     logger = Logger.childFromRoot('mcp-server');
     /** Optional telemetry instance for tracking server events */
     telemetry;
+    dynamicTools;
     /** Rate limiter for controlling tool call frequency */
     rateLimiter;
     /**
@@ -39,6 +41,7 @@ export class SfMcpServer extends McpServer {
     constructor(serverInfo, options) {
         super(serverInfo, options);
         this.telemetry = options?.telemetry;
+        this.dynamicTools = options?.dynamicTools ?? false;
         // Initialize rate limiter if configuration is provided
         if (options?.rateLimit !== undefined) {
             this.rateLimiter = createRateLimiter(options.rateLimit);
@@ -112,7 +115,16 @@ export class SfMcpServer extends McpServer {
             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);
+        const tool = super.tool(name, ...rest.slice(0, -1), wrappedCb);
+        if (this.dynamicTools) {
+            // Only disable the tool if it's not a core tool
+            if (!CORE_TOOLS.includes(name))
+                tool.disable();
+            addTool(tool, name).catch((error) => {
+                this.logger.error(`Failed to add tool ${name}:`, error);
+            });
+        }
+        return tool;
     };
 }
 //# sourceMappingURL=sf-mcp-server.js.map

package/lib/shared/auth.js

@@ -95,7 +95,7 @@ export async function getAllAllowedOrgs() {
     const url = new URL(import.meta.url);
     const params = url.searchParams.get('orgs');
     const paramOrg = params ? params : undefined;
-    const orgAllowList = paramOrg ? new Set([paramOrg]) : Cache.getInstance().get('allowedOrgs') ?? new Set();
+    const orgAllowList = paramOrg ? new Set([paramOrg]) : (await Cache.safeGet('allowedOrgs')) ?? new Set();
     // Get all orgs on the user's machine
     const allOrgs = await AuthInfo.listAllAuthorizations();
     // Sanitize the orgs to remove sensitive data

package/lib/shared/cache.d.ts

@@ -1,14 +1,38 @@
+import { ToolInfo } from './types.js';
 type CacheContents = {
     allowedOrgs: Set<string>;
+    tools: ToolInfo[];
 };
 type ValueOf<T> = T[keyof T];
 /**
- * A simple cache for storing values that need to be accessed globally.
+ * A thread-safe cache providing generic Map operations with mutex protection.
+ * Offers atomic read, write, and update operations for concurrent access.
  */
 export default class Cache extends Map<keyof CacheContents, ValueOf<CacheContents>> {
     private static instance;
-    constructor();
+    private static mutex;
+    private constructor();
+    /**
+     * Get the singleton instance of the Cache
+     * Creates a new instance if one doesn't exist
+     *
+     * @returns The singleton Cache instance
+     */
     static getInstance(): Cache;
-    get(_key: 'allowedOrgs'): Set<string>;
+    /**
+     * Thread-safe atomic update operation
+     * Allows safe read-modify-write operations with mutex protection
+     */
+    static safeUpdate<K extends keyof CacheContents>(key: K, updateFn: (currentValue: CacheContents[K]) => CacheContents[K]): Promise<CacheContents[K]>;
+    /**
+     * Thread-safe atomic read operation
+     */
+    static safeGet<K extends keyof CacheContents>(key: K): Promise<CacheContents[K]>;
+    /**
+     * Thread-safe atomic write operation
+     */
+    static safeSet<K extends keyof CacheContents>(key: K, value: CacheContents[K]): Promise<void>;
+    get<K extends keyof CacheContents>(key: K): CacheContents[K];
+    private initialize;
 }
 export {};

package/lib/shared/cache.js

@@ -13,23 +13,63 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+import { Mutex } from '@salesforce/core';
 /**
- * A simple cache for storing values that need to be accessed globally.
+ * A thread-safe cache providing generic Map operations with mutex protection.
+ * Offers atomic read, write, and update operations for concurrent access.
  */
 export default class Cache extends Map {
     static instance;
+    // Mutex for thread-safe cache operations
+    static mutex = new Mutex();
     constructor() {
         super();
-        this.set('allowedOrgs', new Set());
+        this.initialize();
     }
+    /**
+     * Get the singleton instance of the Cache
+     * Creates a new instance if one doesn't exist
+     *
+     * @returns The singleton Cache instance
+     */
     static getInstance() {
-        if (!Cache.instance) {
-            Cache.instance = new Cache();
-        }
-        return Cache.instance;
+        return (Cache.instance ??= new Cache());
+    }
+    /**
+     * Thread-safe atomic update operation
+     * Allows safe read-modify-write operations with mutex protection
+     */
+    static async safeUpdate(key, updateFn) {
+        const cache = Cache.getInstance();
+        return Cache.mutex.lock(() => {
+            const currentValue = cache.get(key);
+            const newValue = updateFn(currentValue);
+            cache.set(key, newValue);
+            return newValue;
+        });
+    }
+    /**
+     * Thread-safe atomic read operation
+     */
+    static async safeGet(key) {
+        const cache = Cache.getInstance();
+        return Cache.mutex.lock(() => cache.get(key));
+    }
+    /**
+     * Thread-safe atomic write operation
+     */
+    static async safeSet(key, value) {
+        const cache = Cache.getInstance();
+        return Cache.mutex.lock(() => {
+            cache.set(key, value);
+        });
     }
     get(key) {
         return super.get(key);
     }
+    initialize() {
+        this.set('allowedOrgs', new Set());
+        this.set('tools', []);
+    }
 }
 //# sourceMappingURL=cache.js.map

package/lib/shared/tools.d.ts

@@ -0,0 +1,64 @@
+import { RegisteredTool } from '@modelcontextprotocol/sdk/server/mcp.js';
+export declare const TOOLSETS: readonly ["orgs", "data", "users", "metadata", "testing", "experimental"];
+type Toolset = (typeof TOOLSETS)[number];
+export declare const CORE_TOOLS: string[];
+/**
+ * Determines which toolsets should be enabled based on the provided toolsets array and dynamic tools flag.
+ *
+ * @param {Array<Toolset | 'all'>} toolsets - Array of toolsets to enable. Can include 'all' to enable all non-experimental toolsets.
+ * @param {boolean} dynamicTools - Flag indicating whether dynamic tools should be enabled. When true, only core and dynamic toolsets are enabled.
+ * @returns {Record<Toolset | 'dynamic' | 'core', boolean>} Object mapping each toolset to a boolean indicating whether it should be enabled.
+ *
+ * @example
+ * // Enable all toolsets except experimental
+ * determineToolsetsToEnable(['all'], false)
+ * // Returns: { core: true, data: true, dynamic: false, experimental: false, metadata: true, orgs: true, testing: true, users: true }
+ *
+ * @example
+ * // Enable only dynamic tools
+ * determineToolsetsToEnable([], true)
+ * // Returns: { core: true, data: false, dynamic: true, experimental: false, metadata: false, orgs: false, testing: false, users: false }
+ *
+ * @example
+ * // Enable specific toolsets
+ * determineToolsetsToEnable(['data', 'users'], false)
+ * // Returns: { core: true, data: true, dynamic: false, experimental: false, metadata: false, orgs: false, testing: false, users: true }
+ */
+export declare function determineToolsetsToEnable(toolsets: Array<Toolset | 'all'>, dynamicTools: boolean): Record<Toolset | 'dynamic' | 'core', boolean>;
+/**
+ * Add a tool to the cache
+ */
+export declare function addTool(tool: RegisteredTool, name: string): Promise<{
+    success: boolean;
+    message: string;
+}>;
+/**
+ * Enable an individual tool
+ */
+export declare function enableTool(toolName: string): Promise<{
+    success: boolean;
+    message: string;
+}>;
+/**
+ * Disable an individual tool
+ */
+export declare function disableTool(toolName: string): Promise<{
+    success: boolean;
+    message: string;
+}>;
+/**
+ * Get individual tool status
+ */
+export declare function getToolStatus(toolName: string): Promise<{
+    enabled: boolean;
+    description: string;
+} | undefined>;
+/**
+ * List all individual tools with their status
+ */
+export declare function listAllTools(): Promise<Array<{
+    name: string;
+    enabled: boolean;
+    description: string;
+}>>;
+export {};

package/lib/shared/tools.js

@@ -0,0 +1,156 @@
+/*
+ * 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 Cache from './cache.js';
+export const TOOLSETS = ['orgs', 'data', 'users', 'metadata', 'testing', 'experimental'];
+/*
+ * These are tools that are always enabled at startup. They cannot be disabled and they cannot be dynamically enabled.
+ */
+export const CORE_TOOLS = ['sf-get-username', 'sf-resume', 'sf-enable-tool', 'sf-list-tools'];
+/**
+ * Determines which toolsets should be enabled based on the provided toolsets array and dynamic tools flag.
+ *
+ * @param {Array<Toolset | 'all'>} toolsets - Array of toolsets to enable. Can include 'all' to enable all non-experimental toolsets.
+ * @param {boolean} dynamicTools - Flag indicating whether dynamic tools should be enabled. When true, only core and dynamic toolsets are enabled.
+ * @returns {Record<Toolset | 'dynamic' | 'core', boolean>} Object mapping each toolset to a boolean indicating whether it should be enabled.
+ *
+ * @example
+ * // Enable all toolsets except experimental
+ * determineToolsetsToEnable(['all'], false)
+ * // Returns: { core: true, data: true, dynamic: false, experimental: false, metadata: true, orgs: true, testing: true, users: true }
+ *
+ * @example
+ * // Enable only dynamic tools
+ * determineToolsetsToEnable([], true)
+ * // Returns: { core: true, data: false, dynamic: true, experimental: false, metadata: false, orgs: false, testing: false, users: false }
+ *
+ * @example
+ * // Enable specific toolsets
+ * determineToolsetsToEnable(['data', 'users'], false)
+ * // Returns: { core: true, data: true, dynamic: false, experimental: false, metadata: false, orgs: false, testing: false, users: true }
+ */
+export function determineToolsetsToEnable(toolsets, dynamicTools) {
+    if (dynamicTools) {
+        return {
+            core: true,
+            data: true,
+            dynamic: true,
+            experimental: false,
+            metadata: true,
+            orgs: true,
+            testing: true,
+            users: true,
+        };
+    }
+    if (toolsets.includes('all')) {
+        return {
+            core: true,
+            data: true,
+            dynamic: false,
+            experimental: false,
+            metadata: true,
+            orgs: true,
+            testing: true,
+            users: true,
+        };
+    }
+    return {
+        core: true,
+        data: toolsets.includes('data'),
+        dynamic: false,
+        experimental: toolsets.includes('experimental'),
+        metadata: toolsets.includes('metadata'),
+        orgs: toolsets.includes('orgs'),
+        testing: toolsets.includes('testing'),
+        users: toolsets.includes('users'),
+    };
+}
+/**
+ * Add a tool to the cache
+ */
+export async function addTool(tool, name) {
+    const existingTools = await Cache.safeGet('tools');
+    // Check if tool already exists
+    const existingTool = existingTools.find((t) => t.name === name);
+    if (existingTool) {
+        return { success: false, message: `Tool ${name} already exists` };
+    }
+    await Cache.safeUpdate('tools', (toolsArray) => {
+        const newTool = {
+            tool,
+            name,
+        };
+        return [...toolsArray, newTool];
+    });
+    return { success: true, message: `Added tool ${name}` };
+}
+/**
+ * Enable an individual tool
+ */
+export async function enableTool(toolName) {
+    const tools = await Cache.safeGet('tools');
+    const toolInfo = tools.find((t) => t.name === toolName);
+    if (!toolInfo) {
+        return { success: false, message: `Tool ${toolName} not found` };
+    }
+    if (toolInfo.tool.enabled) {
+        return { success: false, message: `Tool ${toolName} is already enabled` };
+    }
+    // Enable the tool directly
+    toolInfo.tool.enable();
+    return { success: true, message: `Tool ${toolName} enabled` };
+}
+/**
+ * Disable an individual tool
+ */
+export async function disableTool(toolName) {
+    const tools = await Cache.safeGet('tools');
+    const toolInfo = tools.find((t) => t.name === toolName);
+    if (!toolInfo) {
+        return { success: false, message: `Tool ${toolName} not found` };
+    }
+    if (!toolInfo.tool.enabled) {
+        return { success: false, message: `Tool ${toolName} is already disabled` };
+    }
+    // Disable the tool directly
+    toolInfo.tool.disable();
+    return { success: true, message: `Tool ${toolName} disabled` };
+}
+/**
+ * Get individual tool status
+ */
+export async function getToolStatus(toolName) {
+    const tools = await Cache.safeGet('tools');
+    const toolInfo = tools.find((t) => t.name === toolName);
+    if (!toolInfo) {
+        return;
+    }
+    return {
+        enabled: toolInfo.tool.enabled,
+        description: toolInfo.tool.description ?? '',
+    };
+}
+/**
+ * List all individual tools with their status
+ */
+export async function listAllTools() {
+    const tools = await Cache.safeGet('tools');
+    return tools.map((toolInfo) => ({
+        name: toolInfo.name,
+        enabled: toolInfo.tool.enabled,
+        description: toolInfo.tool.description ?? '',
+    }));
+}
+//# sourceMappingURL=tools.js.map

package/lib/shared/types.d.ts

@@ -1,5 +1,6 @@
 import { ConfigInfo } from '@salesforce/core';
 import { type Nullable } from '@salesforce/ts-types';
+import { RegisteredTool } from '@modelcontextprotocol/sdk/server/mcp.js';
 export type ConfigInfoWithCache = {
     key: string;
     location?: ConfigInfo['location'];
@@ -26,3 +27,7 @@ export type ToolTextResponse = {
         text: string;
     }>;
 };
+export type ToolInfo = {
+    tool: RegisteredTool;
+    name: string;
+};

package/lib/tools/dynamic/index.d.ts

@@ -0,0 +1,2 @@
+export { registerToolEnableTool } from './sf-enable-tool.js';
+export { registerToolListTools } from './sf-list-tools.js';

package/lib/tools/dynamic/index.js

@@ -0,0 +1,18 @@
+/*
+ * 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.
+ */
+export { registerToolEnableTool } from './sf-enable-tool.js';
+export { registerToolListTools } from './sf-list-tools.js';
+//# sourceMappingURL=index.js.map

package/lib/tools/dynamic/sf-enable-tool.d.ts

@@ -0,0 +1,2 @@
+import { SfMcpServer } from '../../sf-mcp-server.js';
+export declare function registerToolEnableTool(server: SfMcpServer): void;

package/lib/tools/dynamic/sf-enable-tool.js

@@ -0,0 +1,38 @@
+/*
+ * 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 { z } from 'zod';
+import { textResponse } from '../../shared/utils.js';
+import { enableTool } from '../../shared/tools.js';
+const enableToolParamsSchema = z.object({
+    tool: z.string().describe('The name of the tool to enable'),
+});
+export function registerToolEnableTool(server) {
+    server.tool('sf-enable-tool', `Enable one of the tools the Salesforce MCP server provides.
+
+AGENT INSTRUCTIONS:
+use sf-list-all-tools first to learn what tools are available for enabling'`, enableToolParamsSchema.shape, {
+        title: 'Enable an individual tool',
+        readOnlyHint: true,
+        openWorldHint: false,
+    }, async ({ tool }) => {
+        const result = await enableTool(tool);
+        if (result.success) {
+            server.sendToolListChanged();
+        }
+        return textResponse(result.message, !result.success);
+    });
+}
+//# sourceMappingURL=sf-enable-tool.js.map

package/lib/tools/dynamic/sf-list-tools.d.ts

@@ -0,0 +1,2 @@
+import { SfMcpServer } from '../../sf-mcp-server.js';
+export declare function registerToolListTools(server: SfMcpServer): void;