@salesforce/mcp 0.17.1 → 0.17.2-dev.1

package/lib/index.d.ts

@@ -4,7 +4,7 @@ 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<("all" | "users" | "data" | "orgs" | "metadata" | "testing" | "experimental")[] | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        toolsets: import("@oclif/core/interfaces").OptionFlag<(import("@salesforce/mcp-provider-api/src/toolset.js").Toolset | "all")[] | 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>;

package/lib/index.js

@@ -14,13 +14,15 @@
  * limitations under the License.
  */
 /* eslint-disable no-console */
+import { TOOLSETS } from '@salesforce/mcp-provider-api';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import { Command, Flags, ux } from '@oclif/core';
-import Cache from './shared/cache.js';
+import Cache from './utils/cache.js';
 import { Telemetry } from './telemetry.js';
 import { SfMcpServer } from './sf-mcp-server.js';
-import { maybeBuildIndex } from './assets.js';
-import { TOOLSETS, registerToolsets } from './registry.js';
+import { maybeBuildIndex } from './utils/assets.js';
+import { registerToolsets } from './utils/registry-utils.js';
+import { Services } from './services.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.
@@ -130,10 +132,10 @@ You can also use special values to control access to orgs:
             },
         }, {
             telemetry: this.telemetry,
-            dynamicTools: flags['dynamic-tools'] ?? false,
         });
         await maybeBuildIndex(this.config.dataDir);
-        registerToolsets(flags.toolsets ?? ['all'], flags['dynamic-tools'] ?? false, server);
+        const services = new Services({ telemetry: this.telemetry, dataDir: this.config.dataDir });
+        await registerToolsets(flags.toolsets ?? ['all'], flags['dynamic-tools'] ?? false, server, services);
         const transport = new StdioServerTransport();
         await server.connect(transport);
         console.error(`✅ Salesforce MCP Server v${this.config.version} running on stdio`);

package/lib/main-server-provider.d.ts

@@ -0,0 +1,7 @@
+import { McpProvider, McpTool, Services } from '@salesforce/mcp-provider-api';
+import { SfMcpServer } from './sf-mcp-server.js';
+export declare function createDynamicServerTools(server: SfMcpServer): McpTool[];
+export declare class MainServerProvider extends McpProvider {
+    getName(): string;
+    provideTools(services: Services): Promise<McpTool[]>;
+}

package/lib/main-server-provider.js

@@ -0,0 +1,31 @@
+/*
+ * 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 { McpProvider } from '@salesforce/mcp-provider-api';
+import { EnableToolsMcpTool } from './tools/sf-enable-tools.js';
+import { ListToolsMcpTool } from './tools/sf-list-tools.js';
+import { SuggestCliCommandMcpTool } from './tools/sf-suggest-cli-command.js';
+export function createDynamicServerTools(server) {
+    return [new EnableToolsMcpTool(server), new ListToolsMcpTool()];
+}
+export class MainServerProvider extends McpProvider {
+    getName() {
+        return 'MainServerProvider';
+    }
+    async provideTools(services) {
+        return Promise.resolve([new SuggestCliCommandMcpTool(services)]);
+    }
+}
+//# sourceMappingURL=main-server-provider.js.map

package/lib/registry.d.ts

@@ -1,29 +1,3 @@
-import { SfMcpServer } from './sf-mcp-server.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>;
-export declare function registerToolsets(toolsets: Array<Toolset | 'all'>, dynamicTools: boolean, server: SfMcpServer): void;
-export {};
+import { McpProvider } from '@salesforce/mcp-provider-api';
+/** -------- ADD McpProvider INSTANCES HERE ------------------------------------------------------------------------- */
+export declare const MCP_PROVIDER_REGISTRY: McpProvider[];

package/lib/registry.js

