hostinger-api-mcp 1.63.4 → 2.1.0

package/src/core/catalog.ts

@@ -0,0 +1,207 @@
+// Typed mirror of catalog.js. Keep both files, and api-remote-mcp's PHP
+// implementation, behaviourally identical.
+
+export const DEFAULT_SEARCH_LIMIT = 5;
+export const MAX_SEARCH_LIMIT = 20;
+export const MAX_STEPS = 20;
+
+const STEP_REF = /^\$steps\.(\d+)((?:\.[^.]+)*)$/;
+
+export interface CatalogOperation {
+  name: string;
+  title?: string;
+  description?: string;
+  group?: string;
+  annotations?: { readOnlyHint?: boolean; destructiveHint?: boolean; [key: string]: unknown };
+  inputSchema: { type: 'object'; properties?: Record<string, unknown>; required?: string[]; [key: string]: unknown };
+}
+
+export interface OperationSummary {
+  operation: string;
+  title: string;
+  description: string;
+  group: string | null;
+  readOnly: boolean;
+  destructive: boolean;
+  inputSchema: CatalogOperation['inputSchema'];
+}
+
+export interface StepResult { step: number; operation: string; result: unknown }
+export interface BatchResult { results: StepResult[]; error?: { step: number; message: string } }
+
+export class ToolInputError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = 'ToolInputError';
+  }
+}
+
+const meta = (name: string, title: string, description: string, inputSchema: CatalogOperation['inputSchema'], readOnly: boolean) => ({
+  name,
+  title,
+  description,
+  inputSchema,
+  annotations: { title, readOnlyHint: readOnly, destructiveHint: !readOnly },
+});
+
+export const META_TOOLS = [
+  meta('search', 'Search API operations',
+    "Find API operations by keyword. Returns the best matches, each with its operation name, hints and inputSchema. Pass a result's operation and params matching its inputSchema to execute or multi-execute.",
+    {
+      type: 'object',
+      properties: {
+        query: { type: 'string', description: 'Keywords, e.g. "list vps" or "dns records".' },
+        limit: { type: 'integer', minimum: 1, maximum: MAX_SEARCH_LIMIT, default: DEFAULT_SEARCH_LIMIT, description: 'Maximum number of results.' },
+      },
+      required: ['query'],
+    },
+    true),
+  meta('execute', 'Execute an API operation',
+    "Run one API operation found with search. params is a flat object holding the operation's path, query and body parameters as described by its inputSchema.",
+    {
+      type: 'object',
+      properties: {
+        operation: { type: 'string', description: 'Operation name returned by search.' },
+        params: { type: 'object', description: 'Parameters matching the operation inputSchema.' },
+      },
+      required: ['operation'],
+    },
+    false),
+  meta('multi-execute', 'Execute API operations in sequence',
+    'Run up to 20 API operations in order, stopping at the first failure. A params value that is exactly "$steps.<i>.<path>" is replaced by that value from the result of earlier step <i> (dot-separated keys; numbers index arrays), e.g. "$steps.0.0.id".',
+    {
+      type: 'object',
+      properties: {
+        steps: {
+          type: 'array',
+          minItems: 1,
+          maxItems: MAX_STEPS,
+          items: {
+            type: 'object',
+            properties: {
+              operation: { type: 'string', description: 'Operation name returned by search.' },
+              params: { type: 'object', description: 'Parameters; may contain "$steps.<i>.<path>" references.' },
+            },
+            required: ['operation'],
+          },
+        },
+      },
+      required: ['steps'],
+    },
+    false),
+];
+
+const byteOrder = (a: string, b: string): number => (a < b ? -1 : a > b ? 1 : 0);
+
+function toSummary(op: CatalogOperation): OperationSummary {
+  return {
+    operation: op.name,
+    title: op.title ?? op.name,
+    description: op.description ?? '',
+    group: op.group ?? null,
+    readOnly: op.annotations?.readOnlyHint === true,
+    destructive: op.annotations?.destructiveHint === true,
+    inputSchema: op.inputSchema,
+  };
+}
+
+export function searchOperations(operations: CatalogOperation[], query: unknown, limit: unknown = DEFAULT_SEARCH_LIMIT): OperationSummary[] {
+  if (typeof query !== 'string') throw new ToolInputError('query must be a string');
+  const tokens = query.toLowerCase().split(/[^a-z0-9]+/).filter(Boolean);
+  if (tokens.length === 0) throw new ToolInputError('query must contain at least one letter or digit');
+  if (typeof limit !== 'number' || !Number.isInteger(limit) || limit < 1 || limit > MAX_SEARCH_LIMIT) {
+    throw new ToolInputError(`limit must be an integer from 1 to ${MAX_SEARCH_LIMIT}`);
+  }
+
+  return operations
+    .map(op => {
+      const name = op.name.toLowerCase();
+      const group = (op.group ?? '').toLowerCase();
+      const title = (op.title ?? '').toLowerCase();
+      const description = (op.description ?? '').toLowerCase();
+      let score = 0;
+      for (const t of tokens) {
+        if (name.includes(t)) score += 3;
+        if (group.includes(t)) score += 2;
+        if (title.includes(t)) score += 2;
+        if (description.includes(t)) score += 1;
+      }
+      return { op, score };
+    })
+    .filter(s => s.score > 0)
+    .sort((a, b) => b.score - a.score || byteOrder(a.op.name, b.op.name))
+    .slice(0, limit)
+    .map(s => toSummary(s.op));
+}
+
+export function renderSearch(query: string, results: OperationSummary[]): string {
+  return results.length > 0
+    ? JSON.stringify(results)
+    : `No operations matched "${query}". Try broader or different terms.`;
+}
+
+export function findOperation<T extends CatalogOperation>(operations: Map<string, T>, name: unknown, params: unknown): T {
+  const op = typeof name === 'string' ? operations.get(name) : undefined;
+  if (!op) {
+    throw new ToolInputError(`Unknown operation "${String(name)}". Use search to find operations.`);
+  }
+  if (params === null || typeof params !== 'object' || Array.isArray(params)) {
+    throw new ToolInputError('params must be an object');
+  }
+  const given = params as Record<string, unknown>;
+  const missing = (op.inputSchema?.required ?? []).filter(k => given[k] === undefined || given[k] === null);
+  if (missing.length > 0) {
+    throw new ToolInputError(`Missing required parameter(s) for ${op.name}: ${missing.join(', ')}`);
+  }
+  return op;
+}
+
+export function resolveRefs(value: unknown, results: unknown[], stepIndex: number): unknown {
+  if (typeof value === 'string') {
+    const m = STEP_REF.exec(value);
+    if (!m) return value;
+    const i = Number(m[1]);
+    if (i >= stepIndex) {
+      throw new ToolInputError(`${value}: references must point to an earlier step`);
+    }
+    let current: unknown = results[i];
+    for (const segment of m[2].split('.').slice(1)) {
+      if (current === null || typeof current !== 'object' || !Object.hasOwn(current, segment)) {
+        throw new ToolInputError(`${value}: path not found in the result of step ${i}`);
+      }
+      current = (current as Record<string, unknown>)[segment];
+    }
+    return current;
+  }
+  if (Array.isArray(value)) return value.map(v => resolveRefs(v, results, stepIndex));
+  if (value !== null && typeof value === 'object') {
+    return Object.fromEntries(Object.entries(value).map(([k, v]) => [k, resolveRefs(v, results, stepIndex)]));
+  }
+  return value;
+}
+
+export async function runSteps(
+  steps: unknown,
+  runOne: (operation: string, params: Record<string, unknown>) => Promise<unknown>,
+  formatError: (error: unknown) => string,
+): Promise<BatchResult> {
+  if (!Array.isArray(steps) || steps.length === 0 || steps.length > MAX_STEPS) {
+    throw new ToolInputError(`steps must be an array of 1 to ${MAX_STEPS} items`);
+  }
+  const raw: unknown[] = [];
+  const results: StepResult[] = [];
+  for (const [i, step] of steps.entries()) {
+    try {
+      if (step === null || typeof step !== 'object' || typeof step.operation !== 'string') {
+        throw new ToolInputError(`step ${i}: operation must be a string`);
+      }
+      const params = resolveRefs(step.params ?? {}, raw, i) as Record<string, unknown>;
+      const result = await runOne(step.operation, params);
+      raw.push(result);
+      results.push({ step: i, operation: step.operation, result });
+    } catch (error) {
+      return { results, error: { step: i, message: formatError(error) } };
+    }
+  }
+  return { results };
+}

