@toolplex/client 0.1.1

package/dist/mcp-server/serversCache.js

@@ -0,0 +1,100 @@
+import { ListServersResultSchema } from '../shared/serverManagerTypes.js';
+import { FileLogger } from '../shared/fileLogger.js';
+const logger = FileLogger;
+/**
+ * An in-memory cache that tracks currently installed servers.
+ * Maintains a set of server IDs for quick lookup of installed servers.
+ * Can be refreshed by querying server manager clients for their current server lists.
+ */
+export class ServersCache {
+    constructor() {
+        this._serverIds = null;
+        this._serverIds = null;
+    }
+    /**
+     * Initialize the cache with a list of servers, e.g. from initialize() succeeded list.
+     * Only tracks server IDs.
+     */
+    init(servers) {
+        this._serverIds = new Set(servers.map((s) => s.server_id));
+    }
+    /**
+     * Update the cache with a new list of servers, e.g. after calling listServersHandler.
+     * This does not imply initialization, but is meant to refresh the cache with the latest list.
+     * Only tracks server IDs.
+     */
+    updateServers(servers) {
+        this._serverIds = new Set(servers.map((s) => s.server_id));
+    }
+    /**
+     * Returns true if the server is installed (present in the cache).
+     * Throws an error if the cache is not initialized.
+     */
+    isInstalled(serverId) {
+        if (!this.isInitialized()) {
+            throw new Error('ServersCache not initialized');
+        }
+        if (!serverId) {
+            throw new Error(`Invalid serverId: "${serverId}"`);
+        }
+        return this._serverIds.has(serverId);
+    }
+    /**
+     * Get all cached server IDs.
+     */
+    getServerIds() {
+        if (!this._serverIds) {
+            throw new Error('ServersCache not initialized');
+        }
+        return Array.from(this._serverIds);
+    }
+    /**
+     * Refresh the cache by calling list_servers on all server manager clients.
+     * This follows the pattern in handleListServers (listServersHandler.ts):
+     * - Use sendRequest('list_servers', {}) on each client.
+     * - Validate/parse the response with ListServersResultSchema.
+     * - Collect all servers from all runtimes.
+     * @param serverManagerClients - Record of server manager clients (e.g. from Registry)
+     */
+    async refreshCache(serverManagerClients) {
+        const allServerIds = new Set();
+        for (const [runtime, client] of Object.entries(serverManagerClients)) {
+            try {
+                const response_data = await client.sendRequest('list_servers', {});
+                if (response_data.error) {
+                    await logger.warn(`Error from server manager client "${runtime}": ${response_data.error}`);
+                    continue;
+                }
+                const parsed = ListServersResultSchema.safeParse(response_data);
+                if (!parsed.success) {
+                    await logger.warn(`Failed to parse list_servers response from "${runtime}": ${JSON.stringify(response_data)}`);
+                    continue;
+                }
+                if (parsed.data.servers && parsed.data.servers.length > 0) {
+                    for (const server of parsed.data.servers) {
+                        if (server && typeof server.server_id === 'string') {
+                            allServerIds.add(server.server_id);
+                        }
+                    }
+                }
+            }
+            catch (err) {
+                await logger.warn(`Exception while refreshing cache from server manager client "${runtime}": ${err instanceof Error ? err.message : String(err)}`);
+                // Continue to next client
+            }
+        }
+        this._serverIds = allServerIds;
+    }
+    /**
+     * Check if the cache is initialized
+     */
+    isInitialized() {
+        return this._serverIds !== null;
+    }
+    /**
+     * Reset the cache
+     */
+    reset() {
+        this._serverIds = null;
+    }
+}

package/dist/mcp-server/staticPrompts.d.ts

@@ -0,0 +1,6 @@
+export declare const PRE_INITIALIZATION_PROMPTS: {
+    tools_initialization_error: string;
+    enforce_init_toolplex: string;
+    unknown_tool: string;
+    unexpected_error: string;
+};

package/dist/mcp-server/staticPrompts.js

@@ -0,0 +1,6 @@
+export const PRE_INITIALIZATION_PROMPTS = {
+    tools_initialization_error: `ERROR: Unable to connect to ToolPlex. Please check your API key and network connection. If the problem persists, contact support at support@toolplex.ai for assistance.`,
+    enforce_init_toolplex: `ERROR: Attempted to call tool {TOOL_NAME} before calling initalize_toolplex().\nPlease init and retry.`,
+    unknown_tool: 'Unknown tool: {TOOL_NAME}. Use list_toolplex_tools() to see available tools.',
+    unexpected_error: 'Unexpected error: {ERROR}',
+};

