nova-control-mcp-server 0.0.5 → 0.0.7

package/README.md

@@ -113,21 +113,24 @@ Point your MCP client at `http://<host>:3000/mcp`. For Claude Desktop with a rem
 
 ## Tools
 
-The server exposes the following tools. The serial connection is opened lazily on the first tool call and kept alive for the lifetime of the server process.
+The server exposes the following tools. The serial connection is opened lazily on the first tool call; call `disconnect` to free the port, or let the server exit cleanly.
+
+All movement tools accept an optional `within_ms` parameter. When provided, the robot moves smoothly to the target using a trapezoidal velocity profile (ramp-up → constant speed → ramp-down) over the given number of milliseconds. Without `within_ms`, the servos move at constant maximum speed.
 
 | tool | parameters | description |
 |---|---|---|
-| `home` | — | send all servos to their home positions |
-| `move` | `shift_to?`, `roll_to?`, `pitch_to?`, `rotate_to?`, `lift_to?` (all `number`, at least one required) | set one or more servo positions atomically |
-| `move_to` | `within_ms: number` (required), `s1?`, `s2?`, `s3?`, `s4?`, `s5?` (all optional `number`) | move one or more servos to target positions in exactly `within_ms` milliseconds, using a trapezoidal ramp-up/ramp-down profile |
-| `shift_to` | `deg: number` | shift head forward (>90°) or back (<90°) — s1 |
-| `roll_to` | `deg: number` | roll head clockwise (>90°) or counter-clockwise (<90°) — s2 |
-| `pitch_to` | `deg: number` | pitch head up (>110°) or down (<110°) — s3 |
-| `rotate_to` | `deg: number` | rotate body around Z-axis — s4 |
-| `lift_to` | `deg: number` | lift head on secondary axis, range 20°–150° — s5 |
+| `home` | `within_ms?` | send all servos to their home positions |
+| `move` | `shift_to?`, `roll_to?`, `pitch_to?`, `rotate_to?`, `lift_to?` (at least one required); `within_ms?` | set one or more servo positions atomically |
+| `move_to` | `within_ms: number` (required, must be > 0); `s1?`, `s2?`, `s3?`, `s4?`, `s5?` | move one or more servos smoothly to target positions using a trapezoidal ramp-up/ramp-down profile |
+| `shift_to` | `angle: number`; `within_ms?` | shift head forward (>90°) or back (<90°) — s1 |
+| `roll_to` | `angle: number`; `within_ms?` | roll head clockwise (>90°) or counter-clockwise (<90°) — s2 |
+| `pitch_to` | `angle: number`; `within_ms?` | pitch head up (>110°) or down (<110°) — s3 |
+| `rotate_to` | `angle: number`; `within_ms?` | rotate body around Z-axis — s4 |
+| `lift_to` | `angle: number`; `within_ms?` | lift head on secondary axis, range 20°–150° — s5 |
 | `wait` | `ms: number` | pause for `ms` milliseconds before the next action |
 | `get_state` | — | return current servo positions as a JSON object with keys `s1`–`s5` |
 | `run_script` | `script: string` | execute a multi-line movement script (one command per line; blank lines and `#`-comments ignored; commands: `home`, `shift-to`, `roll-to`, `pitch-to`, `rotate-to`, `lift-to`, `move`, `wait`) |
+| `disconnect` | — | close the serial connection to free the port; the connection reopens automatically on the next movement command |
 
 ### Servo mapping
 
@@ -143,12 +146,13 @@ The server exposes the following tools. The serial connection is opened lazily o
 
 Once the server is running inside Claude Desktop you can give natural-language instructions like:
 