package/src/core/instructions.js

@@ -1,2 +1,2 @@
 // Auto-generated server instructions
-export default "Hostinger API notes for agents. Tool descriptions are authoritative for request shapes; read them before calling.\n\nDatabases (web hosting, hosting_* tools)\n- MySQL runs on the same server as the website. From the deployed app connect to host 127.0.0.1, port 3306. PHP may also use localhost (Unix socket). Node.js should use 127.0.0.1: localhost can resolve to IPv6 (::1) and not every database user has that grant.\n- The `host` from hosting_listAccountDatabasesV1 (srvNNNN.hstgr.io) is only for connections from outside Hostinger, after hosting_createDatabaseRemoteConnectionV1. Never use it from the app.\n- Agency Plan (agency-hosting_* tools) database users are created for localhost; the PHP app connects there.\n\nAsynchronous operations\n- A success response often means \"queued\", not \"done\". Poll the matching read tool with backoff (seconds, then minutes). Never re-send the write.\n- hosting_createWebsiteV1 -> poll hosting_listWebsitesV1 until the domain appears (a few minutes).\n- hosting_startNode_jsBuildV1 -> hosting_getNode_jsBuildDetailsV1; logs via hosting_getNodeJSBuildLogsV1; on failure hosting_analyseFailedNode_jsBuildV1.\n- hosting_installWordPressV1 and WordPress plugin/theme/core jobs -> poll hosting_listWordPressInstallationsV1.\n- agency-hosting_createANewWebsiteV1 -> poll agency-hosting_getWebsiteSetupStatusV1 with setup_uuid; other Agency Plan jobs -> agency-hosting_listWebsiteProcessesV1.\n- Website deletion, database repair and domain contact changes finish in the background.\n\nCredentials\n- Never write database passwords or API tokens into source code, client-side JavaScript or committed .env files.\n- Node.js apps read them from environment variables: set the full set with hosting_replaceNode_jsEnvironmentVariablesV1 (full replace; values are masked on read). Build-time variables (Next.js) need a new build afterwards.\n- PHP apps read them from a config file on the server, outside the repository.\n- Generate strong passwords and do not echo them back once stored.\n\nFor end-to-end site builds install the headless skill: npx skills add hostinger/api-mcp-server";
+export default "Hostinger API notes for agents. Find operations with search; the inputSchema it returns is authoritative for request shapes. Run one with execute, or chain several with multi-execute.\n\nDatabases (web hosting, hosting_* operations)\n- MySQL runs on the same server as the website. From the deployed app connect to host 127.0.0.1, port 3306. PHP may also use localhost (Unix socket). Node.js should use 127.0.0.1: localhost can resolve to IPv6 (::1) and not every database user has that grant.\n- The `host` from hosting_databases_list (srvNNNN.hstgr.io) is only for connections from outside Hostinger, after hosting_databases_create-remote-connection. Never use it from the app.\n- Agency Plan (agency-hosting_* operations) database users are created for localhost; the PHP app connects there.\n\nAsynchronous operations\n- A success response often means \"queued\", not \"done\". Poll the matching read operation with backoff (seconds, then minutes). Never re-send the write.\n- hosting_websites_create -> poll hosting_websites_list until the domain appears (a few minutes).\n- hosting_nodejs_start-build -> hosting_nodejs_build; logs via hosting_nodejs_build-logs; on failure hosting_nodejs_analyse-failed-build.\n- wordpress_installations_install and WordPress plugin/theme/core jobs -> poll wordpress_installations_list.\n- agency-hosting_website-setups_create -> poll agency-hosting_website-setups_status with setup_uuid; other Agency Plan jobs -> agency-hosting_websites_list-processes.\n- Website deletion, database repair and domain contact changes finish in the background.\n\nCredentials\n- Never write database passwords or API tokens into source code, client-side JavaScript or committed .env files.\n- Node.js apps read them from environment variables: set the full set with hosting_nodejs_replace-environment-variables (full replace; values are masked on read). Build-time variables (Next.js) need a new build afterwards.\n- PHP apps read them from a config file on the server, outside the repository.\n- Generate strong passwords and do not echo them back once stored.\n\nFor end-to-end site builds install the headless skill: npx skills add hostinger/api-mcp-server";