package/dist/mcp-server/toolDefinitionsCache.d.ts

@@ -0,0 +1,33 @@
+import { Tool } from '@modelcontextprotocol/sdk/types.js';
+import { ToolplexApiService } from './toolplexApi/service.js';
+import { ClientContext } from './clientContext.js';
+export declare class ToolDefinitionsCache {
+    private _tools;
+    private _version;
+    constructor();
+    /**
+     * Initialize tools cache by fetching tools from API
+     * Handles errors if fetching fails, but does not rethrow.
+     */
+    init(service: ToolplexApiService, _clientContext: ClientContext): Promise<void>;
+    /**
+     * Get all cached tool definitions
+     */
+    getTools(): Tool[];
+    /**
+     * Get a specific tool by name from the cache
+     */
+    getTool(name: string): Tool;
+    /**
+     * Get the version of the current tools
+     */
+    getVersion(): string;
+    /**
+     * Check if the cache is initialized
+     */
+    isInitialized(): boolean;
+    /**
+     * Reset the cache
+     */
+    reset(): void;
+}

package/dist/mcp-server/toolDefinitionsCache.js

@@ -0,0 +1,67 @@
+export class ToolDefinitionsCache {
+    constructor() {
+        this._tools = null;
+        this._version = null;
+        this._tools = null;
+        this._version = null;
+    }
+    /**
+     * Initialize tools cache by fetching tools from API
+     * Handles errors if fetching fails, but does not rethrow.
+     */
+    async init(service, _clientContext) {
+        try {
+            const toolsResponse = await service.getTools();
+            this._tools = toolsResponse.tools;
+            this._version = toolsResponse._version;
+        }
+        catch {
+            this._tools = null;
+            this._version = null;
+        }
+    }
+    /**
+     * Get all cached tool definitions
+     */
+    getTools() {
+        if (!this._tools) {
+            throw new Error('ToolDefinitionsCache not initialized');
+        }
+        return this._tools;
+    }
+    /**
+     * Get a specific tool by name from the cache
+     */
+    getTool(name) {
+        if (!this._tools) {
+            throw new Error('ToolDefinitionsCache not initialized');
+        }
+        const tool = this._tools.find((t) => t.name === name);
+        if (!tool) {
+            throw new Error(`Tool "${name}" not found in cache`);
+        }
+        return tool;
+    }
+    /**
+     * Get the version of the current tools
+     */
+    getVersion() {
+        if (!this._version) {
+            throw new Error('ToolDefinitionsCache not initialized');
+        }
+        return this._version;
+    }
+    /**
+     * Check if the cache is initialized
+     */
+    isInitialized() {
+        return this._tools !== null;
+    }
+    /**
+     * Reset the cache
+     */
+    reset() {
+        this._tools = null;
+        this._version = null;
+    }
+}

package/dist/mcp-server/toolHandlers/callToolHandler.d.ts

@@ -0,0 +1,3 @@
+import { CallToolResult } from '@modelcontextprotocol/sdk/types.js';
+import { CallToolParams } from '../../shared/mcpServerTypes.js';
+export declare function handleCallTool(params: CallToolParams): Promise<CallToolResult>;

package/dist/mcp-server/toolHandlers/callToolHandler.js

