@toolplex/client 0.1.1 → 0.1.3

package/dist/mcp-server/toolplexServer.js

@@ -1,29 +1,29 @@
 #!/usr/bin/env node
-import path from 'path';
-import { fileURLToPath } from 'url';
-import { Server } from '@modelcontextprotocol/sdk/server/index.js';
-import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
-import { CallToolRequestSchema, ListToolsRequestSchema, } from '@modelcontextprotocol/sdk/types.js';
-import { ClientContext } from './clientContext.js';
-import Registry from './registry.js';
-import { PRE_INITIALIZATION_PROMPTS } from './staticPrompts.js';
-import { createToolDefinitions } from './tools.js';
-import { handleInitialize } from './toolHandlers/initHandler.js';
-import { handleSearchTool } from './toolHandlers/searchHandler.js';
-import { handleInstallServer } from './toolHandlers/installServerHandler.js';
-import { handleListTools } from './toolHandlers/listToolsHandler.js';
-import { handleListServers } from './toolHandlers/listServersHandler.js';
-import { handleCallTool } from './toolHandlers/callToolHandler.js';
-import { handleUninstallServer } from './toolHandlers/uninstallServerHandler.js';
-import { handleSavePlaybook } from './toolHandlers/savePlaybookHandler.js';
-import { handleLogPlaybookUsage } from './toolHandlers/logPlaybookUsageHandler.js';
-import { handleLookupEntityTool } from './toolHandlers/lookupEntityHandler.js';
-import { handleSubmitFeedback } from './toolHandlers/submitFeedbackHandler.js';
-import { handleGetServerConfig } from './toolHandlers/getServerConfigHandler.js';
-import { StdioServerManagerClient } from '../shared/stdioServerManagerClient.js';
-import { FileLogger } from '../shared/fileLogger.js';
-import { CallToolParamsSchema, InitializeToolplexParamsSchema, InstallParamsSchema, ListToolsParamsSchema, SearchParamsSchema, UninstallParamsSchema, SavePlaybookParamsSchema, LogPlaybookUsageParamsSchema, LookupEntityParamsSchema, SubmitFeedbackParamsSchema, GetServerConfigParamsSchema, } from '../shared/mcpServerTypes.js';
-import { version as clientVersion } from '../version.js';
+import path from "path";
+import { fileURLToPath } from "url";
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { CallToolRequestSchema, ListToolsRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
+import { ClientContext } from "./clientContext.js";
+import Registry from "./registry.js";
+import { PRE_INITIALIZATION_PROMPTS } from "./staticPrompts.js";
+import { createToolDefinitions } from "./tools.js";
+import { handleInitialize } from "./toolHandlers/initHandler.js";
+import { handleSearchTool } from "./toolHandlers/searchHandler.js";
+import { handleInstallServer } from "./toolHandlers/installServerHandler.js";
+import { handleListTools } from "./toolHandlers/listToolsHandler.js";
+import { handleListServers } from "./toolHandlers/listServersHandler.js";
+import { handleCallTool } from "./toolHandlers/callToolHandler.js";
+import { handleUninstallServer } from "./toolHandlers/uninstallServerHandler.js";
+import { handleSavePlaybook } from "./toolHandlers/savePlaybookHandler.js";
+import { handleLogPlaybookUsage } from "./toolHandlers/logPlaybookUsageHandler.js";
+import { handleLookupEntityTool } from "./toolHandlers/lookupEntityHandler.js";
+import { handleSubmitFeedback } from "./toolHandlers/submitFeedbackHandler.js";
+import { handleGetServerConfig } from "./toolHandlers/getServerConfigHandler.js";
+import { StdioServerManagerClient } from "../shared/stdioServerManagerClient.js";
+import { FileLogger } from "../shared/fileLogger.js";
+import { CallToolParamsSchema, InitializeToolplexParamsSchema, InstallParamsSchema, ListToolsParamsSchema, SearchParamsSchema, UninstallParamsSchema, SavePlaybookParamsSchema, LogPlaybookUsageParamsSchema, LookupEntityParamsSchema, SubmitFeedbackParamsSchema, GetServerConfigParamsSchema, } from "../shared/mcpServerTypes.js";
+import { version as clientVersion } from "../version.js";
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const logger = FileLogger;
 export async function serve(config) {
@@ -31,11 +31,12 @@ export async function serve(config) {
     clientContext.dev = config.dev;
     clientContext.apiKey = config.apiKey;
     clientContext.clientMode = config.clientMode;
+    clientContext.clientName = config.clientName;
     clientContext.clientVersion = clientVersion;
     await Registry.init(clientContext);
-    await logger.info(`Starting Toolplex server in ${config.dev ? 'development' : 'production'} mode`);
+    await logger.info(`Starting Toolplex server in ${config.dev ? "development" : "production"} mode`);
     const server = new Server({
-        name: 'toolplex-server',
+        name: "toolplex-server",
         version: clientContext.clientVersion,
     }, {
         capabilities: {
@@ -44,18 +45,18 @@ export async function serve(config) {
         },
     });
     // Initialize server manager clients
-    await logger.info('Initializing server manager clients');
+    await logger.info("Initializing server manager clients");
     const serverManagerClients = {
-        node: new StdioServerManagerClient('node', [path.join(__dirname, '..', 'server-manager', 'index.js')], { LOG_LEVEL: config.logLevel }),
+        node: new StdioServerManagerClient("node", [path.join(__dirname, "..", "server-manager", "index.js")], { LOG_LEVEL: config.logLevel }),
     };
     // Start all server manager clients
-    await logger.info('Starting server manager clients');
+    await logger.info("Starting server manager clients");
     await Promise.all(Object.values(serverManagerClients).map((client) => client.start()));
-    await logger.info('All server manager clients started successfully');
+    await logger.info("All server manager clients started successfully");
     Registry.setServerManagerClients(serverManagerClients);
     // List tools handler
     server.setRequestHandler(ListToolsRequestSchema, async () => {
-        await logger.debug('Handling list tools request');
+        await logger.debug("Handling list tools request");
         return {
             tools: createToolDefinitions(),
         };
@@ -67,23 +68,23 @@ export async function serve(config) {
         let result;
         if (!Registry.getToolDefinitionsCache().isInitialized()) {
             result = {
-                role: 'system',
+                role: "system",
                 content: [
                     {
-                        type: 'text',
+                        type: "text",
                         text: PRE_INITIALIZATION_PROMPTS.tools_initialization_error,
                     },
                 ],
             };
             return result;
         }
-        if (!clientContext.isInitialized() && name !== 'initialize_toolplex') {
+        if (!clientContext.isInitialized() && name !== "initialize_toolplex") {
             result = {
-                role: 'system',
+                role: "system",
                 content: [
                     {
-                        type: 'text',
-                        text: PRE_INITIALIZATION_PROMPTS.enforce_init_toolplex.replace('{TOOL_NAME}', name),
+                        type: "text",
+                        text: PRE_INITIALIZATION_PROMPTS.enforce_init_toolplex.replace("{TOOL_NAME}", name),
                     },
                 ],
             };
@@ -91,8 +92,8 @@ export async function serve(config) {
         }
         try {
             switch (name) {
-                case 'initialize_toolplex': {
-                    await logger.debug('Handling initialize_toolplex request');
+                case "initialize_toolplex": {
+                    await logger.debug("Handling initialize_toolplex request");
                     const parsed = InitializeToolplexParamsSchema.safeParse(params);
                     if (!parsed.success)
                         throw new Error(`Invalid initialize_toolplex params: ${parsed.error}`);
@@ -100,16 +101,16 @@ export async function serve(config) {
                     result = await handleInitialize(parsed.data);
                     break;
                 }
-                case 'search': {
-                    await logger.debug('Handling search request');
+                case "search": {
+                    await logger.debug("Handling search request");
                     const parsed = SearchParamsSchema.safeParse(params);
                     if (!parsed.success)
                         throw new Error(`Invalid search params: ${parsed.error}`);
                     result = await handleSearchTool(parsed.data);
                     break;
                 }
-                case 'install': {
-                    await logger.debug('Handling install request');
+                case "install": {
+                    await logger.debug("Handling install request");
                     const parsed = InstallParamsSchema.safeParse(params);
                     if (!parsed.success)
                         throw new Error(`Invalid install params: ${parsed.error}`);
@@ -117,37 +118,37 @@ export async function serve(config) {
                     server.sendToolListChanged();
                     break;
                 }
-                case 'list_tools': {
-                    await logger.debug('Handling list_tools request');
+                case "list_tools": {
+                    await logger.debug("Handling list_tools request");
                     const parsed = ListToolsParamsSchema.safeParse(params);
                     if (!parsed.success)
                         throw new Error(`Invalid list_toolplex_tools params: ${parsed.error}`);
                     result = await handleListTools(parsed.data);
                     break;
                 }
-                case 'list_servers': {
-                    await logger.debug('Handling list_toolplex_tools request');
+                case "list_servers": {
+                    await logger.debug("Handling list_toolplex_tools request");
                     result = await handleListServers();
                     break;
                 }
-                case 'call_tool': {
-                    await logger.debug('Handling call_tool request');
+                case "call_tool": {
+                    await logger.debug("Handling call_tool request");
                     const parsed = CallToolParamsSchema.safeParse(params);
                     if (!parsed.success)
                         throw new Error(`Invalid call_tool params: ${parsed.error}`);
                     result = await handleCallTool(parsed.data);
                     break;
                 }
-                case 'uninstall': {
-                    await logger.debug('Handling uninstall request');
+                case "uninstall": {
+                    await logger.debug("Handling uninstall request");
                     const parsed = UninstallParamsSchema.safeParse(params);
                     if (!parsed.success)
                         throw new Error(`Invalid uninstall params: ${parsed.error}`);
                     result = await handleUninstallServer(parsed.data);
                     break;
                 }
-                case 'save_playbook': {
-                    await logger.debug('Handling save_playbook request');
+                case "save_playbook": {
+                    await logger.debug("Handling save_playbook request");
                     const parsed = SavePlaybookParamsSchema.safeParse(params);
                     if (!parsed.success)
                         throw new Error(`Invalid save_playbook params: ${parsed.error}`);
@@ -156,8 +157,8 @@ export async function serve(config) {
                     result = await handleSavePlaybook(parsed.data);
                     break;
                 }
-                case 'log_playbook_usage': {
-                    await logger.debug('Handling log_playbook_usage request');
+                case "log_playbook_usage": {
+                    await logger.debug("Handling log_playbook_usage request");
                     const parsed = LogPlaybookUsageParamsSchema.safeParse(params);
                     if (!parsed.success)
                         throw new Error(`Invalid log_playbook_usage params: ${parsed.error}`);
@@ -166,16 +167,16 @@ export async function serve(config) {
                     result = await handleLogPlaybookUsage(parsed.data);
                     break;
                 }
-                case 'lookup_entity': {
-                    await logger.debug('Handling lookup_entity request');
+                case "lookup_entity": {
+                    await logger.debug("Handling lookup_entity request");
                     const parsed = LookupEntityParamsSchema.safeParse(params);
                     if (!parsed.success)
                         throw new Error(`Invalid lookup_entity params: ${parsed.error}`);
                     result = await handleLookupEntityTool(parsed.data);
                     break;
                 }
-                case 'submit_feedback': {
-                    await logger.debug('Handling submit_feedback request');
+                case "submit_feedback": {
+                    await logger.debug("Handling submit_feedback request");
                     const parsed = SubmitFeedbackParamsSchema.safeParse(params);
                     if (!parsed.success)
                         throw new Error(`Invalid submit_feedback params: ${parsed.error}`);
@@ -185,8 +186,8 @@ export async function serve(config) {
                     break;
                 }
                 // Add get_server_config tool handler
-                case 'get_server_config': {
-                    await logger.debug('Handling get_server_config request');
+                case "get_server_config": {
+                    await logger.debug("Handling get_server_config request");
                     const parsed = GetServerConfigParamsSchema.safeParse(params);
                     if (!parsed.success)
                         throw new Error(`Invalid get_server_config params: ${parsed.error}`);
@@ -196,28 +197,28 @@ export async function serve(config) {
                 default:
                     await logger.warn(`Unknown tool requested: ${name}`);
                     result = {
-                        role: 'system',
+                        role: "system",
                         content: [
                             {
-                                type: 'text',
-                                text: PRE_INITIALIZATION_PROMPTS.unknown_tool.replace('{TOOL_NAME}', name),
+                                type: "text",
+                                text: PRE_INITIALIZATION_PROMPTS.unknown_tool.replace("{TOOL_NAME}", name),
                             },
                         ],
                     };
             }
         }
         catch (error) {
-            let errorMessage = 'Unknown error occurred';
+            let errorMessage = "Unknown error occurred";
             if (error instanceof Error) {
                 errorMessage = error.message;
             }
             await logger.error(`Error calling ToolPlex: ${errorMessage}`);
             result = {
-                role: 'system',
+                role: "system",
                 content: [
                     {
-                        type: 'text',
-                        text: PRE_INITIALIZATION_PROMPTS.unexpected_error.replace('{ERROR}', errorMessage),
+                        type: "text",
+                        text: PRE_INITIALIZATION_PROMPTS.unexpected_error.replace("{ERROR}", errorMessage),
                     },
                 ],
             };
@@ -225,23 +226,23 @@ export async function serve(config) {
         return result;
     });
     const transport = new StdioServerTransport();
-    await logger.info('Connecting server transport');
+    await logger.info("Connecting server transport");
     await server.connect(transport);
-    await logger.info('Server transport connected successfully');
+    await logger.info("Server transport connected successfully");
     // Clean up on process exit
-    process.on('exit', async () => {
-        await logger.info('Process exit - stopping server manager clients');
+    process.on("exit", async () => {
+        await logger.info("Process exit - stopping server manager clients");
         await logger.flush();
         Object.values(serverManagerClients).forEach((client) => client.stop());
     });
-    process.on('SIGINT', async () => {
-        await logger.warn('SIGINT received - stopping server manager clients');
+    process.on("SIGINT", async () => {
+        await logger.warn("SIGINT received - stopping server manager clients");
         await logger.flush();
         Object.values(serverManagerClients).forEach((client) => client.stop());
         process.exit();
     });
-    process.on('SIGTERM', async () => {
-        await logger.warn('SIGTERM received - stopping server manager clients');
+    process.on("SIGTERM", async () => {
+        await logger.warn("SIGTERM received - stopping server manager clients");
         await logger.flush();
         Object.values(serverManagerClients).forEach((client) => client.stop());
         process.exit();

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

@@ -1,2 +1,2 @@
-import { Tool } from '@modelcontextprotocol/sdk/types.js';
+import { Tool } from "@modelcontextprotocol/sdk/types.js";
 export declare function createToolDefinitions(): Tool[];

package/dist/mcp-server/tools.js

@@ -1,11 +1,11 @@
-import Registry from './registry.js';
+import Registry from "./registry.js";
 export function createToolDefinitions() {
     const toolDefinitionsCache = Registry.getToolDefinitionsCache();
     if (!toolDefinitionsCache.isInitialized()) {
         return [
             {
-                name: 'initialize_toolplex',
-                inputSchema: { type: 'object', properties: {}, required: [] },
+                name: "initialize_toolplex",
+                inputSchema: { type: "object", properties: {}, required: [] },
             },
         ];
     }

package/dist/mcp-server/utils/initServerManagers.d.ts

@@ -1,6 +1,6 @@
-import { StdioServerManagerClient } from '../../shared/stdioServerManagerClient.js';
-import { InitializeResult } from '../../shared/serverManagerTypes.js';
+import { StdioServerManagerClient } from "../../shared/stdioServerManagerClient.js";
+import { InitializeResult } from "../../shared/serverManagerTypes.js";
 export declare function initServerManagersOnly(serverManagerClients: Record<string, StdioServerManagerClient>): Promise<{
-    succeeded: InitializeResult['succeeded'];
-    failures: InitializeResult['failures'];
+    succeeded: InitializeResult["succeeded"];
+    failures: InitializeResult["failures"];
 }>;

package/dist/mcp-server/utils/initServerManagers.js

@@ -1,12 +1,12 @@
-import { InitializeResultSchema } from '../../shared/serverManagerTypes.js';
-import { FileLogger } from '../../shared/fileLogger.js';
+import { InitializeResultSchema, } from "../../shared/serverManagerTypes.js";
+import { FileLogger } from "../../shared/fileLogger.js";
 const logger = FileLogger;
 export async function initServerManagersOnly(serverManagerClients) {
-    await logger.info('Pre-warming server manager clients');
+    await logger.info("Pre-warming server manager clients");
     const initPromises = Object.entries(serverManagerClients).map(async ([runtime, client]) => {
         try {
-            const response = await client.sendRequest('initialize', {});
-            if ('error' in response)
+            const response = await client.sendRequest("initialize", {});
+            if ("error" in response)
                 throw new Error(response.error.message);
             const parsed = InitializeResultSchema.safeParse(response);
             if (!parsed.success)

package/dist/mcp-server/utils/resultAnnotators.js

@@ -10,10 +10,8 @@
  */
 export function annotateInstalledServer(
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
-server, serversCache
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-) {
-    if (!server || typeof server !== 'object' || !server.server_id) {
+server, serversCache) {
+    if (!server || typeof server !== "object" || !server.server_id) {
         return server;
     }
     if (serversCache.isInstalled(server.server_id)) {
@@ -41,9 +39,7 @@ server, serversCache
  */
 export function annotateInstalledServers(
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
-servers, serversCache
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-) {
+servers, serversCache) {
     if (!Array.isArray(servers))
         return [];
     return servers.map((server) => annotateInstalledServer(server, serversCache));

package/dist/mcp-server/utils/runtimeCheck.js

@@ -1,12 +1,12 @@
-import { getEnhancedPath } from '../../shared/enhancedPath.js';
-import which from 'which';
+import { getEnhancedPath } from "../../shared/enhancedPath.js";
+import which from "which";
 const INSTALL_HINTS = {
-    uvx: 'Install uvx: https://docs.astral.sh/uv/getting-started/installation/',
-    uv: 'Install uv: https://docs.astral.sh/uv/getting-started/installation/',
-    python: 'Install Python: https://www.python.org/downloads/. Or check if you have `python3` installed.',
-    python3: 'Install Python: https://www.python.org/downloads/. Or check if you have `python` installed.',
-    node: 'Install Node.js: https://nodejs.org/en/download/',
-    npx: 'Install npx (comes with Node.js): https://nodejs.org/en/download/',
+    uvx: "Install uvx: https://docs.astral.sh/uv/getting-started/installation/",
+    uv: "Install uv: https://docs.astral.sh/uv/getting-started/installation/",
+    python: "Install Python: https://www.python.org/downloads/. Or check if you have `python3` installed.",
+    python3: "Install Python: https://www.python.org/downloads/. Or check if you have `python` installed.",
+    node: "Install Node.js: https://nodejs.org/en/download/",
+    npx: "Install npx (comes with Node.js): https://nodejs.org/en/download/",
 };
 export class RuntimeCheck {
     static validateCommandOrThrow(rawCommand) {

package/dist/server-manager/index.js

@@ -1,8 +1,8 @@
-import { ServerManagerProtocol } from './stdioServer.js';
-import { FileLogger } from '../shared/fileLogger.js';
-FileLogger.initialize('server-manager');
+import { ServerManagerProtocol } from "./stdioServer.js";
+import { FileLogger } from "../shared/fileLogger.js";
+FileLogger.initialize("server-manager");
 const protocol = new ServerManagerProtocol();
 protocol.start().catch((error) => {
-    console.error('Failed to start server:', error);
+    console.error("Failed to start server:", error);
     process.exit(1);
 });

package/dist/server-manager/serverManager.d.ts

@@ -1,9 +1,9 @@
-import { Client } from '@modelcontextprotocol/sdk/client/index.js';
-import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';
-import { SSEClientTransport } from '@modelcontextprotocol/sdk/client/sse.js';
-import { Tool } from '@modelcontextprotocol/sdk/types.js';
-import { ServerConfig } from '../shared/mcpServerTypes.js';
-import { InitializeResult } from '../shared/serverManagerTypes.js';
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
+import { SSEClientTransport } from "@modelcontextprotocol/sdk/client/sse.js";
+import { Tool } from "@modelcontextprotocol/sdk/types.js";
+import { ServerConfig } from "../shared/mcpServerTypes.js";
+import { InitializeResult } from "../shared/serverManagerTypes.js";
 export declare class ServerManager {
     private sessions;
     private tools;

package/dist/server-manager/serverManager.js

@@ -1,12 +1,12 @@
-import { Client } from '@modelcontextprotocol/sdk/client/index.js';
-import { StdioClientTransport, } from '@modelcontextprotocol/sdk/client/stdio.js';
-import { SSEClientTransport } from '@modelcontextprotocol/sdk/client/sse.js';
-import * as fs from 'fs/promises';
-import * as path from 'path';
-import which from 'which';
-import { FileLogger } from '../shared/fileLogger.js';
-import envPaths from 'env-paths';
-import { getEnhancedPath } from '../shared/enhancedPath.js';
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StdioClientTransport, } from "@modelcontextprotocol/sdk/client/stdio.js";
+import { SSEClientTransport } from "@modelcontextprotocol/sdk/client/sse.js";
+import * as fs from "fs/promises";
+import * as path from "path";
+import which from "which";
+import { FileLogger } from "../shared/fileLogger.js";
+import envPaths from "env-paths";
+import { getEnhancedPath } from "../shared/enhancedPath.js";
 const logger = FileLogger;
 export class ServerManager {
     constructor() {
@@ -18,22 +18,22 @@ export class ServerManager {
         this.sessions = new Map();
         this.tools = new Map();
         this.serverNames = new Map();
-        const paths = envPaths('ToolPlex', { suffix: '' });
-        this.configPath = path.join(paths.data, 'server_config.json');
+        const paths = envPaths("ToolPlex", { suffix: "" });
+        this.configPath = path.join(paths.data, "server_config.json");
     }
     async loadConfig() {
         try {
-            const data = await fs.readFile(this.configPath, 'utf-8');
+            const data = await fs.readFile(this.configPath, "utf-8");
             await logger.debug(`Loaded config from ${this.configPath}`);
             const allConfig = JSON.parse(data);
             // Validate the config structure
-            if (typeof allConfig !== 'object' || allConfig === null) {
-                await logger.warn('Invalid config format, using empty config');
+            if (typeof allConfig !== "object" || allConfig === null) {
+                await logger.warn("Invalid config format, using empty config");
                 return {};
             }
             const config = {};
             for (const [serverId, serverConfig] of Object.entries(allConfig)) {
-                if (typeof serverConfig === 'object' && serverConfig !== null) {
+                if (typeof serverConfig === "object" && serverConfig !== null) {
                     config[serverId] = serverConfig;
                 }
                 else {
@@ -43,14 +43,14 @@ export class ServerManager {
             return config;
         }
         catch (error) {
-            let errorMessage = 'Unknown error occurred';
+            let errorMessage = "Unknown error occurred";
             if (error instanceof Error)
                 errorMessage = error.message;
             await logger.debug(`No existing config found at ${this.configPath}: ${errorMessage}`);
             // If the file exists but is malformed, back it up and start fresh
             try {
                 await fs.access(this.configPath);
-                const backupPath = this.configPath + '.backup.' + Date.now();
+                const backupPath = this.configPath + ".backup." + Date.now();
                 await fs.copyFile(this.configPath, backupPath);
                 await logger.warn(`Malformed config backed up to ${backupPath}`);
             }
@@ -65,11 +65,11 @@ export class ServerManager {
         this.configLock = this.configLock.then(async () => {
             let existingConfig = {};
             try {
-                const data = await fs.readFile(this.configPath, 'utf-8');
+                const data = await fs.readFile(this.configPath, "utf-8");
                 existingConfig = JSON.parse(data);
                 // Validate the existing config structure
-                if (typeof existingConfig !== 'object' || existingConfig === null) {
-                    await logger.warn('Invalid existing config format, using empty config');
+                if (typeof existingConfig !== "object" || existingConfig === null) {
+                    await logger.warn("Invalid existing config format, using empty config");
                     existingConfig = {};
                 }
             }
@@ -92,7 +92,7 @@ export class ServerManager {
             }
             await fs.mkdir(path.dirname(this.configPath), { recursive: true });
             // Write to a temporary file first, then rename (atomic operation)
-            const tempPath = this.configPath + '.tmp';
+            const tempPath = this.configPath + ".tmp";
             try {
                 await fs.writeFile(tempPath, JSON.stringify(mergedConfig, null, 2));
                 await fs.rename(tempPath, this.configPath);
@@ -116,14 +116,14 @@ export class ServerManager {
         const succeeded = [];
         const failures = {};
         try {
-            await logger.info('Initializing ServerManager');
+            await logger.info("Initializing ServerManager");
             this.config = await this.loadConfig();
             await logger.debug(`Loaded ${Object.keys(this.config).length} server configs`);
             for (const [serverId, serverConfig] of Object.entries(this.config)) {
                 succeeded.push({
                     server_id: serverId,
                     server_name: serverConfig.server_name ?? serverId,
-                    description: serverConfig.description ?? '',
+                    description: serverConfig.description ?? "",
                 });
             }
         }
@@ -196,14 +196,14 @@ export class ServerManager {
             await this.removeServer(serverId);
         }
         let transport;
-        if (config.transport === 'sse') {
+        if (config.transport === "sse") {
             if (!config.url)
-                throw new Error('URL is required for SSE transport');
+                throw new Error("URL is required for SSE transport");
             transport = new SSEClientTransport(new URL(config.url));
         }
-        else if (config.transport === 'stdio') {
+        else if (config.transport === "stdio") {
             if (!config.command)
-                throw new Error('Command is required for stdio transport');
+                throw new Error("Command is required for stdio transport");
             const enhancedPath = getEnhancedPath();
             let resolvedCommand = which.sync(config.command, {
                 path: enhancedPath,
@@ -221,14 +221,14 @@ export class ServerManager {
                     PATH: enhancedPath,
                     ...(config.env || {}),
                 },
-                stderr: 'pipe',
+                stderr: "pipe",
             };
             transport = new StdioClientTransport(serverParams);
         }
         else {
             throw new Error(`Invalid transport type: ${config.transport}`);
         }
-        const client = new Client({ name: serverId, version: '1.0.0' }, { capabilities: { prompts: {}, resources: {}, tools: {} } });
+        const client = new Client({ name: serverId, version: "1.0.0" }, { capabilities: { prompts: {}, resources: {}, tools: {} } });
         try {
             const toolsResponse = await this.connectWithHandshakeTimeout(client, transport, 30000);
             const tools = toolsResponse.tools || [];
@@ -267,9 +267,7 @@ export class ServerManager {
     }
     async callTool(serverId, toolName, 
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    arguments_, timeout = 60000
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    ) {
+    arguments_, timeout = 60000) {
         // Check for ongoing installation before attempting to install
         const existingInstall = this.installationPromises.get(serverId);
         if (existingInstall) {
@@ -281,7 +279,7 @@ export class ServerManager {
             if (!config)
                 throw new Error(`No config found for server ${serverId}`);
             const name = config.server_name || serverId;
-            const description = config.description || '';
+            const description = config.description || "";
             await this.install(serverId, name, description, config);
         }
         const client = this.sessions.get(serverId);
@@ -339,7 +337,7 @@ export class ServerManager {
         // Remove the server from the config file
         let config = {};
         try {
-            const data = await fs.readFile(this.configPath, 'utf-8');
+            const data = await fs.readFile(this.configPath, "utf-8");
             config = JSON.parse(data);
         }
         catch (error) {
@@ -375,7 +373,7 @@ export class ServerManager {
             server_id: id,
             server_name: cfg.server_name || id,
             tool_count: this.tools.get(id)?.length || 0,
-            description: cfg.description || '',
+            description: cfg.description || "",
         }));
     }
     async listTools(serverId) {
@@ -389,7 +387,7 @@ export class ServerManager {
             const config = this.config[serverId];
             if (!config)
                 throw new Error(`No config for server ${serverId}`);
-            await this.install(serverId, config.server_name || serverId, config.description || '', config);
+            await this.install(serverId, config.server_name || serverId, config.description || "", config);
         }
         return this.tools.get(serverId) || [];
     }