@nataliapc/mcp-openmsx 1.1.5 → 1.1.13

package/dist/server.js

@@ -6,11 +6,11 @@
  * through TCL commands via stdio.
  *
  * @package @nataliapc/mcp-openmsx
- * @version 1.1.4
+ * @version 1.1.13
  * @author Natalia Pujol Cremades (@nataliapc)
  * @license GPL2
  */
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { McpServer, ResourceTemplate } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
 import { isInitializeRequest } from "@modelcontextprotocol/sdk/types.js";
@@ -18,11 +18,13 @@ import { randomUUID } from "node:crypto";
 import { z } from "zod";
 import express from "express";
 import fs from "fs/promises";
+import mime from "mime-types";
 import path from "path";
 import { openMSXInstance } from "./openmsx.js";
-import { encodeTypeText, isErrorResponse } from "./utils.js";
+import { encodeTypeText, isErrorResponse, getResponseContent } from "./utils.js";
 // Version info for CLI
-const PACKAGE_VERSION = "1.1.4";
+const PACKAGE_VERSION = "1.1.13";
+const resourcesDir = path.join(path.dirname(new URL(import.meta.url).pathname), "../resources");
 // Defaults for openMSX paths
 var OPENMSX_EXECUTABLE = 'openmsx';
 var OPENMSX_SHARE_DIR = '/usr/share/openmsx';
@@ -35,31 +37,32 @@ var EXTENSIONS_DIR = `${OPENMSX_SHARE_DIR}/extensions`;
 // Tools available in the MCP server
 // https://modelcontextprotocol.io/docs/concepts/tools#tool-definition-structure
 //