@@ -13,118 +13,14 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { ux } from '@oclif/core';
-import * as platformCli from './modules/platform-cli/index.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.
- *
- * If you are added a new core tool, please add it to this list so that the SfMcpServer knows about it.
- */
-export const CORE_TOOLS = [
-    'sf-get-username',
-    'sf-resume',
-    'sf-enable-tools',
-    'sf-list-tools',
-    'sf-suggest-cli-command',
+import { DxCoreMcpProvider } from '@salesforce/mcp-provider-dx-core';
+import { CodeAnalyzerMcpProvider } from '@salesforce/mcp-provider-code-analyzer';
+import { MainServerProvider } from './main-server-provider.js';
+/** -------- ADD McpProvider INSTANCES HERE ------------------------------------------------------------------------- */
+export const MCP_PROVIDER_REGISTRY = [
+    new MainServerProvider(),
+    new DxCoreMcpProvider(),
+    new CodeAnalyzerMcpProvider(),
+    // Add new instances here
 ];
-/**
- * The tool registry maps toolsets to functions that register tools with the server.
- *
- * When adding a new tool, you must add it to the appropriate toolset in this registry.
- */
-const TOOL_REGISTRY = {
-    core: [platformCli.getUsername, platformCli.resume, platformCli.suggestCliCommand],
-    dynamic: [platformCli.enableTools, platformCli.listTools],
-    orgs: [platformCli.listAllOrgs],
-    data: [platformCli.queryOrg],
-    users: [platformCli.assignPermissionSet],
-    testing: [platformCli.testAgent, platformCli.testApex],
-    metadata: [platformCli.deployMetadata, platformCli.retrieveMetadata],
-    experimental: [
-        platformCli.orgOpen,
-        platformCli.createScratchOrg,
-        platformCli.deleteOrg,
-        platformCli.createOrgSnapshot,
-    ],
-};
-/**
- * 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'),
-    };
-}
-function registerToolset(toolset, server) {
-    if (TOOL_REGISTRY[toolset]) {
-        for (const tool of TOOL_REGISTRY[toolset]) {
-            tool(server);
-        }
-    }
-    else {
-        throw new Error(`Failed to register toolset ${toolset}.`);
-    }
-}
-export function registerToolsets(toolsets, dynamicTools, server) {
-    const toolsetsToEnable = determineToolsetsToEnable(toolsets, dynamicTools);
-    for (const toolset of ['core', 'dynamic', ...TOOLSETS]) {
-        if (!toolsetsToEnable[toolset]) {
-            ux.stderr(`Skipping registration of ${toolset} tools`);
-            continue;
-        }
-        ux.stderr(`Registering ${toolset} tools`);
-        registerToolset(toolset, server);
-    }
-}
 //# sourceMappingURL=registry.js.map

package/lib/scripts/build-index.js

@@ -36,7 +36,7 @@ const main = async () => {
     }
     // Define the output file paths
     const commandsPath = path.join(outputDir, 'sf-commands.json');
-    const faissIndexPath = path.join(outputDir, 'faiss-index.bin');
+    const faissIndexPath = path.join(outputDir, 'commands-index.bin');
     ux.stderr('Starting offline data preparation...');
     // 1. Ensure output directory exists
     if (!fs.existsSync(outputDir)) {

package/lib/services.d.ts

@@ -0,0 +1,12 @@
+import { Services as IServices, TelemetryService, OrgService, ConfigService } from '@salesforce/mcp-provider-api';
+export declare class Services implements IServices {
+    private readonly telemetry;
+    private readonly dataDir;
+    constructor(opts: {
+        telemetry: TelemetryService | undefined;
+        dataDir: string;
+    });
+    getTelemetryService(): TelemetryService;
+    getConfigService(): ConfigService;
+    getOrgService(): OrgService;
+}

package/lib/services.js

@@ -0,0 +1,34 @@
+import Cache from './utils/cache.js';
+import { getConnection, getDefaultTargetOrg, getDefaultTargetDevHub, getAllAllowedOrgs, findOrgByUsernameOrAlias, } from './utils/auth.js';
+export class Services {
+    telemetry;
+    dataDir;
+    constructor(opts) {
+        this.telemetry = opts.telemetry ? opts.telemetry : new NoopTelemetryService();
+        this.dataDir = opts.dataDir;
+    }
+    getTelemetryService() {
+        return this.telemetry;
+    }
+    getConfigService() {
+        return {
+            getDataDir: () => this.dataDir,
+        };
+    }
+    getOrgService() {
+        return {
+            getAllowedOrgUsernames: async () => Cache.safeGet('allowedOrgs'),
+            getAllowedOrgs: () => getAllAllowedOrgs(),
+            getConnection: (username) => getConnection(username),
+            getDefaultTargetOrg: () => getDefaultTargetOrg(),
+            getDefaultTargetDevHub: () => getDefaultTargetDevHub(),
+            findOrgByUsernameOrAlias: (allOrgs, usernameOrAlias) => findOrgByUsernameOrAlias(allOrgs, usernameOrAlias),
+        };
+    }
+}
+class NoopTelemetryService {
+    sendEvent(_eventName, _event) {
+        // no-op
+    }
+}
+//# sourceMappingURL=services.js.map

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

@@ -1,11 +1,13 @@
-import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
-import { Implementation } from '@modelcontextprotocol/sdk/types.js';
+import { McpServer, RegisteredTool, ToolCallback } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { Implementation, ToolAnnotations } from '@modelcontextprotocol/sdk/types.js';
 import { ServerOptions } from '@modelcontextprotocol/sdk/server/index.js';
+import { ZodRawShape } from 'zod';
 import { Telemetry } from './telemetry.js';
-import { RateLimitConfig } from './shared/rate-limiter.js';
+import { RateLimitConfig } from './utils/rate-limiter.js';
 type ToolMethodSignatures = {
     tool: McpServer['tool'];
     connect: McpServer['connect'];
+    registerTool: McpServer['registerTool'];
 };
 /**
  * Extended server options that include telemetry and rate limiting
@@ -15,8 +17,6 @@ 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.
@@ -30,7 +30,6 @@ 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?;
     /**
@@ -41,6 +40,12 @@ export declare class SfMcpServer extends McpServer implements ToolMethodSignatur
      */
     constructor(serverInfo: Implementation, options?: SfMcpServerOptions);
     connect: McpServer['connect'];
-    tool: McpServer['tool'];
+    registerTool<InputArgs extends ZodRawShape, OutputArgs extends ZodRawShape>(name: string, config: {
+        title?: string;
+        description?: string;
+        inputSchema?: InputArgs;
+        outputSchema?: OutputArgs;
+        annotations?: ToolAnnotations;
+    }, cb: ToolCallback<InputArgs>): RegisteredTool;
 }
 export {};