@@ -0,0 +1,79 @@
+import { findServerManagerClient } from './serverManagerUtils.js';
+import { CallToolResultSchema } from '../../shared/serverManagerTypes.js';
+import { FileLogger } from '../../shared/fileLogger.js';
+import Registry from '../registry.js';
+const logger = FileLogger;
+export async function handleCallTool(params) {
+    await logger.debug(`Handling call tool request with params: ${JSON.stringify(params)}`);
+    const serverManagerClients = Registry.getServerManagerClients();
+    const telemetryLogger = Registry.getTelemetryLogger();
+    const promptsCache = Registry.getPromptsCache();
+    const clientContext = Registry.getClientContext();
+    const startTime = Date.now();
+    // Get the CallToolObserver from the PolicyEnforcer via Registry
+    const policyEnforcer = Registry.getPolicyEnforcer();
+    const callToolObserver = policyEnforcer.getCallToolObserver();
+    try {
+        // Enforce call tool policy
+        policyEnforcer.enforceCallToolPolicy(params.server_id);
+        const client = await findServerManagerClient(params.server_id, serverManagerClients);
+        const response = await client.sendRequest('call_tool', params);
+        if ('error' in response) {
+            throw new Error(`Failed to call tool with params: ${JSON.stringify(params)}, error message: ${response.error.message}`);
+        }
+        const parsed = CallToolResultSchema.safeParse(response);
+        if (!parsed.success) {
+            throw new Error(`Invalid call_tool response: ${parsed.error}`);
+        }
+        // Record the successful tool call for Playbook policy enforcement
+        callToolObserver.recordCall(params.server_id, params.tool_name);
+        const result = parsed.data.result;
+        const content = Array.isArray(result) ? result : [result];
+        if (!clientContext.permissions.enable_read_only_mode &&
+            clientContext.clientMode !== 'restricted') {
+            content.push({
+                type: 'text',
+                text: promptsCache.getPrompt('tool_call_next_steps'),
+            });
+        }
+        await logger.debug('Tool called successfully');
+        await telemetryLogger.log('client_call_tool', {
+            success: true,
+            log_context: {
+                server_id: params.server_id,
+                tool_name: params.tool_name,
+            },
+            latency_ms: Date.now() - startTime,
+        });
+        return {
+            role: 'system',
+            content: content,
+        };
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : promptsCache.getPrompt('unexpected_error');
+        await logger.error(`Failed to call tool: ${errorMessage}`);
+        await telemetryLogger.log('client_call_tool', {
+            success: false,
+            log_context: {
+                server_id: params.server_id,
+                tool_name: params.tool_name,
+            },
+            pii_sanitized_error_message: errorMessage,
+            latency_ms: Date.now() - startTime,
+        });
+        return {
+            role: 'system',
+            content: [
+                {
+                    type: 'text',
+                    text: promptsCache
+                        .getPrompt('tool_call_failure')
+                        .replace('{ERROR}', errorMessage)
+                        .replace('{SERVER_ID}', params.server_id)
+                        .replace('{TOOL_NAME}', params.tool_name),
+                },
+            ],
+        };
+    }
+}

package/dist/mcp-server/toolHandlers/getServerConfigHandler.d.ts

@@ -0,0 +1,3 @@
+import { CallToolResult } from '@modelcontextprotocol/sdk/types.js';
+import { GetServerConfigParams } from '../../shared/mcpServerTypes.js';
+export declare function handleGetServerConfig(params: GetServerConfigParams): Promise<CallToolResult>;

package/dist/mcp-server/toolHandlers/getServerConfigHandler.js

@@ -0,0 +1,69 @@
+import { FileLogger } from '../../shared/fileLogger.js';
+import { findServerManagerClient } from './serverManagerUtils.js';
+import Registry from '../registry.js';
+const logger = FileLogger;
+export async function handleGetServerConfig(params) {
+    const startTime = Date.now();
+    const serverManagerClients = Registry.getServerManagerClients();
+    const telemetryLogger = Registry.getTelemetryLogger();
+    const promptsCache = Registry.getPromptsCache();
+    const policyEnforcer = Registry.getPolicyEnforcer();
+    try {
+        const server_id = params.server_id;
+        if (!server_id) {
+            throw new Error('Missing server_id');
+        }
+        // Check if server is blocked using policy enforcer
+        policyEnforcer.enforceUseServerPolicy(server_id);
+        await logger.debug(`Getting config for server: ${server_id}`);
+        const client = await findServerManagerClient(server_id, serverManagerClients);
+        const response_data = await client.sendRequest('get_server_config', { server_id });
+        if ('error' in response_data) {
+            throw new Error(`Failed to get config for server_id ${server_id}, error message: ${response_data.error.message}`);
+        }
+        // The config is returned directly as an object
+        const config = response_data;
+        await logger.debug('Successfully retrieved server config');
+        await telemetryLogger.log('client_get_server_config', {
+            success: true,
+            log_context: {
+                server_id,
+            },
+            latency_ms: Date.now() - startTime,
+        });
+        return {
+            role: 'system',
+            content: [
+                {
+                    type: 'text',
+                    text: promptsCache.getPrompt('get_server_config_header').replace('{SERVER_ID}', server_id) +
+                        '\n' +
+                        JSON.stringify(config, null, 2),
+                },
+            ],
+        };
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : promptsCache.getPrompt('unexpected_error');
+        await logger.error(`Failed to get server config: ${errorMessage}`);
+        await telemetryLogger.log('client_get_server_config', {
+            success: false,
+            log_context: {
+                server_id: params.server_id,
+            },
+            pii_sanitized_error_message: errorMessage,
+            latency_ms: Date.now() - startTime,
+        });
+        return {
+            role: 'system',
+            content: [
+                {
+                    type: 'text',
+                    text: promptsCache
+                        .getPrompt('get_server_config_failure')
+                        .replace('{ERROR}', errorMessage),
+                },
+            ],
+        };
+    }
+}