package/src/core/instructions.ts

@@ -1,3 +1,3 @@
 // Auto-generated server instructions
-const instructions: string = "Hostinger API notes for agents. Tool descriptions are authoritative for request shapes; read them before calling.\n\nDatabases (web hosting, hosting_* tools)\n- MySQL runs on the same server as the website. From the deployed app connect to host 127.0.0.1, port 3306. PHP may also use localhost (Unix socket). Node.js should use 127.0.0.1: localhost can resolve to IPv6 (::1) and not every database user has that grant.\n- The `host` from hosting_listAccountDatabasesV1 (srvNNNN.hstgr.io) is only for connections from outside Hostinger, after hosting_createDatabaseRemoteConnectionV1. Never use it from the app.\n- Agency Plan (agency-hosting_* tools) database users are created for localhost; the PHP app connects there.\n\nAsynchronous operations\n- A success response often means \"queued\", not \"done\". Poll the matching read tool with backoff (seconds, then minutes). Never re-send the write.\n- hosting_createWebsiteV1 -> poll hosting_listWebsitesV1 until the domain appears (a few minutes).\n- hosting_startNode_jsBuildV1 -> hosting_getNode_jsBuildDetailsV1; logs via hosting_getNodeJSBuildLogsV1; on failure hosting_analyseFailedNode_jsBuildV1.\n- hosting_installWordPressV1 and WordPress plugin/theme/core jobs -> poll hosting_listWordPressInstallationsV1.\n- agency-hosting_createANewWebsiteV1 -> poll agency-hosting_getWebsiteSetupStatusV1 with setup_uuid; other Agency Plan jobs -> agency-hosting_listWebsiteProcessesV1.\n- Website deletion, database repair and domain contact changes finish in the background.\n\nCredentials\n- Never write database passwords or API tokens into source code, client-side JavaScript or committed .env files.\n- Node.js apps read them from environment variables: set the full set with hosting_replaceNode_jsEnvironmentVariablesV1 (full replace; values are masked on read). Build-time variables (Next.js) need a new build afterwards.\n- PHP apps read them from a config file on the server, outside the repository.\n- Generate strong passwords and do not echo them back once stored.\n\nFor end-to-end site builds install the headless skill: npx skills add hostinger/api-mcp-server";
+const instructions: string = "Hostinger API notes for agents. Find operations with search; the inputSchema it returns is authoritative for request shapes. Run one with execute, or chain several with multi-execute.\n\nDatabases (web hosting, hosting_* operations)\n- MySQL runs on the same server as the website. From the deployed app connect to host 127.0.0.1, port 3306. PHP may also use localhost (Unix socket). Node.js should use 127.0.0.1: localhost can resolve to IPv6 (::1) and not every database user has that grant.\n- The `host` from hosting_databases_list (srvNNNN.hstgr.io) is only for connections from outside Hostinger, after hosting_databases_create-remote-connection. Never use it from the app.\n- Agency Plan (agency-hosting_* operations) database users are created for localhost; the PHP app connects there.\n\nAsynchronous operations\n- A success response often means \"queued\", not \"done\". Poll the matching read operation with backoff (seconds, then minutes). Never re-send the write.\n- hosting_websites_create -> poll hosting_websites_list until the domain appears (a few minutes).\n- hosting_nodejs_start-build -> hosting_nodejs_build; logs via hosting_nodejs_build-logs; on failure hosting_nodejs_analyse-failed-build.\n- wordpress_installations_install and WordPress plugin/theme/core jobs -> poll wordpress_installations_list.\n- agency-hosting_website-setups_create -> poll agency-hosting_website-setups_status with setup_uuid; other Agency Plan jobs -> agency-hosting_websites_list-processes.\n- Website deletion, database repair and domain contact changes finish in the background.\n\nCredentials\n- Never write database passwords or API tokens into source code, client-side JavaScript or committed .env files.\n- Node.js apps read them from environment variables: set the full set with hosting_nodejs_replace-environment-variables (full replace; values are masked on read). Build-time variables (Next.js) need a new build afterwards.\n- PHP apps read them from a config file on the server, outside the repository.\n- Generate strong passwords and do not echo them back once stored.\n\nFor end-to-end site builds install the headless skill: npx skills add hostinger/api-mcp-server";
 export default instructions;