-function registerAllTools(server) {
-    server.tool(
+async function registerAllTools(server) {
+    server.registerTool(
     // Name of the tool (used to call it)
-    "emu_control", 
-    // Description of the tool (what it does)
-    `Controls an openMSX emulator.
-		Commands:
-			'launch [machine] [extensions]': opens a powered-on openMSX emulator; you must wait some time waiting the machine is fully booted; machine and extensions parameters can be specified so use 'machineList' and 'extensionList' commands to obtain valid values. " +
-			'close': closes the openMSX emulator.
-			'powerOn': powers on the openMSX emulator.
-			'powerOff': powers off the openMSX emulator.
-			'reset': resets the current machine.
-			'getEmulatorSpeed': gets the current emulator speed as a percentage, default is 100.
-			'setEmulatorSpeed <emuspeed>': sets the emulator speed as a percentage, valid values are 1-10000, default is 100.
-			'machineList': gets a list of all available MSX machines that can be emulated with openMSX.
-			'extensionList': gets a list of all available MSX extensions that can be used with openMSX.
-			'wait <seconds>': performs a wait for the specified number of seconds, default is 2.
-		`, 
-    // Schema for the tool (input validation)
-    {
-        command: z.enum(["launch", "close", "powerOn", "powerOff", "reset", "getEmulatorSpeed", "setEmulatorSpeed", "machineList", "extensionList", "wait"]),
-        machine: z.string().min(1).max(100).optional(),
-        extensions: z.array(z.string().min(1).max(100)).optional(),
-        emuspeed: z.number().min(1).max(10000).optional().default(100),
-        seconds: z.number().min(1).max(10).optional().default(2), // Seconds to wait
+    "emu_control", {
+        title: "Emulator control tools",
+        // Description of the tool (what it does)
+        description: "Tools to control an openMSX emulator.",
+        // Schema for the tool (input validation)
+        inputSchema: {
+            command: z.enum(["launch", "close", "powerOn", "powerOff", "reset", "getEmulatorSpeed", "setEmulatorSpeed", "machineList", "extensionList", "wait"]).describe(`Available commands:
+'launch [machine] [extensions]': opens a powered-on openMSX emulator; you must wait some time waiting the machine is fully booted; machine and extensions parameters can be specified so use 'machineList' and 'extensionList' commands to obtain valid values. " +
+'close': closes the openMSX emulator.
+'powerOn': powers on the openMSX emulator.
+'powerOff': powers off the openMSX emulator.
+'reset': resets the current machine.
+'getEmulatorSpeed': gets the current emulator speed as a percentage, default is 100.
+'setEmulatorSpeed <emuspeed>': sets the emulator speed as a percentage, valid values are 1-10000, default is 100.
+'machineList': gets a list of all available MSX machines that can be emulated with openMSX.
+'extensionList': gets a list of all available MSX extensions that can be used with openMSX.
+'wait <seconds>': performs a wait for the specified number of seconds, default is 3.
+`),
+            machine: z.string().min(1).max(100).optional().describe("Machine name to launch; valid names can be obtained using [machineList]. Used by [launch]."),
+            extensions: z.array(z.string().min(1).max(100)).optional().describe("List of extensions to use; valid extensions can be obtained using [extensionList]. Used by [launch]."),
+            emuspeed: z.number().min(1).max(10000).optional().default(100).describe("Emulator speed as a percentage (1-10000); default is 100. Used by [setEmulatorSpeed]."),
+            seconds: z.number().min(1).max(10).optional().default(3).describe("Number of seconds to wait; default is 3. Used by [wait]."),
+        },
     }, 
     // Handler for the tool (function to be executed when the tool is called)
     async ({ command, machine, extensions, emuspeed, seconds }) => {
@@ -110,28 +113,29 @@ function registerAllTools(server) {
             result
         ]);
     });
-    server.tool(
+    server.registerTool(
     // Name of the tool (used to call it)
-    "emu_media", 
-    // Description of the tool (what it does)
-    `Manage tapes, rom cartridges, and floppy disks.
-		Commands:
-			'tapeInsert <tapefile>': insert a valid tape file (*.cas, *.wav, *.tsx).
-			'tapeRewind': rewind the current tape.
-			'tapeEject': remove tape from virtual cassette player.
-			'romInsert <romfile>': insert a valid ROM cartridge file (*.rom) at cartridge slot A.
-			'romEject': remove the current ROM cartridge from cartridge slot A.
-			'diskInsert <diskfile>': insert a valid disk file (*.dsk) in floppy disk A.
-			'diskInsertFolder <diskfolder>': use a host folder as a floppy disk A root directory.
-			'diskEject': remove the current disk from floppy disk A.
-		`, 
-    // Schema for the tool (input validation)
-    {
-        command: z.enum(["tapeInsert", "tapeRewind", "tapeEject", "romInsert", "romEject", "diskInsert", "diskInsertFolder", "diskEject"]),
-        tapefile: z.string().min(1).max(200).optional(), // Tape file to insert
-        romfile: z.string().min(1).max(200).optional(), // ROM file to insert
-        diskfile: z.string().min(1).max(200).optional(), // Disk file to insert
-        diskfolder: z.string().min(1).max(200).optional(), // Disk folder to insert
+    "emu_media", {
+        title: "Emulator media tools",
+        // Description of the tool (what it does)
+        description: "Manage tapes, rom cartridges, and floppy disks.",
+        // Schema for the tool (input validation)
+        inputSchema: {
+            command: z.enum(["tapeInsert", "tapeRewind", "tapeEject", "romInsert", "romEject", "diskInsert", "diskInsertFolder", "diskEject"]).describe(`Available commands:
+	'tapeInsert <tapefile>': insert a valid tape file (*.cas, *.wav, *.tsx).
+	'tapeRewind': rewind the current tape.
+	'tapeEject': remove tape from virtual cassette player.
+	'romInsert <romfile>': insert a valid ROM cartridge file (*.rom) at cartridge slot A.
+	'romEject': remove the current ROM cartridge from cartridge slot A.
+	'diskInsert <diskfile>': insert a valid disk file (*.dsk) in floppy disk A.
+	'diskInsertFolder <diskfolder>': use a host folder as a floppy disk A root directory.
+	'diskEject': remove the current disk from floppy disk A.
+`),
+            tapefile: z.string().min(1).max(200).optional().describe("Absolute Tape filename to insert. Used by [tapeInsert]"),
+            romfile: z.string().min(1).max(200).optional().describe("Absolute ROM filename to insert. Used by [romInsert]"),
+            diskfile: z.string().min(1).max(200).optional().describe("Absolute Disk filename to insert. Used by [diskInsert]"),
+            diskfolder: z.string().min(1).max(200).optional().describe("Absolute Disk folder filename to insert. Used by [diskInsertFolder]"),
+        },
     }, 
     // Handler for the tool (function to be executed when the tool is called)
     async ({ command, tapefile, romfile, diskfile, diskfolder }) => {
@@ -172,19 +176,20 @@ function registerAllTools(server) {
             response
         ]);
     });
-    server.tool(
+    server.registerTool(
     // Name of the tool (used to call it)
-    "emu_info", 
-    // Description of the tool (what it does)
-    `Obtain informacion about the current emulated machine.
-		Commands:
-			'getStatus': returns the status of the openMSX emulator.
-			'getSlotsMap': shows what devices/ROM/RAM are inserted into which slots.
-			'getIOPortsMap': shows an overview about the I/O mapped devices.
-		`, 
-    // Schema for the tool (input validation)
-    {
-        command: z.enum(["getStatus", "getSlotsMap", "getIOPortsMap"]),
+    "emu_info", {
+        title: "Emulator info tools",
+        // Description of the tool (what it does)
+        description: "Obtain informacion about the current emulated machine.",
+        // Schema for the tool (input validation)
+        inputSchema: {
+            command: z.enum(["getStatus", "getSlotsMap", "getIOPortsMap"]).describe(`Available commands:
+	'getStatus': returns the status of the openMSX emulator.
+	'getSlotsMap': shows what devices/ROM/RAM are inserted into which slots.
+	'getIOPortsMap': shows an overview about the I/O mapped devices.
+`),
+        },
     }, 
     // Handler for the tool (function to be executed when the tool is called)
     async ({ command }) => {
@@ -210,24 +215,25 @@ function registerAllTools(server) {
             response
         ]);
     });
-    server.tool(
+    server.registerTool(
     // Name of the tool (used to call it)
-    "emu_vdp", 
-    // Description of the tool (what it does)
-    `Manage the VDP (Video Display Processor).
-		Commands:
-			'getPalette': returns the current V9938/V9958 color palette in RGB333 format.
-			'getRegisters': returns all VDP register values.
-			'getRegisterValue <register>': returns the value of a specific VDP register (0-31) in decimal format.
-			'setRegisterValue <register> <value>': sets a hexadecimal value to a specific VDP register (0-31).
-			'screenGetMode': returns the current screen mode (0-12) as a number, which matches the BASIC SCREEN command.
-			'screenGetFullText': returns the full content of an MSX text screen (screen 0 or 1) as a string; PRIORITIZE this command to view screen content in text modes.
-		`, 
-    // Schema for the tool (input validation)
-    {
-        command: z.enum(["getPalette", "getRegisters", "getRegisterValue", "setRegisterValue", "screenGetMode", "screenGetFullText"]),
-        register: z.number().min(0).max(31).optional(), // Register to read/write
-        value: z.string().regex(/^0x[0-9a-fA-F]{2}$/).optional(),
+    "emu_vdp", {
+        title: "VDP tools",
+        // Description of the tool (what it does)
+        description: "Manage the VDP (Video Display Processor).",
+        // Schema for the tool (input validation)
+        inputSchema: {
+            command: z.enum(["getPalette", "getRegisters", "getRegisterValue", "setRegisterValue", "screenGetMode", "screenGetFullText"]).describe(`Available commands:
+	'getPalette': returns the current V9938/V9958 color palette in RGB333 format.
+	'getRegisters': returns all VDP register values.
+	'getRegisterValue <register>': returns the value of a specific VDP register (0-31) in decimal format.
+	'setRegisterValue <register> <value>': sets a hexadecimal value to a specific VDP register (0-31).
+	'screenGetMode': returns the current screen mode (0-12) as a number, which matches the BASIC SCREEN command.
+	'screenGetFullText': returns the full content of an MSX text screen (screen 0 or 1) as a string; PRIORITIZE this command to view screen content in text modes.
+`),
+            register: z.number().min(0).max(31).optional().describe("VDP register number (0-31) to read/write. Used by [getRegisterValue, setRegisterValue]"),
+            value: z.string().regex(/^0x[0-9a-fA-F]{2}$/).optional().describe("2 hexadecimal digits for a VDP register value (e.g. 0x1f). Used by [setRegisterValue]"),
+        },
     }, 
     // Handler for the tool (function to be executed when the tool is called)
     async ({ command, register, value }) => {
@@ -263,26 +269,27 @@ function registerAllTools(server) {
             response
         ]);
     });
-    server.tool(
+    server.registerTool(
     // Name of the tool (used to call it)
-    "debug_run", 
-    // Description of the tool (what it does)
-    `Control execution (break, continue, step).
-		Commands:
-			'break': to break CPU at current execution position.
-			'isBreaked': to check if the CPU is currently in break state (1) or not (0).
-			'continue': to continue execution after break.
-			'stepIn': to execute one CPU instruction, go into subroutines.
-			'stepOver': to execute one CPU instruction, but don't go into subroutines.
-			'stepOut': to step out of the current subroutine.
-			'stepBack': to step one instruction back in time.
-			'runTo <address>': to run the CPU until it reaches the specified address.
-		**Important Note**: Addresses and values are in hexadecimal format (e.g. 0x0000).
-		`, 
-    // Schema for the tool (input validation)
-    {
-        command: z.enum(["break", "isBreaked", "continue", "stepIn", "stepOut", "stepOver", "stepBack", "runTo"]),
-        address: z.string().regex(/^0x[0-9a-fA-F]{4}$/).optional()
+    "debug_run", {
+        title: "CPU Runtime Debugger tools",
+        // Description of the tool (what it does)
+        description: "Control execution (break, continue, step).",
+        // Schema for the tool (input validation)
+        inputSchema: {
+            command: z.enum(["break", "isBreaked", "continue", "stepIn", "stepOut", "stepOver", "stepBack", "runTo"]).describe(`Available commands:
+	'break': to break CPU (pause emulation) at current execution position.
+	'isBreaked': to check if the CPU is currently in break state (1) or not (0).
+	'continue': to continue execution after break.
+	'stepIn': to execute one CPU instruction, go into subroutines.
+	'stepOver': to execute one CPU instruction, but don't go into subroutines.
+	'stepOut': to step out of the current subroutine.
+	'stepBack': to step one instruction back in time.
+	'runTo <address>': to run the CPU until it reaches the specified address.
+**Important Note**: Addresses and values are in hexadecimal format (e.g. 0x0000).
+`),
+            address: z.string().regex(/^0x[0-9a-fA-F]{4}$/).optional().describe("4 hexadecimal digits for a memory address (e.g. 0x4af3). Used by [runTo]"),
+        },
     }, 
     // Handler for the tool (function to be executed when the tool is called)
     async ({ command, address }) => {
@@ -322,27 +329,29 @@ function registerAllTools(server) {
             response
         ]);
     });
-    server.tool(
+    server.registerTool(
     // Name of the tool (used to call it)
-    "debug_cpu", 
-    // Description of the tool (what it does)
-    `Read/write CPU registers, CPU info, Stack pile, and Disassemble code from memory.
-		Commands:
-			'getCpuRegisters': to get an overview of all the CPU registers.
-			'getRegister <register>': to get the decimal value of a specific CPU register (pc, sp, ix, iy, af, bc, de, hl, ixh, ixl, iyh, iyl, a, f, b, c, d, e, h, l, i, r, im, iff).
-			'setRegister <register> <value>': to set the value of a specific CPU register (pc, sp, ix, iy, af, bc, de, hl, ixh, ixl, iyh, iyl, a, f, b, c, d, e, h, l, i, r, im, iff).
-			'getStackPile': to get an overview of the CPU stack.
-			'disassemble [address] [size]': to print disassembled instructions at the address parameter location or PC register if empty.
-			'getActiveCpu': to return the active cpu: z80 or r800.
-		"**Important Note**: Addresses and values are in hexadecimal format (e.g. 0x0000)."
-		`, 
-    // Schema for the tool (input validation)
-    {
-        command: z.enum(["getCpuRegisters", "getRegister", "setRegister", "getStackPile", "disassemble", "getActiveCpu"]),
-        register: z.enum(["pc", "sp", "ix", "iy", "af", "bc", "de", "hl", "ixh", "ixl", "iyh", "iyl", "a", "f", "b", "c", "d", "e", "h", "l", "i", "r", "im", "iff"]).optional(),
-        address: z.string().regex(/^0x[0-9a-fA-F]{4}$/), // 4 hex digits for MSX memory address
-        value: z.string().regex(/^0x[0-9a-fA-F]{2-4}$/).optional(), // 2-4 hex digits for byte value for writeByte command
-        size: z.number().min(1).max(50).optional().default(8), // Number of bytes for disassemble command
+    "debug_cpu", {
+        title: "CPU tools",
+        // Description of the tool (what it does)
+        description: "Read/write CPU registers, CPU info, Stack pile, and Disassemble code from memory.",
+        // Schema for the tool (input validation)
+        inputSchema: {
+            command: z.enum(["getCpuRegisters", "getRegister", "setRegister", "getStackPile", "disassemble", "getActiveCpu"]).describe(`Available commands:
+	'getCpuRegisters': to get an overview of all the CPU registers.
+	'getRegister <register>': to get the decimal value of a specific CPU register (pc, sp, ix, iy, af, bc, de, hl, ixh, ixl, iyh, iyl, a, f, b, c, d, e, h, l, i, r, im, iff).
+	'setRegister <register> <value>': to set the value of a specific CPU register (pc, sp, ix, iy, af, bc, de, hl, ixh, ixl, iyh, iyl, a, f, b, c, d, e, h, l, i, r, im, iff).
+	'getStackPile': to get an overview of the CPU stack.
+	'disassemble [address] [size]': to print disassembled instructions at the address parameter location or PC register if empty.
+	'getActiveCpu': to return the active cpu: z80 or r800.
+"**Important Note**: Addresses and values are in hexadecimal format (e.g. 0xd2 0x3af2)."
+`),
+            register: z.enum(["pc", "sp", "ix", "iy", "af", "bc", "de", "hl", "ixh", "ixl", "iyh", "iyl", "a", "f", "b", "c", "d", "e", "h", "l", "i", "r", "im", "iff"]).optional()
+                .describe("CPU register to read/write. Used by [getRegister, setRegister]"),
+            address: z.string().regex(/^0x[0-9a-fA-F]{4}$/).optional().describe("4 hexadecimal digits for a memory address (e.g. 0x4af3). Used by [disassemble]"),
+            value: z.string().regex(/^0x[0-9a-fA-F]{2,4}$/).optional().describe("2-4 hexadecimal digits for a byte value (e.g. 0xa5 or 0xa5b1). Used by [setRegister]"),
+            size: z.number().min(8).max(50).optional().describe("Number of bytes to disassemble. Used by [disassemble]"),
+        },
     }, 
     // Handler for the tool (function to be executed when the tool is called)
     async ({ command, address, register, value, size }) => {
@@ -376,27 +385,28 @@ function registerAllTools(server) {
             response
         ]);
     });
-    server.tool(
+    server.registerTool(
     // Name of the tool (used to call it)
-    "debug_memory", 
-    // Description of the tool (what it does)
-    `Slots info, and Read/write from/to memory in the openMSX emulator.
-		Commands:
-			'selectedSlots': to get a list of the currently selected memory slots.
-			'getBlock <address> [lines]': to read a block of memory from the specified address.
-			'readByte <address>': to read a BYTE from the specified address.
-			'readWord <address>': to read a WORD from the specified address.
-			'writeByte <address> <value8>': to write a BYTE to the specified address.
-			'writeWord <address> <value16>': to write a WORD to the specified address.
-		**Important Note**: Addresses and values are in hexadecimal format (e.g. 0x0000).
-		`, 
-    // Schema for the tool (input validation)
-    {
-        command: z.enum(["selectedSlots", "getBlock", "readByte", "readWord", "writeByte", "writeWord"]),
-        address: z.string().regex(/^0x[0-9a-fA-F]{4}$/).optional(), // 4 hex digits for MSX memory address
-        lines: z.number().min(1).max(50).optional().default(8), // Number of lines for getBlock command
-        value8: z.string().regex(/^0x[0-9a-fA-F]{2}$/).optional(), // 2 hex digits for byte value for writeByte command
-        value16: z.string().regex(/^0x[0-9a-fA-F]{4}$/).optional(), // 4 hex digits for byte value for writeByte command
+    "debug_memory", {
+        title: "Memory tools",
+        // Description of the tool (what it does)
+        description: "Slots info, and Read/write from/to memory in the openMSX emulator.",
+        // Schema for the tool (input validation)
+        inputSchema: {
+            command: z.enum(["selectedSlots", "getBlock", "readByte", "readWord", "writeByte", "writeWord"]).describe(`Available commands:
+	'selectedSlots': to get a list of the currently selected memory slots.
+	'getBlock <address> [lines]': to read a block of memory from the specified address.
+	'readByte <address>': to read a BYTE from the specified address.
+	'readWord <address>': to read a WORD from the specified address.
+	'writeByte <address> <value8>': to write a BYTE to the specified address.
+	'writeWord <address> <value16>': to write a WORD to the specified address.
+**Important Note**: Addresses and values are in hexadecimal format (e.g. 0x0000).
+`),
+            address: z.string().regex(/^0x[0-9a-fA-F]{4}$/).optional().describe("4 hexadecimal digits for a memory address (e.g. 0x4af3). Used by [getBlock, readByte, writeByte, readWord, writeWord]"),
+            lines: z.number().min(1).max(50).optional().default(8).describe("Number of lines to obtain. Used by [getBlock]"),
+            value8: z.string().regex(/^0x[0-9a-fA-F]{2}$/).optional().describe("2 hexadecimal digits for a byte value (e.g. 0xa5). Used by [writeByte]"),
+            value16: z.string().regex(/^0x[0-9a-fA-F]{4}$/).optional().describe("4 hexadecimal digits for a word value (e.g. 0xa5b1). Used by [writeWord]"),
+        },
     }, 
     // Handler for the tool (function to be executed when the tool is called)
     async ({ command, address, lines, value8, value16 }) => {
@@ -430,23 +440,24 @@ function registerAllTools(server) {
             response
         ]);
     });
-    server.tool(
+    server.registerTool(
     // Name of the tool (used to call it)
-    "debug_vram", 
-    // Description of the tool (what it does)
-    `Read or write from/to VRAM video memory in the openMSX emulator.
-		Commands:
-			'getBlock <address> [lines]': to read a block of VRAM memory from the specified address.
-			'readByte <address>': to read a BYTE from the specified VRAM address.
-			'writeByte <address> <value8>': to write a BYTE to the specified VRAM address.
-		**Important Note**: Addresses and values are in hexadecimal format (e.g. 0x0000).
-		`, 
-    // Schema for the tool (input validation)
-    {
-        command: z.enum(["getBlock", "readByte", "writeByte"]),
-        address: z.string().regex(/^0x[0-9a-fA-F]{4}$/).optional(), // 4 hex digits for MSX memory address
-        lines: z.number().min(1).max(50).optional().default(8), // Number of lines for getBlock command
-        value8: z.string().regex(/^0x[0-9a-fA-F]{2}$/).optional(), // 2 hex digits for byte value for writeByte command
+    "debug_vram", {
+        title: "VRAM tools",
+        // Description of the tool (what it does)
+        description: "Read or write from/to VRAM video memory from the openMSX emulator.",
+        // Schema for the tool (input validation)
+        inputSchema: {
+            command: z.enum(["getBlock", "readByte", "writeByte"]).describe(`Available commands:
+	'getBlock <address> [lines]': to read a block of VRAM memory from the specified address.
+	'readByte <address>': to read a BYTE from the specified VRAM address.
+	'writeByte <address> <value8>': to write a BYTE to the specified VRAM address.
+**Important Note**: Addresses and values are in hexadecimal format (e.g. 0x0000).
+`),
+            address: z.string().regex(/^0x[0-9a-fA-F]{5}$/).optional().describe("5 hexadecimal digits for a VRAM address (e.g. 0x04af3). Used by [getBlock, readByte, writeByte]"),
+            lines: z.number().min(1).max(50).optional().default(8).describe("Number of lines to obtain. Used by [getBlock]"),
+            value8: z.string().regex(/^0x[0-9a-fA-F]{2}$/).optional().describe("2 hexadecimal digits for a byte value (e.g. 0xa5). Used by [writeByte]"),
+        },
     }, 
     // Handler for the tool (function to be executed when the tool is called)
     async ({ command, address, lines, value8 }) => {
@@ -471,23 +482,24 @@ function registerAllTools(server) {
             response
         ]);
     });
-    server.tool(
+    server.registerTool(
     // Name of the tool (used to call it)
-    "debug_breakpoints", 
-    // Description of the tool (what it does)
-    `Create, remove, and list breakpoints.
-		Commands:
-			'create <address>': create a breakpoint at a specified address, and returns its name.
-			'remove <bpname>': remove a breakpoint by name (e.g. bp#1).
-			'list': enumerate the active breakpoints.
-		"**Important Note**: Addresses and values are in hexadecimal format (e.g. 0x0000).
-		"**Important Note**: The memory addresses of functions and variables can be previously obtained from *.sym or *.map files.
-		`, 
-    // Schema for the tool (input validation)
-    {
-        command: z.enum(["create", "remove", "list"]),
-        address: z.string().regex(/^0x[0-9a-fA-F]{4}$/).optional(), // 4 hex digits for MSX memory address
-        bpname: z.string().min(3).max(10).optional(), // breakpoint name (e.g. bp#1)
+    "debug_breakpoints", {
+        title: "Breakpoints tools",
+        // Description of the tool (what it does)
+        description: "Create, remove, and list breakpoints.",
+        // Schema for the tool (input validation)
+        inputSchema: {
+            command: z.enum(["create", "remove", "list"]).describe(`Available commands:
+	'create <address>': create a breakpoint at a specified address, and returns its name.
+	'remove <bpname>': remove a breakpoint by name (e.g. bp#1).
+	'list': enumerate the active breakpoints.
+"**Important Note**: Addresses and values are in hexadecimal format (e.g. 0x4af3).
+"**Important Note**: The memory addresses of functions and variables can be previously obtained from *.sym or *.map files.
+`),
+            address: z.string().regex(/^0x[0-9a-fA-F]{4}$/).optional().describe("4 hexadecimal digits for a memory address (e.g. 0x4af3). Used by [create]"),
+            bpname: z.string().min(3).max(10).optional().describe("Breakpoint name (e.g. bp#1). Used by [remove]"),
+        },
     }, 
     // Handler for the tool (function to be executed when the tool is called)
     async ({ command, address, bpname }) => {
@@ -512,21 +524,22 @@ function registerAllTools(server) {
             response
         ]);
     });
-    server.tool(
+    server.registerTool(
     // Name of the tool (used to call it)
-    "emu_savestates", 
-    // Description of the tool (what it does)
-    `Load, save, and list savestates.
-		Commands:
-			'load <name>': restores a previously created savestate.
-			'save <name>': creates a snapshot of the currently emulated MSX machine specifying a name for the savestate.
-			'list': returns the names of all previously created savestates, separated by spaces.
-		**Important Note**: names with spaces are enclosed in {}.
-		`, 
-    // Schema for the tool (input validation)
-    {
-        command: z.enum(["load", "save", "list"]),
-        name: z.string().min(1).max(20).optional(), // breakpoint name (e.g. bp#1)
+    "emu_savestates", {
+        title: "Save states tools",
+        // Description of the tool (what it does)
+        description: "Load, save, and list savestates.",
+        // Schema for the tool (input validation)
+        inputSchema: {
+            command: z.enum(["load", "save", "list"]).describe(`Available commands:
+	'load <name>': restores a previously created savestate.
+	'save <name>': creates a snapshot of the currently emulated MSX machine specifying a name for the savestate.
+	'list': returns the names of all previously created savestates, separated by spaces.
+**Important Note**: names with spaces are enclosed in {}.
+`),
+            name: z.string().min(1).max(20).optional().describe("Name of the savestate to load/save. Used by [load, save]"),
+        },
     }, 
     // Handler for the tool (function to be executed when the tool is called)
     async ({ command, name }) => {
@@ -556,32 +569,35 @@ function registerAllTools(server) {
             response
         ]);
     });
-    server.tool(
+    server.registerTool(
     // Name of the tool (used to call it)
-    "emu_replay", 
-    // Description of the tool (what it does)
-    `When replay is enabled (the default) the emulator collect data while emulating,
-		which enables you to go back and forward in MSX time.
-		Commands:
-			'start': starts the replay mode (enabled by default when emulator is launched).
-			'stop': stops the replay mode.
-			'status': gives information about the replay feature and the data that is collected.
-			'goBack <seconds>': go back specified seconds (1-60) in the timeline, you cannot go back to a time before the time the replay started.
-			'absoluteGoto <time>': go to the indicated absolute time in seconds in the MSX timeline, if time is before replay started it will jump to the time when is started.
-			'truncate': stop replaying and wipe all the future replay data after now.
-			'saveReplay [filename]': saves the current replay data to a file (extension .omr), filename is returned in the response.
-			'loadReplay <filename>': loads a previously saved replay file (extension .omr), starts replaying from the begin, and starts replay mode.
-		**Important Note**: consider do a #debug_run 'break' to maintain the timeline before a 'goBack' or 'absoluteGoto'.
-		`, 
-    // Schema for the tool (input validation)
-    {
-        command: z.enum(["start", "stop", "status", "goBack", "absoluteGoto", "truncate", "saveReplay", "loadReplay"]),
-        seconds: z.number().min(1).max(60).optional(), // Seconds to go back
-        time: z.string().regex(/^\d+$/).optional(), // Time in seconds to go to
-        filename: z.string().min(1).max(200).optional(), // Filename to save/load replay
+    "emu_replay", {
+        title: "Replay tools",
+        // Description of the tool (what it does)
+        description: "When replay is enabled (the default) the emulator collect data while emulating, which enables you to go back and forward in the emulated MSX time.",
+        // Schema for the tool (input validation)
+        inputSchema: {
+            command: z.enum(["start", "stop", "status", "goBack", "absoluteGoto", "truncate", "advanceFrame", "reverseFrame", "saveReplay", "loadReplay"]).describe(`Available commands:
+	'start': starts the replay mode (enabled by default when emulator is launched).
+	'stop': stops the replay mode.
+	'status': gives information about the replay feature and the data that is collected.
+	'goBack <seconds>': go back specified seconds (1-60) in the timeline, you cannot go back to a time before the time the replay started.
+	'absoluteGoto <time>': go to the indicated absolute time in seconds in the MSX timeline, if time is before replay started it will jump to the time when is started.
+	'truncate': stop replaying and wipe all the future replay data after now.
+	'advanceFrame' [frames]: advances a number of frames in the replay timeline, useful to advance the timeline while debugging.
+	'reverseFrame' [frames]: reverses a number of frames in the replay timeline, useful to reverse the timeline while debugging.
+	'saveReplay [filename]': saves the current replay data to a file (extension .omr), filename is returned in the response.
+	'loadReplay <filename>': loads a previously saved replay file (extension .omr), starts replaying from the begin, and starts replay mode.
+**Important Note**: consider do a #debug_run 'break' to maintain the timeline before a 'goBack' or 'absoluteGoto'.
+`),
+            seconds: z.number().min(1).max(60).optional().describe("Seconds to go back. Used by [goBack]"),
+            time: z.string().regex(/^\d+$/).optional().describe("Absolute time in seconds to go to. Used by [absoluteGoto]"),
+            frames: z.number().min(1).max(1000).optional().default(1).describe("Number of frames to advance/reverse. Used by [advanceFrame, reverseFrame]"),
+            filename: z.string().min(1).max(200).optional().describe("Filename to save/load replay. Used by [saveReplay, loadReplay]"),
+        },
     }, 
     // Handler for the tool (function to be executed when the tool is called)
-    async ({ command, seconds, time, filename }) => {
+    async ({ command, seconds, time, frames, filename }) => {
         let tclCommand;
         switch (command) {
             case "start":
@@ -602,6 +618,12 @@ function registerAllTools(server) {
             case "truncate":
                 tclCommand = "reverse truncatereplay";
                 break;
+            case "advanceFrame":
+                tclCommand = `advance_frame ${frames}`;
+                break;
+            case "reverseFrame":
+                tclCommand = `reverse_frame ${frames}`;
+                break;
             case "saveReplay":
                 if (filename)
                     filename = `"${OPENMSX_REPLAYS_DIR}${filename}"`;
@@ -622,20 +644,21 @@ function registerAllTools(server) {
             response
         ]);
     });
-    server.tool(
+    server.registerTool(
     // Name of the tool (used to call it)
-    "emu_keyboard", 
-    // Description of the tool (what it does)
-    `Send a text to the openMSX emulator.
-		Commands:
-			'sendText <text>': type a string in the emulated MSX, this command automatically press and release keys in the MSX keyboard matrix.
-		**Important Note**: each 'text' sent is limited to 200 characters, and the 'text' is sent as if it was typed in the MSX keyboard.
-		**Important Note**: escape keys that needs it as Return key (use \\r), double quotes (use \\\"), etc...
-		`, 
-    // Schema for the tool (input validation)
-    {
-        command: z.enum(["sendText"]),
-        text: z.string().min(1).max(200).optional().default(''), // Key to send to the emulator
+    "emu_keyboard", {
+        title: "Keyboard tools",
+        // Description of the tool (what it does)
+        description: "Send a text to the openMSX emulator.",
+        // Schema for the tool (input validation)
+        inputSchema: {
+            command: z.enum(["sendText"]).describe(`Available commands:
+	'sendText <text>': type a string in the emulated MSX, this command automatically press and release keys in the MSX keyboard matrix.
+**Important Note**: each 'text' sent is limited to 200 characters, and the 'text' is sent as if it was typed in the MSX keyboard.
+**Important Note**: escape keys that needs it as Return key (use \\r), double quotes (use \\\"), etc...
+`),
+            text: z.string().min(1).max(200).optional().default('').describe("Text to send to the emulator via emulated keyboard"),
+        },
     }, 
     // Handler for the tool (function to be executed when the tool is called)
     async ({ command, text }) => {
@@ -654,18 +677,19 @@ function registerAllTools(server) {
             response
         ]);
     });
-    server.tool(
+    server.registerTool(
     // Name of the tool (used to call it)
-    "screen_shot", 
-    // Description of the tool (what it does)
-    `Take a screenshot of the openMSX emulator screen.
-		Commands:
-			'as_image': take a screenshot and the image is returned in the response.
-			'to_file': take a screenshot and save it to a file, the file name is returned in the response.
-		`, 
-    // Schema for the tool (input validation)
-    {
-        command: z.enum(["as_image", "to_file"]),
+    "screen_shot", {
+        title: "Screenshot tools",
+        // Description of the tool (what it does)
+        description: "Take a screenshot of the openMSX emulator screen.",
+        // Schema for the tool (input validation)
+        inputSchema: {
+            command: z.enum(["as_image", "to_file"]).describe(`Available commands:
+	'as_image': take a screenshot and the image is returned in the response.
+	'to_file': take a screenshot and save it to a file, the file name is returned in the response.
+`),
+        },
     }, 
     // Handler for the tool (function to be executed when the tool is called)
     async ({ command }) => {
@@ -674,7 +698,7 @@ function registerAllTools(server) {
         switch (command) {
             case "as_image":
                 try {
-                    // Check if the response is a file path using fstat
+                    // Check if the response is a file path
                     if (!response || !response.startsWith(OPENMSX_SCREENSHOT_DIR) || !response.endsWith('.png')) {
                         throw new Error(`Invalid screenshot "${response}"`);
                     }
@@ -710,16 +734,18 @@ function registerAllTools(server) {
             `Error: Unknown screen_shot command "${command}".`
         ]);
     });
-    server.tool(
+    server.registerTool(
     // Name of the tool (used to call it)
-    "screen_dump", 
-    // Description of the tool (what it does)
-    `Take a screendump of the openMSX emulator screen as SC?.
-		The parameter scrbasename is the name of the filename (without path) to save the screendump, default is 'screendump'.
-		`, 
-    // Schema for the tool (input validation)
-    {
-        scrbasename: z.string().min(1).max(100).default("screendump"),
+    "screen_dump", {
+        title: "Screen dump tools",
+        // Description of the tool (what it does)
+        description: `Take a screendump of the openMSX emulator screen as SC?.
+The parameter scrbasename is the name of the filename (without path) to save the screendump, default is 'screendump'.
+`,
+        // Schema for the tool (input validation)
+        inputSchema: {
+            scrbasename: z.string().min(1).max(100).default("screendump").describe("Screendump filename (without path or extension) to save the screendump; default is 'screendump'"),
+        },
     }, 
     // Handler for the tool (function to be executed when the tool is called)
     async ({ scrbasename }) => {
@@ -730,93 +756,105 @@ function registerAllTools(server) {
             response
         ]);
     });
-    server.tool(
+    server.registerTool(
     // Name of the tool (used to call it)
-    "basic_programming", 
-    // Description of the tool (what it does)
-    `Tool helper to develop BASIC programs.
-		Commands:
-			'newProgram': clears the current BASIC program.
-			'setProgram <program>': sets/updates the current BASIC program to the specified string.
-			'runProgram': runs the current BASIC program.
-			'getFullProgram': returns the current BASIC program as a plain text string.
-			'getFullProgramAdvanced': returns the current BASIC program with the ram address where each line is coded.
-			'listProgramLines <startLine> [endLine]': lists at the emulator screen the selected range lines of the current BASIC program.
-			'deleteProgramLines <startLine> [endline]': deletes a specific line range from the current BASIC program, if endline is not specified, only the startLine is deleted.
-		**Important Note**: priorize this tools to develop BASIC programs, it's more efficient than using the 'sendText' tool.
-		**Important Note**: all the program lines must be ended with a carriage return (\\r) to be correctly processed, even the last one.
-		`, 
-    // Schema for the tool (input validation)
-    {
-        command: z.enum(["newProgram", "runProgram", "setProgram", "getFullProgram", "getFullProgramAdvanced", "listProgramLines", "deleteProgramLines"]),
-        program: z.string().min(1).max(10000).optional(), // BASIC program to set
-        startLine: z.number().min(0).max(9999).optional(),
-        endLine: z.number().min(0).max(9999).optional(),
+    "basic_programming", {
+        title: "BASIC programming tools",
+        // Description of the tool (what it does)
+        description: "Helper tool for developing BASIC programs.",
+        // Schema for the tool (input validation)
+        inputSchema: {
+            command: z.enum(["isBasicAvailable", "newProgram", "runProgram", "setProgram", "getFullProgram", "getFullProgramAdvanced", "listProgramLines", "deleteProgramLines"]).describe(`Available commands:
+	'isBasicAvailable': checks if the current machine is ready to manage BASIC programs (true), or not (false).
+	'newProgram': clears the current BASIC program.
+	'setProgram <program>': sets a full BASIC program or updates part of the current BASIC program with the specified string.
+	'runProgram': runs the current BASIC program.
+	'getFullProgram': retrieves the current BASIC program as plain text; very useful in text screen modes.
+	'getFullProgramAdvanced': retrieves the current BASIC program along with the RAM address where each line is stored.
+	'listProgramLines <startLine> [endLine]': lists the selected range of lines from the current BASIC program on the emulator screen.
+	'deleteProgramLines <startLine> [endLine]': deletes a specific range of lines from the current BASIC program; if endLine is not specified, only the startLine is deleted.
+**Important Note**: if error 'not in BASIC mode' then use the command 'isBasicAvailable' to wait for a ready state.
+**Important Note**: prioritize these tools for developing BASIC programs, as they are more efficient than using the 'sendText' tool.
+**Important Note**: all program lines must end with a carriage return (\\r) to be processed correctly, including the last line.
+**Important Note**: if you have questions about MSX BASIC, use the resources provided by this MCP server.
+`),
+            program: z.string().min(1).max(10000).optional().describe("Basic program to set; use only \\r for line endings, even the last one. Used by [setProgram]"),
+            startLine: z.number().min(0).max(9999).optional().describe("Start line number to list/delete BASIC program lines. Used by [listProgramLines, deleteProgramLines]"),
+            endLine: z.number().min(0).max(9999).optional().describe("End line number to list/delete BASIC program lines. Used by [listProgramLines, deleteProgramLines]"),
+        },
     }, 
     // Handler for the tool (function to be executed when the tool is called)
     async ({ command, program, startLine, endLine }) => {
         const CTRL_L_TEMPLATE = 'keymatrixdown 6 2 ; keymatrixdown 4 2 ; after time 0.1 { keymatrixup 6 2 ; keymatrixup 4 2 ; type_via_keybuf "%s" }';
         let tclCommand = undefined;
         let response = undefined;
-        switch (command) {
-            case "newProgram":
-                response = await openMSXInstance.sendCommand(CTRL_L_TEMPLATE.replace('%s', encodeTypeText('new\r')));
-                if (response.startsWith('after#'))
-                    response = '';
-                break;
-            case "runProgram":
-                response = await openMSXInstance.sendCommand(CTRL_L_TEMPLATE.replace('%s', encodeTypeText('run\r')));
-                if (response.startsWith('after#'))
-                    response = '';
-                break;
-            case "deleteProgramLines":
-                if (startLine === undefined) {
-                    response = 'Error: No startLine number provided to delete BASIC program lines.';
+        const inBasic = await openMSXInstance.emu_isInBasic();
+        if (command !== "isBasicAvailable" && !inBasic) {
+            response = 'Error: The current MSX machine is not in BASIC mode.';
+        }
+        else
+            switch (command) {
+                case "isBasicAvailable":
+                    response = inBasic.toString();
                     break;
-                }
-                response = await openMSXInstance.sendCommand(CTRL_L_TEMPLATE.replace('%s', encodeTypeText(`delete ${startLine}-${endLine || startLine}\r`)));
-                break;
-            case "setProgram":
-                if (!program) {
-                    response = 'Error: No BASIC program provided to set.';
+                case "newProgram":
+                    response = await openMSXInstance.sendCommand(CTRL_L_TEMPLATE.replace('%s', encodeTypeText('new\r')));
+                    if (response.startsWith('after#'))
+                        response = '';
                     break;
-                }
-                // Get current speed to restore it later
-                let speed = '100';
-                if (isErrorResponse(speed = await openMSXInstance.sendCommand('set speed'))) {
-                    response = speed;
+                case "runProgram":
+                    response = await openMSXInstance.sendCommand(CTRL_L_TEMPLATE.replace('%s', encodeTypeText('run\r')));
+                    if (response.startsWith('after#'))
+                        response = '';
                     break;
-                }
-                // Set speed to fast for program input
-                if (isErrorResponse(response = await openMSXInstance.sendCommand('set speed 10000')))
+                case "deleteProgramLines":
+                    if (startLine === undefined) {
+                        response = 'Error: No startLine number provided to delete BASIC program lines.';
+                        break;
+                    }
+                    response = await openMSXInstance.sendCommand(CTRL_L_TEMPLATE.replace('%s', encodeTypeText(`delete ${startLine}-${endLine || startLine}\r`)));
                     break;
-                // Clear the screen and type the program
-                if (isErrorResponse(response = await openMSXInstance.sendCommand(`type_via_keybuf "${encodeTypeText(program)}"`)))
+                case "setProgram":
+                    if (!program) {
+                        response = 'Error: no BASIC program provided to set.';
+                        break;
+                    }
+                    if (program.includes('\n') || program.includes('\\n')) {
+                        response = 'Error: you cannot use \\n for line endings, use only \\r instead.';
+                        break;
+                    }
+                    // Escape '$' characters if '(' is the next character and is not escaped yet (openMSX variable substitutions)
+                    program = program.replace(/([^\\])(\$\()/g, '$1\\$2');
+                    // Get current speed to restore it later
+                    let speed = '100';
+                    if (isErrorResponse(speed = await openMSXInstance.sendCommand('set speed'))) {
+                        response = speed;
+                        break;
+                    }
+                    // Set speed to fast, type de program, wait to end, and restore speed
+                    if (isErrorResponse(response = await openMSXInstance.sendCommand(`set speed 10000 ; type_via_keybuf "${encodeTypeText(program)}" ; after idle 20 { set speed ${speed} }`)))
+                        break;
+                    // Success response
+                    response = '';
                     break;
-                // Restore the original speed
-                if (isErrorResponse(response = await openMSXInstance.sendCommand(`set speed ${speed}`)))
+                case "getFullProgram":
+                    // Source: https://www.msx.org/forum/msx-talk/openmsx/export-basic-listing#comment-407392
+                    tclCommand = 'regsub -all -line {^[0-9a-f]x[0-9a-f]{4} > } [ listing ] ""';
                     break;
-                // Success response
-                response = '';
-                break;
-            case "getFullProgram":
-                // Source: https://www.msx.org/forum/msx-talk/openmsx/export-basic-listing#comment-407392
-                tclCommand = 'regsub -all -line {^[0-9a-f]x[0-9a-f]{4} > } [ listing ] ""';
-                break;
-            case "getFullProgramAdvanced":
-                tclCommand = "listing";
-                break;
-            case "listProgramLines":
-                if (startLine === undefined) {
-                    response = 'Error: No start line provided to list BASIC program lines.';
+                case "getFullProgramAdvanced":
+                    tclCommand = "listing";
                     break;
-                }
-                tclCommand = `type_via_keybuf \"${encodeTypeText(`list ${startLine}-${endLine || startLine}\r`)}\"`;
-                break;
-            default:
-                response = `Error: Unknown command "${command}".`;
-                break;
-        }
+                case "listProgramLines":
+                    if (startLine === undefined) {
+                        response = 'Error: No start line provided to list BASIC program lines.';
+                        break;
+                    }
+                    tclCommand = `type_via_keybuf \"${encodeTypeText(`list ${startLine}-${endLine || startLine}\r`)}\"`;
+                    break;
+                default:
+                    response = `Error: Unknown command "${command}".`;
+                    break;
+            }
         if (response === undefined && tclCommand) {
             response = await openMSXInstance.sendCommand(tclCommand);
         }
@@ -824,17 +862,148 @@ function registerAllTools(server) {
             response !== undefined ? response : `Error: No response for command "${command}".`
         ]);
     });
+    // ============================================================================
+    // MSX Documentation resources
+    const resdocs = (await listResourcesDirectory()).sort();
+    for (let index = 0; index < resdocs.length; index++) {
+        const sectionName = resdocs[index];
+        const tocFile = path.join(resourcesDir, `${sectionName}/toc.json`);
+        const tocContent = JSON.parse(await fs.readFile(tocFile, 'utf8'));
+        tocContent.toc.forEach((item, itemIndex) => {
+            const itemName = item.uri.split('/').pop() || '';
+            server.registerResource(
+            // Name of the resource (used to call it)
+            `msxdocs_${sectionName}_${itemName}`, 
+            // Resource URI template
+            item.uri, 
+            // Metadata for the resource
+            {
+                title: item.title || `MSX Documentation '${sectionName}' - ${itemName}`,
+                description: item.description || `Documentation for MSX resource '${sectionName}' - ${itemName}`,
+                mimeType: item.mimeType || 'text/markdown',
+            }, 
+            // Handler for the resource (function to be executed when the resource is called)
+            async (uri) => {
+                let resourceContent;
+                let mimeType;
+                if (uri.href.startsWith('http://') || uri.href.startsWith('https://')) {
+                    // Fetch the resource from the URL
+                    try {
+                        resourceContent = await fetch(uri.href).then(response => {
+                            mimeType = response.headers.get('content-type') || 'text/plain';
+                            return response.text();
+                        }) || 'Error downloading resource content';
+                    }
+                    catch (error) {
+                        // Throw exception (MCP protocol requirement)
+                        throw new Error(`Error fetching resource from ${uri.href}: ${error instanceof Error ? error.message : String(error)}`);
+                    }
+                }
+                else {
+                    // Read the resource from the local MCP server resources directory
+                    try {
+                        let resourceFile;
+                        [mimeType, resourceFile] = await addFileExtension(path.join(resourcesDir, `${sectionName}/${itemName}`));
+                        resourceContent = await fs.readFile(resourceFile, 'utf8');
+                    }
+                    catch (error) {
+                        // Throw exception (MCP protocol requirement)
+                        throw new Error(`Error reading resource ${sectionName}/${item.uri}: ${error instanceof Error ? error.message : String(error)}`);
+                    }
+                }
+                return {
+                    contents: [{
+                            uri: uri.href,
+                            text: resourceContent,
+                            mimeType: mimeType || 'text/plain',
+                        }],
+                };
+            });
+        });
+    }
+    ;
+    server.resource("msxdocs_msxorg_wiki", new ResourceTemplate("msxdocs://msxorg_wiki/{section}", {
+        list: undefined,
+        complete: {
+            section: (value) => [
+                "ABS()", "AND", "ASC()", "ATN()", "AUTO", "BASE()", "BEEP", "BIN$()", "BLOAD", "BSAVE", "CALL", "CALL ADJUST", "CALL PAUSE", "CALL PCMPLAY", "CALL PCMREC",
+                "CDBL()", "CHR$()", "CINT()", "CIRCLE", "CLEAR", "CLOAD", "CLOAD?", "CLOSE", "CLS", "COLOR", "COLOR=", "COLOR", "COLOR", "CONT", "COPY", "COPY", "COS()", "CSAVE",
+                "CSNG()", "CSRLIN", "DATA", "DEFDBL", "DEF FN", "DEFINT", "DEFSNG", "DEFSTR", "DEF USR", "DELETE", "DIM", "DRAW", "ELSE", "END", "EOF()", "EQV", "ERASE", "ERL", "ERR",
+                "ERROR", "EXP()", "FIX()", "FN	MSX1", "FOR...NEXT", "FRE()", "GET DATE", "GET TIME", "GOSUB", "GOTO", "HEX$()", "IF...GOTO...ELSE", "IF...THEN...ELSE",
+                "IMP", "INKEY$", "INP()", "INPUT", "INPUT$()", "INSTR()", "INT()", "INTERVAL", "KEY", "KEY()", "LEFT$()", "LEN()", "LET", "LINE", "LINE INPUT", "LIST",
+                "LLIST", "LOAD", "LOCATE", "LOG()", "LPOS()", "LPRINT", "MAXFILES", "MERGE", "MID$()", "MOD", "MOTOR", "NEW", "NOT", "OCT$()", "ON...GOSUB", "ON...GOTO",
+                "ON ERROR GOTO", "ON INTERVAL GOSUB", "ON KEY GOSUB", "ON SPRITE GOSUB", "ON STOP GOSUB", "ON STRIG GOSUB", "OPEN", "OR", "OUT", "PAD()", "PAINT", "PDL()",
+                "PEEK()", "PLAY", "PLAY()", "POINT", "POKE", "POS()", "PRESET", "PRINT", "PSET", "PUT KANJI", "PUT SPRITE", "READ", "REM", "RENUM", "RESTORE", "RESUME",
+                "RETURN", "RIGHT$()", "RND()", "RUN", "SAVE", "SCREEN", "SET ADJUST", "SET BEEP", "SET DATE", "SET PAGE", "SET PASSWORD", "SET PROMPT", "SET SCREEN",
+                "SET SCROLL", "SET TIME", "SET TITLE", "SET VIDEO", "SGN()", "SIN()", "SOUND", "SPACE$()", "SPC()", "SPRITE", "SPRITE$()", "SQR()", "STICK()", "STOP",
+                "STR$()", "STRIG()", "STRING$()", "SWAP", "TAB()", "TAN()", "TIME", "TROFF", "TRON", "USR()", "VAL()", "VARPTR()", "VDP()", "VPEEK()", "VPOKE", "WAIT",
+                "WIDTH", "XOR"
+            ],
+        },
+    }), {
+        title: "BASIC MSX Documentation",
+        description: "Documentation about all the standard MSX-BASIC instructions.",
+        mimeType: "text/html",
+    }, async (uri, variables) => {
+        const section = variables.section.replace(/ /g, '_').replace(/\?/g, '%3F').replace(/=/g, '%3D');
+        const url = `https://www.msx.org/wiki/${section}`;
+        let resourceContent;
+        let mimeType;
+        try {
+            resourceContent = await fetch(url).then(response => {
+                mimeType = response.headers.get('content-type') || 'text/plain';
+                return response.text();
+            }) || 'Error downloading resource content';
+            // Remove script, style, and link tags from the content
+            resourceContent = resourceContent.replace(/<script\b[^>]*>[\s\S]*?<\/script>|<style\b[^>]*>[\s\S]*?<\/style>|<link\b[^>]*\/?>/gi, '');
+        }
+        catch (error) {
+            // Throw exception (MCP protocol requirement)
+            throw new Error(`Error fetching resource "${uri}" from "${url}": ${error instanceof Error ? error.message : String(error)}`);
+        }
+        return {
+            contents: [{
+                    uri: uri.href,
+                    text: resourceContent,
+                    mimeType: mimeType || 'text/plain',
+                }],
+        };
+    });
+}
+async function addFileExtension(filePath) {
+    // Get directory and filename
+    const directory = path.dirname(filePath);
+    const filename = path.basename(filePath);
+    try {
+        // Get all files in directory that start with our filename
+        const files = await fs.readdir(directory);
+        const matchingFiles = files.filter(file => file.startsWith(filename));
+        if (matchingFiles.length > 0) {
+            const fileFound = path.join(directory, matchingFiles[0]);
+            return [
+                mime.lookup(fileFound) || 'text/plain',
+                fileFound
+            ];
+        }
+    }
+    catch (error) {
+        console.error('Error reading directory:', error);
+    }
+    // Return original if no matches found
+    return ['text/plain', filePath];
 }
-function getResponseContent(response, isError = false) {
-    // Check if any response line starts with "Error:" to automatically set isError to true
-    const hasError = isError || response.some(line => isErrorResponse(line));
-    return {
-        content: response.map(line => ({
-            type: "text",
-            text: line == '' ? "Ok" : line,
-        })),
-        isError: hasError
-    };
+async function listResourcesDirectory() {
+    try {
+        const directories = await fs.readdir(resourcesDir, { withFileTypes: true });
+        const folderNames = directories
+            .filter(dirent => dirent.isDirectory())
+            .map(dirent => dirent.name);
+        return folderNames;
+    }
+    catch (error) {
+        console.error("Error reading resources directory:", error);
+        return [];
+    }
 }
 // ============================================================================
 // Cleanup handlers for graceful shutdown of MCP server
@@ -933,7 +1102,7 @@ async function startHttpServer() {
                 }
             };
             // Create a new server instance for this session
-            const httpServer = createServerInstance();
+            const httpServer = await createServerInstance();
             await httpServer.connect(transport);
         }
         else {
@@ -961,14 +1130,20 @@ async function startHttpServer() {
         console.log(`MCP Server listening on port ${port}`);
     });
 }
-function createServerInstance() {
+async function createServerInstance() {
     // Create a new server instance (you might want to extract server creation logic)
     const newServer = new McpServer({
         name: "mcp-openmsx",
         version: PACKAGE_VERSION,
     });
     // Re-register all tools (you might want to extract this to a separate function)
-    registerAllTools(newServer);
+    try {
+        await registerAllTools(newServer);
+    }
+    catch (error) {
+        console.error("Error registering tools/resources:", error);
+        throw error;
+    }
     return newServer;
 }
 // ============================================================================
@@ -1012,7 +1187,7 @@ async function main() {
     else {
         // Default to stdio
         const transport = new StdioServerTransport();
-        await createServerInstance().connect(transport);
+        (await createServerInstance()).connect(transport);
     }
 }
 main().catch((error) => {