package/dist/mcp-server/toolHandlers/initHandler.d.ts

@@ -0,0 +1,3 @@
+import { CallToolResult } from '@modelcontextprotocol/sdk/types.js';
+import { InitializeToolplexParams } from '../../shared/mcpServerTypes.js';
+export declare function handleInitialize(params: InitializeToolplexParams): Promise<CallToolResult>;

package/dist/mcp-server/toolHandlers/initHandler.js

@@ -0,0 +1,117 @@
+import { FileLogger } from '../../shared/fileLogger.js';
+import os from 'os';
+import { initServerManagersOnly } from '../utils/initServerManagers.js';
+import Registry from '../registry.js';
+const logger = FileLogger;
+export async function handleInitialize(params) {
+    const startTime = Date.now();
+    await logger.info('Initializing ToolPlex');
+    await logger.debug(`Initialization params: ${JSON.stringify(params)}`);
+    const clientContext = Registry.getClientContext();
+    const apiService = Registry.getToolplexApiService();
+    const serverManagerClients = Registry.getServerManagerClients();
+    const telemetryLogger = Registry.getTelemetryLogger();
+    const promptsCache = Registry.getPromptsCache();
+    const serversCache = Registry.getServersCache();
+    const policyEnforcer = Registry.getPolicyEnforcer();
+    await logger.debug(`Server manager clients: ${Object.keys(serverManagerClients).join(', ')}`);
+    const platform = os.platform();
+    const osName = platform === 'darwin'
+        ? 'macOS'
+        : platform === 'win32'
+            ? 'Windows'
+            : platform.charAt(0).toUpperCase() + platform.slice(1);
+    const systemInfo = {
+        os: `${osName} ${os.release()}`,
+        arch: os.arch(),
+        memory: `${Math.round(os.totalmem() / (1024 * 1024 * 1024))}GB`,
+        cpuCores: os.cpus().length,
+        workDir: process.cwd(),
+    };
+    await logger.debug('Initializing server managers and API service');
+    const [serverManagerInitResults, toolplexApiInitResponse] = await Promise.all([
+        initServerManagersOnly(serverManagerClients).catch((err) => {
+            logger.warn(`Server manager init failed: ${err}`);
+            return { succeeded: [], failures: {} };
+        }),
+        apiService.init(),
+    ]);
+    clientContext.isOrgUser = toolplexApiInitResponse.is_org_user;
+    clientContext.sessionId = toolplexApiInitResponse.session_id;
+    clientContext.permissions = toolplexApiInitResponse.permissions;
+    clientContext.flags = toolplexApiInitResponse.flags;
+    promptsCache.init(toolplexApiInitResponse.prompts);
+    // Init PolicyEnforce after setting permissions and flags
+    policyEnforcer.init(clientContext);
+    const allSucceeded = serverManagerInitResults.succeeded;
+    const allFailures = serverManagerInitResults.failures;
+    // Initialize the serversCache with the succeeded servers
+    serversCache.init(allSucceeded);
+    await logger.debug(`Total successes: ${allSucceeded.length}, Total failures: ${Object.keys(allFailures).length}`);
+    await logger.debug('Building initialization response');
+    // Safe to use prompts after init.
+    const result = {
+        role: 'system',
+        content: [
+            {
+                type: 'text',
+                text: promptsCache
+                    .getPrompt('initialization')
+                    .replace('{ARGS.os}', systemInfo.os)
+                    .replace('{ARGS.arch}', systemInfo.arch)
+                    .replace('{ARGS.memory}', systemInfo.memory)
+                    .replace('{ARGS.cpuCores}', systemInfo.cpuCores.toString())
+                    .replace('{ARGS.workDir}', systemInfo.workDir),
+            },
+        ],
+    };
+    result.content.push({
+        type: 'text',
+        text: promptsCache
+            .getPrompt('initialization_results')
+            .replace('{SUCCEEDED}', allSucceeded.map((s) => `${s.server_id} (${s.server_name})`).join(', ') || 'none')
+            .replace('{FAILURES}', Object.entries(allFailures)
+            .map(([serverId, failure]) => `${serverId} (${failure.server_name}): ${failure.error}`)
+            .join(', ') || 'none')
+            .replace('{FAILURE_NOTE}', Object.keys(allFailures).length > 0
+            ? 'Please note there were failures installing some servers. Inform the user.'
+            : ''),
+    });
+    if (clientContext.permissions.allowed_mcp_servers &&
+        clientContext.permissions.allowed_mcp_servers.length > 0) {
+        result.content.push({
+            type: 'text',
+            text: promptsCache
+                .getPrompt('allowed_mcp_servers')
+                .replace('{ALLOWED_MCP_SERVERS}', clientContext.permissions.allowed_mcp_servers.join(', ')),
+        });
+    }
+    result.content.push({
+        type: 'text',
+        text: 'Your Most Recently Used Playbooks:\n' +
+            toolplexApiInitResponse.playbooks.playbooks
+                .map((p) => `- ${p.id}: ${p.description}\n` +
+                `  Used ${p.times_used} times` +
+                (p.days_since_last_used !== null
+                    ? `, last use: ${p.days_since_last_used} ${p.days_since_last_used === 1 ? 'day' : 'days'} ago`
+                    : ''))
+                .join('\n') +
+            '\n\nMore playbooks are available through the search tool.',
+    });
+    await telemetryLogger.log('client_initialize_toolplex', {
+        session_id: toolplexApiInitResponse.session_id,
+        success: Object.keys(allFailures).length === 0,
+        log_context: {
+            os_platform: platform,
+            os_arch: systemInfo.arch,
+            cpu_cores: systemInfo.cpuCores,
+            total_memory_gb: Math.round(os.totalmem() / (1024 * 1024 * 1024)),
+            num_succeeded_servers: allSucceeded.length,
+            num_failed_servers: Object.keys(allFailures).length,
+            num_recent_playbooks: toolplexApiInitResponse.playbooks.playbooks.length,
+        },
+        latency_ms: Date.now() - startTime,
+    });
+    await logger.info('ToolPlex initialization completed');
+    return result;
+}