-- *"Move NOVA's head to look straight up."* → `pitch_to(deg: 130)`
-- *"Rotate the body 45° to the right."* → `rotate_to(deg: 45)`
-- *"Move the head to 120° over 800 ms."* → `move_to(within_ms: 800, s1: 120)`
-- *"Shift to 100°, wait half a second, then return to home."* → `shift_to(100)` + `wait(500)` + `home()`
+- *"Move NOVA's head to look straight up."* → `pitch_to(angle: 130)`
+- *"Rotate the body 45° to the right."* → `rotate_to(angle: 45)`
+- *"Move the head to 120° smoothly over 800 ms."* → `move_to(within_ms: 800, s1: 120)`
+- *"Shift to 100° with a fluid ramp, wait half a second, then return to home."* → `shift_to(angle: 100, within_ms: 600)` + `wait(500)` + `home()`
 - *"What is the current servo state?"* → `get_state()`
 - *"Run the greeting sequence from this script."* → `run_script(script: "home\nwait 500\nshift-to 110\nwait 400\nhome")`
+- *"Free the serial port."* → `disconnect()`
 
 ## Exit behaviour
 

package/dist/nova-control-mcp-server.js

@@ -7,9 +7,239 @@ import { Server as i } from "@modelcontextprotocol/sdk/server/index.js";
 import { StdioServerTransport as a } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { StreamableHTTPServerTransport as o } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
 import { CallToolRequestSchema as s, ListToolsRequestSchema as c } from "@modelcontextprotocol/sdk/types.js";
