get_server_info

Instructions

Implementation Reference

• src/minestom/meta.ts:67-106 (handler)

  The main handler function 'createGetServerInfoTool' that defines the tool definition and executes the logic: parses input (includeDependencies), gets tool names, and returns server metadata including available tools, dependencies, knowledge catalog, runtime info, and version.

  export function createGetServerInfoTool(
  	getToolNames: () => string[],
  ): TanStackServerTool {
  	return toolDefinition({
  		description:
  			"Use this when you need package metadata, runtime details, tool inventory, or knowledge-catalog coverage for this Minestom MCP server.",
  		inputSchema: getServerInfoInputSchema,
  		name: "get_server_info",
  		outputSchema: getServerInfoOutputSchema,
  	}).server(async (args) => {
  		const { includeDependencies } = getServerInfoInputSchema.parse(args);
  		const availableTools = getToolNames();
  
  		return getServerInfoOutputSchema.parse({
  			availableTools,
  			dependencies: includeDependencies ? packageJson.dependencies : undefined,
  			description: packageJson.description,
  			knowledgeCatalog: {
  				coveredTopics: knowledgeCatalogMeta.coveredTopics,
  				environmentAwareTools: [
  					"inspect_minestom_environment",
  					"inspect_minestom_build",
  					"suggest_minestom_libraries",
  				],
  				supportsLiveLibraryLookup:
  					knowledgeCatalogMeta.supportsLiveLibraryLookup,
  				updatedOn: knowledgeCatalogMeta.updatedOn,
  				version: knowledgeCatalogMeta.version,
  			},
  			name: packageJson.name,
  			officialSources: knowledgeCatalogMeta.officialSources,
  			runtime: {
  				node: process.version,
  				platform: process.platform,
  			},
  			toolCount: availableTools.length,
  			version: packageJson.version,
  		});
  	});
  }

• src/minestom/meta.ts:37-65 (schema)

  Input schema (getServerInfoInputSchema) and output schema (getServerInfoOutputSchema) for the get_server_info tool. Input accepts optional 'includeDependencies' boolean. Output includes availableTools, dependencies, description, knowledgeCatalog, name, officialSources, runtime, toolCount, and version.

  const getServerInfoInputSchema = z.object({
  	includeDependencies: z
  		.boolean()
  		.default(false)
  		.describe(
  			"Whether to include runtime dependency versions in the response.",
  		),
  });
  
  const getServerInfoOutputSchema = z.object({
  	availableTools: z.array(z.string()),
  	dependencies: z.record(z.string(), z.string()).optional(),
  	description: z.string(),
  	knowledgeCatalog: z.object({
  		coveredTopics: z.array(minestomTopicSchema),
  		environmentAwareTools: z.array(z.string()),
  		supportsLiveLibraryLookup: z.boolean(),
  		updatedOn: z.string(),
  		version: z.string(),
  	}),
  	name: z.string(),
  	officialSources: z.array(officialLinkSchema),
  	runtime: z.object({
  		node: z.string(),
  		platform: z.string(),
  	}),
  	toolCount: z.number().int(),
  	version: z.string(),
  });

• src/tools.ts:15-28 (registration)

  Registration of the get_server_info tool: createGetServerInfoTool is called with a getToolNames callback that maps tool names from the tools array, then the result is pushed into the tools array.

  const tools: TanStackServerTool[] = [];
  const toolNames = () => tools.map((tool) => tool.name);
  
  tools.push(
  	pingTool,
  	createGetServerInfoTool(toolNames),
  	inspectMinestomEnvironmentTool,
  	inspectMinestomBuildTool,
  	explainMinestomPatternTool,
  	lookupMinestomApiTool,
  	planMinestomFeatureTool,
  	reviewMinestomDesignTool,
  	suggestMinestomLibrariesTool,
  );

• src/server.ts:8-97 (registration)

  Top-level server setup: tools are registered with the MCP server via registerTanStackTools, which calls registerTanStackTool for each tool (including get_server_info).

  (async () => {
  	console.error("Starting MineStom MCP server...");
  	const server = new McpServer({
  		name: "minestom-mcp",
  		description: packageJson.description,
  		version: packageJson.version,
  	});
  
  	registerTanStackTools(server, serverTools);
  
  	const transport = new StdioServerTransport();
  	await server.connect(transport);
  	console.error(
  		`MineStom server started with ${serverTools.length} tools, running through stdio.`,
  	);
  
  	process.on("uncaughtException", (err) => console.error(err));
  	process.on("exit", () => console.error("Shutting down MineStom MCP server."));
  	process.on("beforeExit", () => server.close());
  	process.on("SIGINT", () => process.exit());
  	process.on("SIGTERM", () => process.exit());
  })();