package/dist/mcp-server/toolHandlers/installServerHandler.d.ts

@@ -0,0 +1,3 @@
+import { CallToolResult } from '@modelcontextprotocol/sdk/types.js';
+import { InstallParams } from '../../shared/mcpServerTypes.js';
+export declare function handleInstallServer(params: InstallParams): Promise<CallToolResult>;

package/dist/mcp-server/toolHandlers/installServerHandler.js

@@ -0,0 +1,151 @@
+import { FileLogger } from '../../shared/fileLogger.js';
+import { ServerInstallResultSchema, ListToolsResultSchema, } from '../../shared/serverManagerTypes.js';
+import Registry from '../registry.js';
+import { RuntimeCheck } from '../utils/runtimeCheck.js';
+const logger = FileLogger;
+async function installServer(serverId, serverName, description, serverManagerClient, serverConfig) {
+    await logger.info(`Starting installation of tool ${serverId}: ${serverName}`);
+    await logger.debug(`Server config: ${JSON.stringify(serverConfig)}, Server ID: ${serverId}`);
+    const response = await serverManagerClient.sendRequest('install', {
+        server_id: serverId,
+        server_name: serverName,
+        description: description,
+        config: serverConfig,
+    });
+    if ('error' in response) {
+        const error = `Server installation failed: ${response.error.message}`;
+        await logger.error(error);
+        throw new Error(error);
+    }
+    const parsed = ServerInstallResultSchema.safeParse(response);
+    if (!parsed.success) {
+        throw new Error(`Invalid server install response: ${JSON.stringify(parsed.error.errors)}`);
+    }
+    logger.debug(`Install response: ${JSON.stringify(response)}`);
+    if (!response) {
+        const error = 'Server installation failed: No response received';
+        await logger.error(error);
+        throw new Error(error);
+    }
+    await logger.info(`Successfully installed tool ${serverId}`);
+    return parsed.data;
+}
+export async function handleInstallServer(params) {
+    const serverManagerClients = Registry.getServerManagerClients();
+    const telemetryLogger = Registry.getTelemetryLogger();
+    const promptsCache = Registry.getPromptsCache();
+    const serversCache = Registry.getServersCache();
+    const clientContext = Registry.getClientContext();
+    const policyEnforcer = Registry.getPolicyEnforcer();
+    const installObserver = policyEnforcer.getInstallObserver();
+    const startTime = Date.now();
+    let errorMessage;
+    try {
+        // Check if the client is in restricted mode
+        if (clientContext.clientMode === 'restricted') {
+            throw new Error('Install functionality is disabled in restricted mode.');
+        }
+        const { config, server_id, server_name } = params;
+        const description = params.description || server_name;
+        if (!config || !server_id || !server_name) {
+            throw new Error('Missing required install parameters');
+        }
+        // Validate command is installed before proceeding
+        if (config.command) {
+            await RuntimeCheck.validateCommandOrThrow(config.command);
+        }
+        // Check if server is disallowed using policy enforcer
+        policyEnforcer.enforceUseServerPolicy(server_id);
+        const runtime = config.runtime || 'node';
+        const runtimeKey = 'node';
+        const client = serverManagerClients[runtimeKey];
+        // Keep for now -- may add separate server managers for different runtimes if needed.
+        if (!client) {
+            throw new Error(`Unsupported runtime: ${runtime}`);
+        }
+        // Install server
+        const installResult = await installServer(server_id, server_name, description, client, config);
+        // After successful install, refresh the servers cache
+        await serversCache.refreshCache(serverManagerClients);
+        // List tools on the newly installed server
+        const toolsResponse = await client.sendRequest('list_tools', {
+            server_id: installResult.server_id,
+        });
+        if ('error' in toolsResponse) {
+            throw new Error(`Failed to list tools for server_id ${installResult.server_id}, error message: ${toolsResponse.error.message}`);
+        }
+        const parsed = ListToolsResultSchema.safeParse(toolsResponse);
+        if (!parsed.success) {
+            throw new Error(`Invalid list_tools response: ${JSON.stringify(parsed.error.errors)}, response was: ${JSON.stringify(toolsResponse)}`);
+        }
+        let toolsText = '';
+        const tools = parsed.data.tools || [];
+        if (tools.length > 0) {
+            toolsText = 'Available tools from this server:\n\n';
+            for (const tool of tools) {
+                toolsText += `- ${tool.name}: ${tool.description}\n`;
+                toolsText += `  Input Schema: ${JSON.stringify(tool.inputSchema, null, 2)}\n\n`;
+            }
+        }
+        await telemetryLogger.log('client_install', {
+            success: true,
+            log_context: {
+                server_id: installResult.server_id,
+            },
+            latency_ms: Date.now() - startTime,
+        });
+        const content = [
+            {
+                type: 'text',
+                text: promptsCache
+                    .getPrompt('install_success')
+                    .replace('{SERVER_ID}', installResult.server_id)
+                    .replace('{SERVER_NAME}', installResult.server_name)
+                    .replace('{TOOLS_LIST}', toolsText),
+            },
+        ];
+        if (!clientContext.permissions.enable_read_only_mode) {
+            content.push({
+                type: 'text',
+                text: promptsCache.getPrompt('install_next_steps'),
+            });
+        }
+        return {
+            role: 'system',
+            content,
+        };
+    }
+    catch (error) {
+        errorMessage =
+            error instanceof Error ? error.message : promptsCache.getPrompt('unexpected_error');
+        await logger.error(`Installation failed: ${errorMessage}`);
+        await telemetryLogger.log('client_install', {
+            success: false,
+            log_context: {
+                server_id: params.server_id,
+            },
+            pii_sanitized_error_message: errorMessage,
+            latency_ms: Date.now() - startTime,
+        });
+        const content = [
+            {
+                type: 'text',
+                text: promptsCache.getPrompt('install_failure').replace('{ERROR}', errorMessage),
+            },
+        ];
+        if (!clientContext.permissions.enable_read_only_mode) {
+            content.push({
+                type: 'text',
+                text: promptsCache.getPrompt('install_next_steps'),
+            });
+        }
+        return {
+            role: 'system',
+            content,
+        };
+    }
+    finally {
+        // Record the install action regardless of success or failure
+        installObserver.recordInstall(params.server_id);
+    }
+}

package/dist/mcp-server/toolHandlers/listServersHandler.d.ts

@@ -0,0 +1,2 @@
+import { CallToolResult } from '@modelcontextprotocol/sdk/types.js';
+export declare function handleListServers(): Promise<CallToolResult>;