package/src/core/runtime.js

@@ -17,6 +17,7 @@ import { OAuthProvider, getEnvToken } from "./oauth.js";
 import * as tus from "tus-js-client";
 import fs from "fs";
 import path from "path";
+import { META_TOOLS, searchOperations, renderSearch, findOperation, runSteps } from "./catalog.js";
 
 // Load environment variables
 dotenvConfig({ quiet: true });
@@ -54,7 +55,7 @@ class MCPServer {
     this.toolList = tools;
     this.instructions = instructions;
     this.server = null;
-    this.tools = new Map();
+    this.operations = new Map();
     this.debug = process.env.DEBUG === "true";
     this.baseUrl = process.env.API_BASE_URL || "https://developers.hostinger.com";
     this.headers = this.parseHeaders(process.env.API_HEADERS || "");
@@ -115,20 +116,13 @@ class MCPServer {
    * This runs before the server is connected, so don't log here
    */
   initializeTools() {
-    // Initialize each tool in the tools map
+    // The operations are the catalog behind search/execute; they are not listed as tools.
     for (const tool of this.toolList) {
-      this.tools.set(tool.name, {
-        name: tool.name,
-        title: tool.title,
-        description: tool.description,
-        inputSchema: tool.inputSchema,
-        annotations: tool.annotations,
-        // Don't include security at the tool level
-      });
+      this.operations.set(tool.name, tool);
     }
 
     // Don't log here, we're not connected yet
-    console.error(`Initialized ${this.tools.size} tools`);
+    console.error(`Loaded ${this.operations.size} operations`);
   }
 
   /**
@@ -149,116 +143,98 @@ class MCPServer {
     // Handle tool listing requests
     this.server.setRequestHandler(ListToolsRequestSchema, async () => {
       this.log('debug', "Handling ListTools request");
-      // Return tools in the format expected by MCP SDK
-      return {
-        tools: Array.from(this.tools.entries()).map(([id, tool]) => ({
-          id,
-          ...tool,
-        })),
-      };
+      return { tools: META_TOOLS };
     });
 
-    // Handle tool execution requests
     this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
-      const { name, arguments: params } = request.params;
-      this.log('debug', "Handling CallTool request", { name, params });
-
-      let toolName;
-      let toolDetails;
-
-      // Find the requested tool
-      for (const [tid, tool] of this.tools.entries()) {
-        if (tool.name === name) {
-          toolName = name;
-          break;
-        }
-      }
+      const { name } = request.params;
+      const args = request.params.arguments ?? {};
+      this.log('debug', "Handling CallTool request", { name, args });
 
       // An unknown tool is a protocol error, not a tool execution error: the
       // model cannot self-correct its way out of a name the server does not
-      // have. -32602 is what the spec's example and the SDK's own McpServer
-      // use; a plain Error would go out as -32603 instead.
-      if (!toolName) {
+      // have. -32602 is what the spec's example and the SDK's own McpServer use.
+      if (!META_TOOLS.some(t => t.name === name)) {
         throw new McpError(ErrorCode.InvalidParams, `Tool not found: ${name}`);
       }
 
-      toolDetails = this.toolList.find(t => t.name === toolName);
-      if (!toolDetails) {
-        throw new McpError(ErrorCode.InternalError, `Tool details not found for ID: ${toolName}`);
-      }
-
+      // Everything below is a tool execution: failures (bad input, unknown
+      // operation, API errors) come back inside the result with isError: true.
       try {
-        this.log('info', `Executing tool: ${toolName}`);
-
-        let result;
-
-        if (toolDetails.custom) {
-          result = await this.executeCustomTool(toolDetails, params || {});
-        } else {
-          result = await this.executeApiCall(toolDetails, params || {});
+        if (name === 'search') {
+          const results = searchOperations(this.toolList, args.query, args.limit ?? undefined);
+          return { content: [{ type: "text", text: renderSearch(args.query, results) }] };
         }
 
-        // Return the result in the correct MCP format
-        return {
-          content: [
-            {
-              type: "text",
-              text: JSON.stringify(result)
-            }
-          ]
-        };
-
-      } catch (error) {
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        this.log('error', `Error executing tool ${name}: ${errorMessage}`);
-
-        // MCP reports tool execution failures (API errors, bad input, business
-        // logic) inside the result with isError: true. Throwing here would turn
-        // them into JSON-RPC protocol errors instead, which the spec reserves
-        // for unknown tools and malformed requests — those are still thrown,
-        // above, before this try. The status stays in the text so the model can
-        // tell a retryable 429/503 from a 403 it should not retry.
-        let errorText = errorMessage;
-        if (error instanceof ApiExecutionError) {
-          const payload = error.responseData;
-          const body = payload === null || payload === undefined || payload === ''
-            ? errorMessage
-            : typeof payload === 'object' ? JSON.stringify(payload) : String(payload);
-          errorText = error.status ? `HTTP ${error.status}: ${body}` : body;
+        if (name === 'execute') {
+          const result = await this.executeOperation(args.operation, args.params ?? {});
+          return { content: [{ type: "text", text: JSON.stringify(result) }] };
         }
 
+        const batch = await runSteps(
+          args.steps,
+          (operation, params) => this.executeOperation(operation, params),
+          (error) => this.formatToolError(error),
+        );
         return {
-          isError: true,
-          content: [
-            {
-              type: "text",
-              text: errorText
-            }
-          ]
+          ...(batch.error ? { isError: true } : {}),
+          content: [{ type: "text", text: JSON.stringify(batch) }],
         };
+      } catch (error) {
+        const errorText = this.formatToolError(error);
+        this.log('error', `Error executing ${name}: ${errorText}`);
+        return { isError: true, content: [{ type: "text", text: errorText }] };
       }
     });
   }
 
+  /**
+   * Look an operation up in the catalog, check its required params, and run it
+   * as either a custom tool or a plain API call.
+   */
+  async executeOperation(operation, params) {
+    const tool = findOperation(this.operations, operation, params);
+    this.log('info', `Executing operation: ${tool.name}`);
+    return tool.custom
+      ? this.executeCustomTool(tool, params)
+      : this.executeApiCall(tool, params);
+  }
+
+  /**
+   * Text for an isError result. The status stays in the text so the model can
+   * tell a retryable 429/503 from a 403 it should not retry.
+   */
+  formatToolError(error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    if (!(error instanceof ApiExecutionError)) {
+      return errorMessage;
+    }
+    const payload = error.responseData;
+    const body = payload === null || payload === undefined || payload === ''
+      ? errorMessage
+      : typeof payload === 'object' ? JSON.stringify(payload) : String(payload);
+    return error.status ? `HTTP ${error.status}: ${body}` : body;
+  }
+
   async executeCustomTool(tool, params) {
     switch (tool.name) {
-      case 'agency-hosting_deployNodeStaticWebsite':
+      case 'agency-hosting_deploy-node-static-website':
         return await this.handleNodeStaticDeploy(params);
-      case 'agency-hosting_deployPhpApplication':
+      case 'agency-hosting_deploy-php-application':
         return await this.handlePhpAppDeploy(params);
-      case 'hosting_importWordpressWebsite':
+      case 'hosting_import-wordpress-website':
         return await this.handleWordpressWebsiteImport(params);
-      case 'hosting_deployWordpressPlugin':
+      case 'hosting_deploy-wordpress-plugin':
         return await this.handleWordpressPluginDeploy(params);
-      case 'hosting_deployWordpressTheme':
+      case 'hosting_deploy-wordpress-theme':
         return await this.handleWordpressThemeDeploy(params);
-      case 'hosting_deployJsApplication':
+      case 'hosting_deploy-js-application':
         return await this.handleJavascriptApplicationDeploy(params);
-      case 'hosting_deployStaticWebsite':
+      case 'hosting_deploy-static-website':
         return await this.handleStaticWebsiteDeploy(params);
-      case 'hosting_listJsDeployments':
+      case 'hosting_list-js-deployments':
         return await this.handleListJavascriptDeployments(params);
-      case 'hosting_showJsDeploymentLogs':
+      case 'hosting_show-js-deployment-logs':
         return await this.handleShowJsDeploymentLogs(params);
       default:
         throw new Error(`Unknown custom tool: ${tool.name}`);
@@ -2625,7 +2601,7 @@ class MCPServer {
 
       // Start the server
       const server = app.listen(port, host, () => {
-        this.log('info', `MCP Server with HTTP streaming transport started successfully with ${this.tools.size} tools`);
+        this.log('info', `MCP Server with HTTP streaming transport started successfully with ${META_TOOLS.length} tools`);
         this.log('info', `Listening on http://${host}:${port}`);
       });
 
@@ -2651,8 +2627,8 @@ class MCPServer {
       await this.server.connect(transport);
 
       // Now we can safely log via MCP
-      console.error(`Registered ${this.tools.size} tools`);
-      this.log('info', `MCP Server with stdio transport started successfully with ${this.tools.size} tools`);
+      console.error(`Registered ${META_TOOLS.length} tools`);
+      this.log('info', `MCP Server with stdio transport started successfully with ${META_TOOLS.length} tools`);
     } catch (error) {
       console.error("Failed to start MCP server:", error);
       process.exit(1);