-import { openNova as l, runScript as u } from "nova-control-node";
+import { SerialPort as l } from "serialport";
+//#region ../nova-control-node/dist/nova-control-node.js
+var u = 9600, d = Object.freeze({
+	s1: 90,
+	s2: 90,
+	s3: 110,
+	s4: 90,
+	s5: 95
+}), f = Object.freeze({
+	s1: [45, 135],
+	s2: [10, 170],
+	s3: [40, 150],
+	s4: [30, 180],
+	s5: [20, 150]
+}), p = Object.freeze({
+	s1: (f.s1[1] - f.s1[0]) / 1e3,
+	s2: (f.s2[1] - f.s2[0]) / 1e3,
+	s3: (f.s3[1] - f.s3[0]) / 1e3,
+	s4: (f.s4[1] - f.s4[0]) / 1e3,
+	s5: (f.s5[1] - f.s5[0]) / 1e3
+});
+function m(e, t) {
+	let [n, r] = f[t];
+	return Math.max(n, Math.min(r, Math.round(e)));
+}
+function h(e) {
+	return new Uint8Array([
+		m(e.s4, "s4"),
+		m(e.s3, "s3"),
+		m(e.s2, "s2"),
+		m(e.s1, "s1"),
+		m(e.s5, "s5")
+	]);
+}
+async function g(e, t) {
+	let n = new l({
+		path: e,
+		baudRate: t,
+		autoOpen: !1
+	});
+	return await new Promise((e, t) => {
+		n.open((n) => {
+			n == null ? e() : t(n);
+		});
+	}), await new Promise((e) => setTimeout(e, 2e3)), {
+		async write(e) {
+			await new Promise((t, r) => {
+				n.write(Buffer.from(e), (e) => {
+					e == null ? t() : r(e);
+				});
+			}), await new Promise((e, t) => {
+				n.drain((n) => {
+					n == null ? e() : t(n);
+				});
+			});
+		},
+		destroy() {
+			n.close();
+		}
+	};
+}
+function _(e, t) {
+	let n = Math.min(.499, Math.max(0, t)), r = 1 / (1 - n);
+	if (e <= n) return r * e * e / (2 * n);
+	if (e <= 1 - n) return r * (e - n / 2);
+	let i = 1 - e;
+	return 1 - r * i * i / (2 * n);
+}
+async function v(e, t = u, n) {
+	let r = n?.StepIntervalMs ?? 20, i = n?.RampRatio ?? .25, a = await g(e, t), o = { ...d }, s, c = Promise.resolve();
+	function l(e) {
+		s = {
+			...s ?? o,
+			...e
+		};
+	}
+	async function f() {
+		let e = c;
+		c = (async () => {
+			try {
+				await e;
+			} catch {}
+			for (; s != null;) {
+				let e = s, t = !0, n = { ...o };
+				for (let i of [
+					"s1",
+					"s2",
+					"s3",
+					"s4",
+					"s5"
+				]) {
+					let a = e[i] - o[i], s = r > 0 ? p[i] * r : Infinity;
+					Math.abs(a) > s ? (n[i] = o[i] + Math.sign(a) * s, t = !1) : n[i] = e[i];
+				}
+				t && (s = void 0), o = { ...n }, await a.write(h(n)), t || await new Promise((e) => setTimeout(e, r));
+			}
+		})(), await c;
+	}
+	async function m(e, t) {
+		let n = c;
+		c = (async () => {
+			try {
+				await n;
+			} catch {}
+			let c = { ...o }, l = r > 0 ? Math.max(1, Math.round(t / r)) : 1;
+			s = void 0;
+			for (let t = 1; t <= l; t++) {
+				let n = _(t / l, i), s = { ...o };
+				for (let t of Object.keys(e)) s[t] = Math.round(c[t] + (e[t] - c[t]) * n);
+				o = s, await a.write(h(s)), t < l && await new Promise((e) => setTimeout(e, r));
+			}
+		})(), await c;
+	}
+	return {
+		async home(e) {
+			e != null && e > 0 ? await m({ ...d }, e) : (l({ ...d }), await f());
+		},
+		async shiftHeadTo(e, t) {
+			t != null && t > 0 ? await m({ s1: e }, t) : (l({ s1: e }), await f());
+		},
+		async rollHeadTo(e, t) {
+			t != null && t > 0 ? await m({ s2: e }, t) : (l({ s2: e }), await f());
+		},
+		async pitchHeadTo(e, t) {
+			t != null && t > 0 ? await m({ s3: e }, t) : (l({ s3: e }), await f());
+		},
+		async liftHeadTo(e, t) {
+			t != null && t > 0 ? await m({ s5: e }, t) : (l({ s5: e }), await f());
+		},
+		async rotateBodyTo(e, t) {
+			t != null && t > 0 ? await m({ s4: e }, t) : (l({ s4: e }), await f());
+		},
+		async moveTo(e, t) {
+			t != null && t > 0 ? await m(e, t) : (l(e), await f());
+		},
+		get State() {
+			return structuredClone(s ?? o);
+		},
+		set State(e) {
+			s = {
+				...o,
+				...e
+			};
+		},
+		async sendServoState() {
+			await f();
+		},
+		destroy() {
+			a.destroy();
+		}
+	};
+}
+async function y(e, t) {
+	let n = t.split("\n");
+	for (let t = 0; t < n.length; t++) {
+		let r = n[t].trim(), i = t + 1;
+		if (r === "" || r.startsWith("#")) continue;
+		let a = r.split(/\s+/), o = a[0].toLowerCase();
+		switch (!0) {
+			case o === "home":
+				await e.home();
+				break;
+			case o === "shift-to": {
+				let t = Number(a[1]);
+				if (isNaN(t)) throw Error(`line ${i}: shift-to requires a numeric angle, got '${a[1]}'`);
+				await e.shiftHeadTo(t);
+				break;
+			}
+			case o === "roll-to": {
+				let t = Number(a[1]);
+				if (isNaN(t)) throw Error(`line ${i}: roll-to requires a numeric angle, got '${a[1]}'`);
+				await e.rollHeadTo(t);
+				break;
+			}
+			case o === "pitch-to": {
+				let t = Number(a[1]);
+				if (isNaN(t)) throw Error(`line ${i}: pitch-to requires a numeric angle, got '${a[1]}'`);
+				await e.pitchHeadTo(t);
+				break;
+			}
+			case o === "rotate-to": {
+				let t = Number(a[1]);
+				if (isNaN(t)) throw Error(`line ${i}: rotate-to requires a numeric angle, got '${a[1]}'`);
+				await e.rotateBodyTo(t);
+				break;
+			}
+			case o === "lift-to": {
+				let t = Number(a[1]);
+				if (isNaN(t)) throw Error(`line ${i}: lift-to requires a numeric angle, got '${a[1]}'`);
+				await e.liftHeadTo(t);
+				break;
+			}
+			case o === "move": {
+				let t = {};
+				for (let e = 1; e < a.length; e += 2) {
+					let n = a[e].toLowerCase(), r = Number(a[e + 1]);
+					if (isNaN(r)) throw Error(`line ${i}: '${n}' requires a numeric angle, got '${a[e + 1]}'`);
+					switch (n) {
+						case "shift-to":
+							t.s1 = r;
+							break;
+						case "roll-to":
+							t.s2 = r;
+							break;
+						case "pitch-to":
+							t.s3 = r;
+							break;
+						case "rotate-to":
+							t.s4 = r;
+							break;
+						case "lift-to":
+							t.s5 = r;
+							break;
+						default: throw Error(`line ${i}: unknown move argument '${n}'`);
+					}
+				}
+				if (Object.keys(t).length === 0) throw Error(`line ${i}: move requires at least one servo argument`);
+				e.State = t, await e.sendServoState();
+				break;
+			}
+			case o === "wait": {
+				let e = Number(a[1]);
+				if (isNaN(e) || e < 0) throw Error(`line ${i}: wait requires a non-negative number in ms, got '${a[1]}'`);
+				await new Promise((t) => setTimeout(t, e));
+				break;
+			}
+			default: throw Error(`line ${i}: unknown command '${o}'`);
+		}
+	}
+}
+//#endregion
 //#region src/nova-control-mcp-server.ts