package/lib/sf-mcp-server.js

@@ -15,9 +15,7 @@
  */
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { Logger } from '@salesforce/core';
-import { addTool } from './modules/platform-cli/utils/tools.js';
-import { createRateLimiter } from './shared/rate-limiter.js';
-import { CORE_TOOLS } from './registry.js';
+import { createRateLimiter } from './utils/rate-limiter.js';
 /**
  * A server implementation that extends the base MCP server with telemetry and rate limiting capabilities.
  *
@@ -30,7 +28,6 @@ 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;
     /**
@@ -42,7 +39,6 @@ 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);
@@ -75,10 +71,8 @@ export class SfMcpServer extends McpServer {
             });
         }
     };
-    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) => {
+    registerTool(name, config, cb) {
+        const wrappedCb = async (args, extra) => {
             this.logger.debug(`Tool ${name} called`);
             // Check rate limit before executing tool
             if (this.rateLimiter) {
@@ -103,7 +97,7 @@ export class SfMcpServer extends McpServer {
                 this.logger.debug(`Tool ${name} rate check passed. Remaining: ${rateLimitResult.remaining}`);
             }
             const startTime = Date.now();
-            const result = await cb(args);
+            const result = await cb(args, extra);
             const runtimeMs = Date.now() - startTime;
             this.logger.debug(`Tool ${name} completed in ${runtimeMs}ms`);
             if (result.isError)
@@ -115,17 +109,8 @@ export class SfMcpServer extends McpServer {
             });
             return result;
         };
-        // @ts-expect-error because we no longer know what the type of rest is
-        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);
-            });
-        }
+        const tool = super.registerTool(name, config, wrappedCb);
         return tool;
-    };
+    }
 }
 //# sourceMappingURL=sf-mcp-server.js.map

package/lib/telemetry.d.ts

@@ -1,6 +1,7 @@
 import { Attributes } from '@salesforce/telemetry';
 import { Config } from '@oclif/core';
-export declare class Telemetry {
+import { TelemetryService } from '@salesforce/mcp-provider-api/src/index.js';
+export declare class Telemetry implements TelemetryService {
     private readonly config;
     private attributes;
     /**

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

@@ -0,0 +1,23 @@
+import { z } from 'zod';
+import { McpTool, McpToolConfig, Toolset } from '@salesforce/mcp-provider-api';
+import { CallToolResult } from '@modelcontextprotocol/sdk/types.js';
+import { SfMcpServer } from '../sf-mcp-server.js';
+declare const enableToolsParamsSchema: z.ZodObject<{
+    tools: z.ZodArray<z.ZodString, "many">;
+}, "strip", z.ZodTypeAny, {
+    tools: string[];
+}, {
+    tools: string[];
+}>;
+type InputArgs = z.infer<typeof enableToolsParamsSchema>;
+type InputArgsShapeType = typeof enableToolsParamsSchema.shape;
+type OutputArgsShapeType = z.ZodRawShape;
+export declare class EnableToolsMcpTool extends McpTool<InputArgsShapeType, OutputArgsShapeType> {
+    private readonly server;
+    constructor(server: SfMcpServer);
+    getToolsets(): Toolset[];
+    getName(): string;
+    getConfig(): McpToolConfig<InputArgsShapeType, OutputArgsShapeType>;
+    exec(input: InputArgs): Promise<CallToolResult>;
+}
+export {};

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

@@ -0,0 +1,77 @@
+/*
+ * 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 { McpTool, Toolset } from '@salesforce/mcp-provider-api';
+import { enableTools as utilEnableTools } from '../utils/tools.js';
+const enableToolsParamsSchema = z.object({
+    tools: z.array(z.string()).describe('The names of the tools to enable'),
+});
+export class EnableToolsMcpTool extends McpTool {
+    server;
+    constructor(server) {
+        super();
+        this.server = server;
+    }
+    getToolsets() {
+        return [Toolset.CORE];
+    }
+    getName() {
+        return 'sf-enable-tools';
+    }
+    getConfig() {
+        return {
+            title: 'Enable Salesforce MCP tools',
+            description: `Enable one or more of the tools the Salesforce MCP server provides.
+
+AGENT INSTRUCTIONS:
+Use sf-list-all-tools first to learn what tools are available for enabling.
+Once you have enabled the tool, you MUST invoke that tool to accomplish the user's original request - DO NOT USE A DIFFERENT TOOL OR THE COMMAND LINE.`,
+            inputSchema: enableToolsParamsSchema.shape,
+            outputSchema: undefined,
+            annotations: {
+                title: 'Enable Salesforce MCP tools',
+                readOnlyHint: true,
+                openWorldHint: false,
+            },
+        };
+    }
+    async exec(input) {
+        if (input.tools.length === 0) {
+            return {
+                isError: true,
+                content: [
+                    {
+                        type: 'text',
+                        text: 'No tools specified to enable.',
+                    },
+                ],
+            };
+        }
+        const results = await utilEnableTools(input.tools);
+        this.server.sendToolListChanged();
+        const isError = results.some((result) => !result.success);
+        return {
+            isError,
+            content: [
+                {
+                    type: 'text',
+                    text: results.map((result) => result.message).join('\n'),
+                },
+            ],
+        };
+    }
+}
+//# sourceMappingURL=sf-enable-tools.js.map

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

@@ -0,0 +1,8 @@
+import { McpTool, McpToolConfig, Toolset } from '@salesforce/mcp-provider-api';
+import { CallToolResult } from '@modelcontextprotocol/sdk/types.js';
+export declare class ListToolsMcpTool extends McpTool {
+    getToolsets(): Toolset[];
+    getName(): string;
+    getConfig(): McpToolConfig;
+    exec(): Promise<CallToolResult>;
+}

package/lib/{modules/platform-cli → tools}/sf-list-tools.js

@@ -13,10 +13,19 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { textResponse } from '../../shared/utils.js';
-import { listAllTools } from './utils/tools.js';
-export function listTools(server) {
-    server.tool('sf-list-tools', `List all available tools this Salesforce MCP server can offer, providing the enabled status and description of each.
+import { McpTool, Toolset } from '@salesforce/mcp-provider-api';
+import { listAllTools } from '../utils/tools.js';
+export class ListToolsMcpTool extends McpTool {
+    getToolsets() {
+        return [Toolset.CORE];
+    }
+    getName() {
+        return 'sf-list-tools';
+    }
+    getConfig() {
+        return {
+            title: 'List all individual tools',
+            description: `List all available tools this Salesforce MCP server can offer, providing the enabled status and description of each.
 
 AGENT INSTRUCTIONS:
 DO NOT USE THIS TOOL if you already know what tool you need - try to call the tool directly first.
@@ -27,10 +36,25 @@ ONLY use this tool if:
 
 If you find one or more tools you want to enable, call sf-enable-tools with all the tool names.
 Once you have enabled a tool, you MUST invoke the tool to accomplish the user's original request - DO NOT USE A DIFFERENT TOOL OR THE COMMAND LINE.
-Once a tool has been enabled, you do not need to call sf-list-tools again - instead, invoke the desired tool directly.`, {
-        title: 'List all individual tools',
-        readOnlyHint: true,
-        openWorldHint: false,
-    }, async () => textResponse(JSON.stringify(await listAllTools(), null, 2)));
+Once a tool has been enabled, you do not need to call sf-list-tools again - instead, invoke the desired tool directly.`,
+            inputSchema: undefined,
+            outputSchema: undefined,
+            annotations: {
+                readOnlyHint: true,
+                openWorldHint: false,
+            },
+        };
+    }
+    async exec() {
+        return {
+            isError: false,
+            content: [
+                {
+                    type: 'text',
+                    text: JSON.stringify(await listAllTools(), null, 2),
+                },
+            ],
+        };
+    }
 }
 //# sourceMappingURL=sf-list-tools.js.map

package/lib/tools/sf-suggest-cli-command.d.ts

@@ -0,0 +1,25 @@
+import { z } from 'zod';
+import { McpTool, McpToolConfig, Toolset, Services } from '@salesforce/mcp-provider-api';
+import { CallToolResult } from '@modelcontextprotocol/sdk/types.js';
+/**
+ * Suggest a Salesforce CLI (sf) command based on user input.
+ */
+declare const suggestCliCommandParamsSchema: z.ZodObject<{
+    query: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    query: string;
+}, {
+    query: string;
+}>;
+type InputArgs = z.infer<typeof suggestCliCommandParamsSchema>;
+type InputArgsShape = typeof suggestCliCommandParamsSchema.shape;
+type OutputArgsShape = z.ZodRawShape;
+export declare class SuggestCliCommandMcpTool extends McpTool<InputArgsShape, OutputArgsShape> {
+    private readonly services;
+    constructor(services: Services);
+    getToolsets(): Toolset[];
+    getName(): string;
+    getConfig(): McpToolConfig<InputArgsShape, OutputArgsShape>;
+    exec(input: InputArgs): Promise<CallToolResult>;
+}
+export {};