@toolplex/client 0.1.1 → 0.1.3

package/dist/mcp-server/toolDefinitionsCache.js

@@ -25,7 +25,7 @@ export class ToolDefinitionsCache {
      */
     getTools() {
         if (!this._tools) {
-            throw new Error('ToolDefinitionsCache not initialized');
+            throw new Error("ToolDefinitionsCache not initialized");
         }
         return this._tools;
     }
@@ -34,7 +34,7 @@ export class ToolDefinitionsCache {
      */
     getTool(name) {
         if (!this._tools) {
-            throw new Error('ToolDefinitionsCache not initialized');
+            throw new Error("ToolDefinitionsCache not initialized");
         }
         const tool = this._tools.find((t) => t.name === name);
         if (!tool) {
@@ -47,7 +47,7 @@ export class ToolDefinitionsCache {
      */
     getVersion() {
         if (!this._version) {
-            throw new Error('ToolDefinitionsCache not initialized');
+            throw new Error("ToolDefinitionsCache not initialized");
         }
         return this._version;
     }

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

@@ -1,3 +1,3 @@
-import { CallToolResult } from '@modelcontextprotocol/sdk/types.js';
-import { CallToolParams } from '../../shared/mcpServerTypes.js';
+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

@@ -1,8 +1,16 @@
-import { findServerManagerClient } from './serverManagerUtils.js';
-import { CallToolResultSchema } from '../../shared/serverManagerTypes.js';
-import { FileLogger } from '../../shared/fileLogger.js';
-import Registry from '../registry.js';
+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;
+function safeLength(obj) {
+    try {
+        return JSON.stringify(obj).length;
+    }
+    catch {
+        return -1;
+    }
+}
 export async function handleCallTool(params) {
     await logger.debug(`Handling call tool request with params: ${JSON.stringify(params)}`);
     const serverManagerClients = Registry.getServerManagerClients();
@@ -17,8 +25,8 @@ export async function handleCallTool(params) {
         // 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) {
+        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);
@@ -30,30 +38,34 @@ export async function handleCallTool(params) {
         const result = parsed.data.result;
         const content = Array.isArray(result) ? result : [result];
         if (!clientContext.permissions.enable_read_only_mode &&
-            clientContext.clientMode !== 'restricted') {
+            clientContext.clientMode !== "restricted") {
             content.push({
-                type: 'text',
-                text: promptsCache.getPrompt('tool_call_next_steps'),
+                type: "text",
+                text: promptsCache.getPrompt("tool_call_next_steps"),
             });
         }
-        await logger.debug('Tool called successfully');
-        await telemetryLogger.log('client_call_tool', {
+        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,
+                input_length: safeLength(params),
+                response_length: safeLength(content),
             },
             latency_ms: Date.now() - startTime,
         });
         return {
-            role: 'system',
+            role: "system",
             content: content,
         };
     }
     catch (error) {
-        const errorMessage = error instanceof Error ? error.message : promptsCache.getPrompt('unexpected_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', {
+        await telemetryLogger.log("client_call_tool", {
             success: false,
             log_context: {
                 server_id: params.server_id,
@@ -63,15 +75,15 @@ export async function handleCallTool(params) {
             latency_ms: Date.now() - startTime,
         });
         return {
-            role: 'system',
+            role: "system",
             content: [
                 {
-                    type: 'text',
+                    type: "text",
                     text: promptsCache
-                        .getPrompt('tool_call_failure')
-                        .replace('{ERROR}', errorMessage)
-                        .replace('{SERVER_ID}', params.server_id)
-                        .replace('{TOOL_NAME}', params.tool_name),
+                        .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

@@ -1,3 +1,3 @@
-import { CallToolResult } from '@modelcontextprotocol/sdk/types.js';
-import { GetServerConfigParams } from '../../shared/mcpServerTypes.js';
+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

@@ -1,6 +1,6 @@
-import { FileLogger } from '../../shared/fileLogger.js';
-import { findServerManagerClient } from './serverManagerUtils.js';
-import Registry from '../registry.js';
+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();
@@ -11,20 +11,22 @@ export async function handleGetServerConfig(params) {
     try {
         const server_id = params.server_id;
         if (!server_id) {
-            throw new Error('Missing 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) {
+        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', {
+        await logger.debug("Successfully retrieved server config");
+        await telemetryLogger.log("client_get_server_config", {
             success: true,
             log_context: {
                 server_id,
@@ -32,21 +34,25 @@ export async function handleGetServerConfig(params) {
             latency_ms: Date.now() - startTime,
         });
         return {
-            role: 'system',
+            role: "system",
             content: [
                 {
-                    type: 'text',
-                    text: promptsCache.getPrompt('get_server_config_header').replace('{SERVER_ID}', server_id) +
-                        '\n' +
+                    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');
+        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', {
+        await telemetryLogger.log("client_get_server_config", {
             success: false,
             log_context: {
                 server_id: params.server_id,
@@ -55,13 +61,13 @@ export async function handleGetServerConfig(params) {
             latency_ms: Date.now() - startTime,
         });
         return {
-            role: 'system',
+            role: "system",
             content: [
                 {
-                    type: 'text',
+                    type: "text",
                     text: promptsCache
-                        .getPrompt('get_server_config_failure')
-                        .replace('{ERROR}', errorMessage),
+                        .getPrompt("get_server_config_failure")
+                        .replace("{ERROR}", errorMessage),
                 },
             ],
         };

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

@@ -1,3 +1,3 @@
-import { CallToolResult } from '@modelcontextprotocol/sdk/types.js';
-import { InitializeToolplexParams } from '../../shared/mcpServerTypes.js';
+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

@@ -1,11 +1,11 @@
-import { FileLogger } from '../../shared/fileLogger.js';
-import os from 'os';
-import { initServerManagersOnly } from '../utils/initServerManagers.js';
-import Registry from '../registry.js';
+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.info("Initializing ToolPlex");
     await logger.debug(`Initialization params: ${JSON.stringify(params)}`);
     const clientContext = Registry.getClientContext();
     const apiService = Registry.getToolplexApiService();
@@ -14,12 +14,12 @@ export async function handleInitialize(params) {
     const promptsCache = Registry.getPromptsCache();
     const serversCache = Registry.getServersCache();
     const policyEnforcer = Registry.getPolicyEnforcer();
-    await logger.debug(`Server manager clients: ${Object.keys(serverManagerClients).join(', ')}`);
+    await logger.debug(`Server manager clients: ${Object.keys(serverManagerClients).join(", ")}`);
     const platform = os.platform();
-    const osName = platform === 'darwin'
-        ? 'macOS'
-        : platform === 'win32'
-            ? 'Windows'
+    const osName = platform === "darwin"
+        ? "macOS"
+        : platform === "win32"
+            ? "Windows"
             : platform.charAt(0).toUpperCase() + platform.slice(1);
     const systemInfo = {
         os: `${osName} ${os.release()}`,
@@ -28,7 +28,7 @@ export async function handleInitialize(params) {
         cpuCores: os.cpus().length,
         workDir: process.cwd(),
     };
-    await logger.debug('Initializing server managers and API service');
+    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}`);
@@ -48,57 +48,59 @@ export async function handleInitialize(params) {
     // 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');
+    await logger.debug("Building initialization response");
     // Safe to use prompts after init.
     const result = {
-        role: 'system',
+        role: "system",
         content: [
             {
-                type: 'text',
+                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),
+                    .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',
+        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)
+            .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.'
-            : ''),
+            .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',
+            type: "text",
             text: promptsCache
-                .getPrompt('allowed_mcp_servers')
-                .replace('{ALLOWED_MCP_SERVERS}', clientContext.permissions.allowed_mcp_servers.join(', ')),
+                .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' +
+        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.',
+                    ? `, 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', {
+    await telemetryLogger.log("client_initialize_toolplex", {
         session_id: toolplexApiInitResponse.session_id,
         success: Object.keys(allFailures).length === 0,
         log_context: {
@@ -112,6 +114,6 @@ export async function handleInitialize(params) {
         },
         latency_ms: Date.now() - startTime,
     });
-    await logger.info('ToolPlex initialization completed');
+    await logger.info("ToolPlex initialization completed");
     return result;
 }

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

@@ -1,3 +1,3 @@
-import { CallToolResult } from '@modelcontextprotocol/sdk/types.js';
-import { InstallParams } from '../../shared/mcpServerTypes.js';
+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

@@ -1,18 +1,18 @@
-import { FileLogger } from '../../shared/fileLogger.js';
-import { ServerInstallResultSchema, ListToolsResultSchema, } from '../../shared/serverManagerTypes.js';
-import Registry from '../registry.js';
-import { RuntimeCheck } from '../utils/runtimeCheck.js';
+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', {
+    const response = await serverManagerClient.sendRequest("install", {
         server_id: serverId,
         server_name: serverName,
         description: description,
         config: serverConfig,
     });
-    if ('error' in response) {
+    if ("error" in response) {
         const error = `Server installation failed: ${response.error.message}`;
         await logger.error(error);
         throw new Error(error);
@@ -23,7 +23,7 @@ async function installServer(serverId, serverName, description, serverManagerCli
     }
     logger.debug(`Install response: ${JSON.stringify(response)}`);
     if (!response) {
-        const error = 'Server installation failed: No response received';
+        const error = "Server installation failed: No response received";
         await logger.error(error);
         throw new Error(error);
     }
@@ -42,13 +42,13 @@ export async function handleInstallServer(params) {
     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.');
+        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');
+            throw new Error("Missing required install parameters");
         }
         // Validate command is installed before proceeding
         if (config.command) {
@@ -56,8 +56,8 @@ export async function handleInstallServer(params) {
         }
         // Check if server is disallowed using policy enforcer
         policyEnforcer.enforceUseServerPolicy(server_id);
-        const runtime = config.runtime || 'node';
-        const runtimeKey = 'node';
+        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) {
@@ -68,26 +68,26 @@ export async function handleInstallServer(params) {
         // 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', {
+        const toolsResponse = await client.sendRequest("list_tools", {
             server_id: installResult.server_id,
         });
-        if ('error' in toolsResponse) {
+        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 = '';
+        let toolsText = "";
         const tools = parsed.data.tools || [];
         if (tools.length > 0) {
-            toolsText = 'Available tools from this server:\n\n';
+            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', {
+        await telemetryLogger.log("client_install", {
             success: true,
             log_context: {
                 server_id: installResult.server_id,
@@ -96,30 +96,32 @@ export async function handleInstallServer(params) {
         });
         const content = [
             {
-                type: 'text',
+                type: "text",
                 text: promptsCache
-                    .getPrompt('install_success')
-                    .replace('{SERVER_ID}', installResult.server_id)
-                    .replace('{SERVER_NAME}', installResult.server_name)
-                    .replace('{TOOLS_LIST}', toolsText),
+                    .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'),
+                type: "text",
+                text: promptsCache.getPrompt("install_next_steps"),
             });
         }
         return {
-            role: 'system',
+            role: "system",
             content,
         };
     }
     catch (error) {
         errorMessage =
-            error instanceof Error ? error.message : promptsCache.getPrompt('unexpected_error');
+            error instanceof Error
+                ? error.message
+                : promptsCache.getPrompt("unexpected_error");
         await logger.error(`Installation failed: ${errorMessage}`);
-        await telemetryLogger.log('client_install', {
+        await telemetryLogger.log("client_install", {
             success: false,
             log_context: {
                 server_id: params.server_id,
@@ -129,18 +131,20 @@ export async function handleInstallServer(params) {
         });
         const content = [
             {
-                type: 'text',
-                text: promptsCache.getPrompt('install_failure').replace('{ERROR}', errorMessage),
+                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'),
+                type: "text",
+                text: promptsCache.getPrompt("install_next_steps"),
             });
         }
         return {
-            role: 'system',
+            role: "system",
             content,
         };
     }

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

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

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

@@ -1,6 +1,6 @@
-import { FileLogger } from '../../shared/fileLogger.js';
-import { ListServersResultSchema } from '../../shared/serverManagerTypes.js';
-import Registry from '../registry.js';
+import { FileLogger } from "../../shared/fileLogger.js";
+import { ListServersResultSchema } from "../../shared/serverManagerTypes.js";
+import Registry from "../registry.js";
 const logger = FileLogger;
 export async function handleListServers() {
     const startTime = Date.now();
@@ -10,12 +10,12 @@ export async function handleListServers() {
     const serversCache = Registry.getServersCache();
     const policyEnforcer = Registry.getPolicyEnforcer();
     try {
-        await logger.debug('Listing all installed servers');
-        let response = 'Currently installed MCP servers:\n\n';
+        await logger.debug("Listing all installed servers");
+        let response = "Currently installed MCP servers:\n\n";
         // Collect all servers for updating the cache
         const allServers = [];
         for (const [runtime, client] of Object.entries(serverManagerClients)) {
-            const response_data = await client.sendRequest('list_servers', {});
+            const response_data = await client.sendRequest("list_servers", {});
             if (response_data.error) {
                 continue;
             }
@@ -42,38 +42,42 @@ export async function handleListServers() {
         }
         // Update the servers cache with the fresh list
         serversCache.updateServers(allServers);
-        if (response === 'Currently installed MCP servers:\n\n') {
-            response = promptsCache.getPrompt('list_servers_empty');
+        if (response === "Currently installed MCP servers:\n\n") {
+            response = promptsCache.getPrompt("list_servers_empty");
         }
-        await logger.debug('Successfully retrieved servers list');
-        await telemetryLogger.log('client_list_servers', {
+        await logger.debug("Successfully retrieved servers list");
+        await telemetryLogger.log("client_list_servers", {
             success: true,
             latency_ms: Date.now() - startTime,
         });
         return {
-            role: 'system',
+            role: "system",
             content: [
                 {
-                    type: 'text',
+                    type: "text",
                     text: response,
                 },
             ],
         };
     }
     catch (error) {
-        const errorMessage = error instanceof Error ? error.message : promptsCache.getPrompt('unexpected_error');
+        const errorMessage = error instanceof Error
+            ? error.message
+            : promptsCache.getPrompt("unexpected_error");
         await logger.error(`Failed to list servers: ${errorMessage}`);
-        await telemetryLogger.log('client_list_servers', {
+        await telemetryLogger.log("client_list_servers", {
             success: false,
             pii_sanitized_error_message: errorMessage,
             latency_ms: Date.now() - startTime,
         });
         return {
-            role: 'system',
+            role: "system",
             content: [
                 {
-                    type: 'text',
-                    text: promptsCache.getPrompt('unexpected_error').replace('{ERROR}', errorMessage),
+                    type: "text",
+                    text: promptsCache
+                        .getPrompt("unexpected_error")
+                        .replace("{ERROR}", errorMessage),
                 },
             ],
         };

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

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