-function d() {
+function b() {
 	try {
 		let { values: e } = r({
 			args: process.argv.slice(2),
@@ -46,34 +276,41 @@ function d() {
 		process.stderr.write(`nova-control-mcp: ${e.message ?? e}\n`), process.exit(1);
 	}
 }
-var f = "", p = 9600, m;
-async function h() {
-	return m ??= await l(f, p), m;
+var x = "", S = 9600, C;
+async function w() {
+	return C ??= await v(x, S), C;
 }
-function g() {
-	m != null && (m.destroy(), m = void 0);
+function T() {
+	C != null && (C.destroy(), C = void 0);
 }
-function _(e, t = 9600) {
-	f = e, p = t;
+function E(e, t = 9600) {
+	x = e, S = t;
 }
-function v() {
-	g(), f = "", p = 9600;
+function D() {
+	T(), x = "", S = 9600;
 }
-var y = [
+var O = [
 	{
 		name: "home",
-		description: "send all servos to their home positions",
+		description: "send all servos to their home positions — pass within_ms for smooth, fluid motion with automatic velocity ramp-up and ramp-down; without within_ms the robot moves at constant maximum speed",
 		inputSchema: {
 			type: "object",
-			properties: {}
+			properties: { within_ms: {
+				type: "number",
+				description: "duration in milliseconds for smooth motion with trapezoidal ramp-up and ramp-down — servos glide gradually to the target instead of jumping; omit for constant-speed movement"
+			} }
 		}
 	},
 	{
 		name: "move",
-		description: "set one or more servo positions atomically — at least one of shift_to, roll_to, pitch_to, rotate_to, lift_to is required",
+		description: "set one or more servo positions atomically — at least one of shift_to, roll_to, pitch_to, rotate_to, lift_to is required; pass within_ms for smooth, fluid motion with automatic velocity ramp-up and ramp-down",
 		inputSchema: {
 			type: "object",
 			properties: {
+				within_ms: {
+					type: "number",
+					description: "duration in milliseconds for smooth motion with trapezoidal ramp-up and ramp-down — servos glide gradually to their targets instead of jumping; omit for constant-speed movement"
+				},
 				shift_to: {
 					type: "number",
 					description: "shift head forward (>90°) or back (<90°) — s1"
@@ -99,61 +336,91 @@ var y = [
 	},
 	{
 		name: "shift_to",
-		description: "shift head forward (>90°) or back (<90°) — s1",
+		description: "shift head forward (>90°) or back (<90°) — s1; pass within_ms for smooth motion with trapezoidal velocity profile (ramp-up → constant speed → ramp-down)",
 		inputSchema: {
 			type: "object",
-			properties: { angle: {
-				type: "number",
-				description: "target angle in degrees"
-			} },
+			properties: {
+				angle: {
+					type: "number",
+					description: "target angle in degrees"
+				},
+				within_ms: {
+					type: "number",
+					description: "duration in milliseconds for smooth motion with trapezoidal ramp-up and ramp-down; omit for constant-speed movement"
+				}
+			},
 			required: ["angle"]
 		}
 	},
 	{
 		name: "roll_to",
-		description: "roll head clockwise (>90°) or counter-clockwise (<90°) — s2",
+		description: "roll head clockwise (>90°) or counter-clockwise (<90°) — s2; pass within_ms for smooth motion with trapezoidal velocity profile",
 		inputSchema: {
 			type: "object",
-			properties: { angle: {
-				type: "number",
-				description: "target angle in degrees"
-			} },
+			properties: {
+				angle: {
+					type: "number",
+					description: "target angle in degrees"
+				},
+				within_ms: {
+					type: "number",
+					description: "duration in milliseconds for smooth motion with trapezoidal ramp-up and ramp-down; omit for constant-speed movement"
+				}
+			},
 			required: ["angle"]
 		}
 	},
 	{
 		name: "pitch_to",
-		description: "pitch head up (>110°) or down (<110°) — s3",
+		description: "pitch head up (>110°) or down (<110°) — s3; pass within_ms for smooth motion with trapezoidal velocity profile",
 		inputSchema: {
 			type: "object",
-			properties: { angle: {
-				type: "number",
-				description: "target angle in degrees"
-			} },
+			properties: {
+				angle: {
+					type: "number",
+					description: "target angle in degrees"
+				},
+				within_ms: {
+					type: "number",
+					description: "duration in milliseconds for smooth motion with trapezoidal ramp-up and ramp-down; omit for constant-speed movement"
+				}
+			},
 			required: ["angle"]
 		}
 	},
 	{
 		name: "rotate_to",
-		description: "rotate body around Z-axis — s4",
+		description: "rotate body around Z-axis — s4; pass within_ms for smooth motion with trapezoidal velocity profile",
 		inputSchema: {
 			type: "object",
-			properties: { angle: {
-				type: "number",
-				description: "target angle in degrees"
-			} },
+			properties: {
+				angle: {
+					type: "number",
+					description: "target angle in degrees"
+				},
+				within_ms: {
+					type: "number",
+					description: "duration in milliseconds for smooth motion with trapezoidal ramp-up and ramp-down; omit for constant-speed movement"
+				}
+			},
 			required: ["angle"]
 		}
 	},
 	{
 		name: "lift_to",
-		description: "lift head on secondary axis, range 20°–150° — s5",
+		description: "lift head on secondary axis, range 20°–150° — s5; pass within_ms for smooth motion with trapezoidal velocity profile",
 		inputSchema: {
 			type: "object",
-			properties: { angle: {
-				type: "number",
-				description: "target angle in degrees"
-			} },
+			properties: {
+				angle: {
+					type: "number",
+					description: "target angle in degrees"
+				},
+				within_ms: {
+					type: "number",
+					description: "duration in milliseconds for smooth motion with trapezoidal ramp-up and ramp-down; omit for constant-speed movement"
+				}
+			},
 			required: ["angle"]
 		}
 	},
@@ -213,7 +480,7 @@ var y = [
 	},
 	{
 		name: "run_script",
-		description: "execute a multi-line movement script — one command per line; blank lines and lines starting with # are ignored; commands: home | shift-to <deg> | roll-to <deg> | pitch-to <deg> | rotate-to <deg> | lift-to <deg> | move [shift-to <deg>] [roll-to <deg>] [pitch-to <deg>] [rotate-to <deg>] [lift-to <deg>] | wait <ms>",
+		description: "execute a multi-line movement script — one command per line; blank lines and lines starting with # are ignored; commands: home | shift-to <angle> | roll-to <angle> | pitch-to <angle> | rotate-to <angle> | lift-to <angle> | move [shift-to <angle>] [roll-to <angle>] [pitch-to <angle>] [rotate-to <angle>] [lift-to <angle>] | wait <ms>",
 		inputSchema: {
 			type: "object",
 			properties: { script: {
@@ -222,99 +489,114 @@ var y = [
 			} },
 			required: ["script"]
 		}
+	},
+	{
+		name: "disconnect",
+		description: "close the serial connection to the robot — call this when you are done to free the serial port; the connection reopens automatically on the first subsequent movement command",
+		inputSchema: {
+			type: "object",
+			properties: {}
+		}
 	}
 ];
-async function b() {
-	return await (await h()).home(), "all servos moved to home positions";
+async function k(e) {
+	let t = e.within_ms == null ? void 0 : Number(e.within_ms);
+	return await (await w()).home(t), "all servos moved to home positions";
 }
-async function x(e) {
+async function A(e) {
 	let t = {};
 	if (e.shift_to != null && (t.s1 = Number(e.shift_to)), e.roll_to != null && (t.s2 = Number(e.roll_to)), e.pitch_to != null && (t.s3 = Number(e.pitch_to)), e.rotate_to != null && (t.s4 = Number(e.rotate_to)), e.lift_to != null && (t.s5 = Number(e.lift_to)), Object.keys(t).length === 0) throw Error("move: at least one of shift_to, roll_to, pitch_to, rotate_to, lift_to is required");
-	let n = await h();
-	return n.State = t, await n.sendServoState(), `servos updated: ${JSON.stringify(t)}`;
+	let n = e.within_ms == null ? void 0 : Number(e.within_ms);
+	return await (await w()).moveTo(t, n), `servos updated: ${JSON.stringify(t)}`;
+}
+async function j(e) {
+	let t = Number(e.angle), n = e.within_ms == null ? void 0 : Number(e.within_ms);
+	return await (await w()).shiftHeadTo(t, n), `s1 (shift) → ${t}°`;
 }
-async function S(e) {
-	let t = Number(e.angle), n = await h();
-	return n.State = { s1: t }, await n.sendServoState(), `s1 (shift) → ${t}°`;
+async function M(e) {
+	let t = Number(e.angle), n = e.within_ms == null ? void 0 : Number(e.within_ms);
+	return await (await w()).rollHeadTo(t, n), `s2 (roll) → ${t}°`;
 }
-async function C(e) {
-	let t = Number(e.angle), n = await h();
-	return n.State = { s2: t }, await n.sendServoState(), `s2 (roll) → ${t}°`;
+async function N(e) {
+	let t = Number(e.angle), n = e.within_ms == null ? void 0 : Number(e.within_ms);
+	return await (await w()).pitchHeadTo(t, n), `s3 (pitch) → ${t}°`;
 }
-async function w(e) {
-	let t = Number(e.angle), n = await h();
-	return n.State = { s3: t }, await n.sendServoState(), `s3 (pitch) → ${t}°`;
+async function P(e) {
+	let t = Number(e.angle), n = e.within_ms == null ? void 0 : Number(e.within_ms);
+	return await (await w()).rotateBodyTo(t, n), `s4 (rotate) → ${t}°`;
 }
-async function T(e) {
-	let t = Number(e.angle), n = await h();
-	return n.State = { s4: t }, await n.sendServoState(), `s4 (rotate) → ${t}°`;
+async function F(e) {
+	let t = Number(e.angle), n = e.within_ms == null ? void 0 : Number(e.within_ms);
+	return await (await w()).liftHeadTo(t, n), `s5 (lift) → ${t}°`;
 }
-async function E(e) {
-	let t = Number(e.angle), n = await h();
-	return n.State = { s5: t }, await n.sendServoState(), `s5 (lift) → ${t}°`;
+async function I() {
+	return C == null ? "not connected" : (T(), "disconnected");
 }
-async function D(e) {
+async function L(e) {
 	let t = Number(e.within_ms);
 	if (isNaN(t) || t <= 0) throw Error("move_to: within_ms must be a positive number");
 	let n = {};
 	if (e.s1 != null && (n.s1 = Number(e.s1)), e.s2 != null && (n.s2 = Number(e.s2)), e.s3 != null && (n.s3 = Number(e.s3)), e.s4 != null && (n.s4 = Number(e.s4)), e.s5 != null && (n.s5 = Number(e.s5)), Object.keys(n).length === 0) throw Error("move_to: at least one servo target (s1–s5) must be specified");
-	return await (await h()).moveTo(n, t), "move completed";
+	return await (await w()).moveTo(n, t), "move completed";
 }
-async function O(e) {
+async function R(e) {
 	let t = Number(e.ms);
 	if (isNaN(t) || t < 0) throw Error(`wait: invalid duration '${e.ms}' — expected a non-negative number`);
 	return await new Promise((e) => setTimeout(e, t)), `waited ${t} ms`;
 }
-async function k() {
-	let e = await h();
+async function z() {
+	let e = await w();
 	return JSON.stringify(e.State);
 }
-async function A(e) {
+async function B(e) {
 	let t = String(e.script ?? "");
-	return await u(await h(), t), "script executed successfully";
+	return await y(await w(), t), "script executed successfully";
 }
-function j() {
+function V() {
 	let e = new i({
 		name: "nova-control-mcp-server",
-		version: "0.0.5"
+		version: "0.0.7"
 	}, { capabilities: { tools: {} } });
-	return e.setRequestHandler(c, async () => ({ tools: y })), e.setRequestHandler(s, async (e) => {
+	return e.setRequestHandler(c, async () => ({ tools: O })), e.setRequestHandler(s, async (e) => {
 		let t = e.params.name, n = e.params.arguments ?? {};
 		try {
 			let e;
 			switch (t) {
 				case "home":
-					e = await b();
+					e = await k(n);
 					break;
 				case "move":
-					e = await x(n);
+					e = await A(n);
 					break;
 				case "shift_to":
-					e = await S(n);
+					e = await j(n);
 					break;
 				case "roll_to":
-					e = await C(n);
+					e = await M(n);
 					break;
 				case "pitch_to":
-					e = await w(n);
+					e = await N(n);
 					break;
 				case "rotate_to":
-					e = await T(n);
+					e = await P(n);
 					break;
 				case "lift_to":
-					e = await E(n);
+					e = await F(n);
 					break;
 				case "move_to":
-					e = await D(n);
+					e = await L(n);
 					break;
 				case "wait":
-					e = await O(n);
+					e = await R(n);
 					break;
 				case "get_state":
-					e = await k();
+					e = await z();
 					break;
 				case "run_script":
-					e = await A(n);
+					e = await B(n);
+					break;
+				case "disconnect":
+					e = await I();
 					break;
 				default: return {
 					content: [{
@@ -339,14 +621,14 @@ function j() {
 		}
 	}), e;
 }
-async function M(e) {
+async function H(e) {
 	let t = new a();
 	await e.connect(t);
 	for (let e of ["SIGINT", "SIGTERM"]) process.on(e, () => {
-		g(), process.exit(0);
+		T(), process.exit(0);
 	});
 }
-async function N(e, t) {
+async function U(e, t) {
 	let r = new o({ sessionIdGenerator: void 0 });
 	await e.connect(r);
 	let i = n(async (e, t) => {
@@ -358,17 +640,17 @@ async function N(e, t) {
 		}), i.once("error", n);
 	});
 	for (let e of ["SIGINT", "SIGTERM"]) process.on(e, async () => {
-		await r.close(), i.close(), g(), process.exit(0);
+		await r.close(), i.close(), T(), process.exit(0);
 	});
 }
-async function P() {
-	let { Port: e, BaudRate: t, Transport: n, ListenPort: r } = d();
-	f = e, p = t;
-	let i = j();
-	n === "http" ? await N(i, r) : await M(i);
+async function W() {
+	let { Port: e, BaudRate: t, Transport: n, ListenPort: r } = b();
+	x = e, S = t;
+	let i = V();
+	n === "http" ? await U(i, r) : await H(i);
 }
-t(process.argv[1]) === e(import.meta.url) && P().catch((e) => {
+t(process.argv[1]) === e(import.meta.url) && W().catch((e) => {
 	process.stderr.write(`nova-control-mcp: fatal: ${e.message ?? e}\n`), process.exit(1);
 });
 //#endregion
-export { v as _destroyForTests, _ as _setupForTests, j as createServer };
+export { D as _destroyForTests, E as _setupForTests, V as createServer };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "nova-control-mcp-server",
   "description": "MCP server for controlling a NOVA DIY Artificial Intelligence Robot by Creoqode",
-  "version": "0.0.5",
+  "version": "0.0.7",
   "type": "module",
   "keywords": [
     "nova",