@empyria/mcp 0.1.0

package/lib/Server.js

@@ -0,0 +1,111 @@
+import { McpServer, fromJsonSchema } from '@modelcontextprotocol/server'
+
+import { defineSchema } from '@empyria/common'
+
+import { principiaJsonSchemaValidator } from './Validator.js'
+import { withMetaGuard } from './Guard.js'
+
+/**
+ * @typedef {Object} ActionDef
+ * @property {string} [description] - Shown to MCP clients as the tool's description.
+ * @property {Object<string, Object>} [params] - Map of param name to JSON schema, built with
+ *   `@empyria/common`'s schema helpers (`string()`, `number()`, `bool()`, ...). Omit for a
+ *   tool that takes no arguments.
+ * @property {(params: Object, extra: Object) => *} handler - Receives the validated params
+ *   (or `{}` if no `params` schema was declared) and the MCP request's `extra` context.
+ *   May return anything JSON-serializable, a string, or an already MCP-shaped
+ *   `{ content: [...] }` result; thrown errors are reported back to the client as a
+ *   tool-call error automatically.
+ */
+
+/**
+ * A Moleculer-shaped service definition: `{ name, actions }`, where each action is either
+ * a bare async handler or an {@link ActionDef}. Every action becomes an MCP tool named
+ * `"<service.name>.<actionName>"`.
+ * @typedef {Object} ServiceDef
+ * @property {string} name
+ * @property {Object<string, ActionDef|((params: Object, extra: Object) => *)>} actions
+ */
+
+/**
+ * Normalizes an MCP tool handler's return value into a `CallToolResult`. Passes an
+ * already-shaped result through unchanged; wraps a string as-is and anything else as
+ * pretty-printed JSON, both as a single text content block.
+ * @param {*} result
+ * @returns {{content: Array<{type: string, text: string}>}}
+ */
+function toCallToolResult(result) {
+	if (result && typeof result === 'object' && Array.isArray(result.content)) return result
+	if (typeof result === 'string') return { content: [{ type: 'text', text: result }] }
+	return { content: [{ type: 'text', text: JSON.stringify(result ?? null) }] }
+}
+
+/**
+ * Registers every action of a service as an MCP tool on `server`.
+ * @param {McpServer} server
+ * @param {ServiceDef} service
+ */
+function registerService(server, service) {
+	if (!service?.name) throw new Error('Each service must have a name')
+
+	for (const [actionName, action] of Object.entries(service.actions ?? {})) {
+		const isBareHandler = typeof action === 'function'
+		const handler = isBareHandler ? action : action.handler
+		if (typeof handler !== 'function') {
+			throw new Error(
+				`Service '${service.name}' action '${actionName}' has no handler function`,
+			)
+		}
+
+		const config = { description: isBareHandler ? undefined : action.description }
+		const params = isBareHandler ? undefined : action.params
+		// Always declare an inputSchema, even an empty one: the SDK only calls the tool
+		// callback with (args, extra) when inputSchema is set. Omitting it for a
+		// no-params action drops to a single-argument (extra) call instead — silently
+		// handing the caller's own context object to `args` and leaving `extra` (and
+		// therefore any auth context) undefined.
+		config.inputSchema = fromJsonSchema(
+			defineSchema(params ?? {}),
+			principiaJsonSchemaValidator,
+		)
+
+		server.registerTool(`${service.name}.${actionName}`, config, async (args, extra) => {
+			const result = await handler(args ?? {}, extra)
+			return toCallToolResult(result)
+		})
+	}
+}
+
+/**
+ * Builds an MCP server exposing a list of Moleculer-shaped services as tools —
+ * `{ name: 'Weather', actions: { getForecast: { params, handler } } }` becomes the
+ * `"Weather.getForecast"` tool, with `params` validated as JSON schema via
+ * `@empyria/common`'s `createValidator` (no Zod, no Ajv).
+ *
+ * Connecting the server to a transport (stdio, HTTP, ...) is the caller's responsibility —
+ * this only builds and registers; see `@modelcontextprotocol/server/stdio`'s
+ * `StdioServerTransport` or `serveStdio`, or `WebStandardStreamableHTTPServerTransport`.
+ * @param {Object} options
+ * @param {string} options.name - MCP server name, shown to clients.
+ * @param {string} options.version - MCP server version, shown to clients.
+ * @param {ServiceDef[]} [options.services] - Services to publish as tools.
+ * @param {import('@modelcontextprotocol/server').ServerCapabilities} [options.capabilities] -
+ *   Defaults to `{ tools: {} }`.
+ * @param {Object} [options.guard] - Passed through to {@link withMetaGuard} for every service
+ *   that declares a `resolveToken` (e.g. `{ tokenHeader: 'x-token-key' }`); services without
+ *   one are unaffected. See `lib/Guard.js`.
+ * @returns {McpServer}
+ */
+export function createMcpServer({
+	name,
+	version,
+	services = [],
+	capabilities = { tools: {} },
+	guard,
+}) {
+	const server = new McpServer({ name, version }, { capabilities })
+
+	for (const service of services) registerService(server, withMetaGuard(service, guard))
+
+	return server
+}

package/lib/Validator.js

@@ -0,0 +1,34 @@
+import { createValidator } from '@empyria/common'
+
+/**
+ * @typedef {Object} JsonSchemaValidatorResult
+ * @property {boolean} valid
+ * @property {*} [data]
+ * @property {string} [errorMessage]
+ */
+
+/**
+ * The MCP SDK's `jsonSchemaValidator` provider interface (see
+ * `@modelcontextprotocol/server`'s `fromJsonSchema`), backed by
+ * `@empyria/common`'s `createValidator` — no Ajv, no Zod.
+ *
+ * `createValidator` throws a `PrincipiaError` on invalid input; this adapts
+ * that into the provider's `{valid, data, errorMessage}` result shape.
+ */
+export const principiaJsonSchemaValidator = {
+	/**
+	 * @param {Object} schema - A JSON schema (Draft 2020-12-compatible).
+	 * @returns {(input: unknown) => JsonSchemaValidatorResult}
+	 */
+	getValidator(schema) {
+		const validate = createValidator(schema)
+
+		return (input) => {
+			try {
+				return { valid: true, data: validate(input) }
+			} catch (err) {
+				return { valid: false, errorMessage: err.message }
+			}
+		}
+	},
+}

package/package.json

@@ -0,0 +1,41 @@
+{
+	"name": "@empyria/mcp",
+	"version": "0.1.0",
+	"description": "MCP (Model Context Protocol) helpers for the Principia nanoservice framework",
+	"license": "MIT",
+	"author": "Imre Fazekas <imre.fazekas@icloud.com>",
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/imrefazekas/empyria-guard-mcp.git"
+	},
+	"type": "module",
+	"main": "./index.js",
+	"exports": {
+		".": "./index.js",
+		"./lib/*": "./lib/*.js",
+		"./package.json": "./package.json"
+	},
+	"scripts": {
+		"format": "bun oxfmt --check",
+		"format:fix": "bun oxfmt",
+		"lint": "bun oxlint",
+		"lint:fix": "bun oxlint --fix",
+		"test": "bun test --coverage",
+		"test:watch": "bun test --watch"
+	},
+	"dependencies": {
+		"@empyria/classification": "0.1.0",
+		"@empyria/common": "0.1.0",
+		"@modelcontextprotocol/client": "2.0.0",
+		"@modelcontextprotocol/server": "2.0.0"
+	},
+	"devDependencies": {
+		"oxfmt": "0.63.0",
+		"oxlint": "1.78.0"
+	},
+	"engines": {
+		"bun": ">=1.4.0",
+		"node": ">=26"
+	},
+	"packageManager": "bun@1.4.0"
+}

package/test/Client.test.js

@@ -0,0 +1,125 @@
+import { describe, test, expect, afterEach } from 'bun:test'
+import { string } from '@empyria/common'
+import { createMcpClient, connectStdioClient, connectHttpClient } from '../lib/Client.js'
+import { serveMcpHttp } from '../lib/Http.js'
+
+describe('createMcpClient', () => {
+	test('builds an unconnected client', () => {
+		const client = createMcpClient({ name: 'x', version: '1.0.0' })
+		expect(client).toBeDefined()
+		expect(typeof client.connect).toBe('function')
+	})
+})
+
+describe('connectStdioClient', () => {
+	test('spawns a real server process and connects over stdio', async () => {
+		const client = await connectStdioClient({
+			name: 'test-client',
+			version: '1.0.0',
+			command: 'bun',
+			args: [new URL('./fixtures/stdio-server.js', import.meta.url).pathname],
+		})
+		try {
+			const { tools } = await client.listTools()
+			expect(tools.map((t) => t.name)).toEqual(['Echo.say'])
+
+			const result = await client.callTool({ name: 'Echo.say', arguments: { text: 'hi' } })
+			expect(result.content).toEqual([{ type: 'text', text: 'hi' }])
+		} finally {
+			await client.close()
+		}
+	})
+})
+
+describe('connectHttpClient', () => {
+	let server
+
+	afterEach(async () => {
+		if (server) {
+			await server.close()
+			server = undefined
+		}
+	})
+
+	test('connects over HTTP and can call a tool', async () => {
+		const Service = {
+			name: 'Echo',
+			actions: { say: { params: { text: string() }, handler: async ({ text }) => text } },
+		}
+		server = serveMcpHttp({ name: 'x', version: '1.0.0', services: [Service] }, { port: 0 })
+
+		const client = await connectHttpClient({
+			name: 'c',
+			version: '1.0.0',
+			url: server.url.toString(),
+		})
+		try {
+			const { tools } = await client.listTools()
+			expect(tools.map((t) => t.name)).toEqual(['Echo.say'])
+		} finally {
+			await client.close()
+		}
+	})
+
+	test('the "token" shorthand sends an Authorization: Bearer header', async () => {
+		let receivedToken
+		const Service = {
+			name: 'Secrets',
+			resolveToken: async (tokenKey) => {
+				receivedToken = tokenKey
+				return { name: 'Bob' }
+			},
+			actions: { reveal: async () => 'secret' },
+		}
+		server = serveMcpHttp({ name: 'x', version: '1.0.0', services: [Service] }, { port: 0 })
+
+		const client = await connectHttpClient({
+			name: 'c',
+			version: '1.0.0',
+			url: server.url.toString(),
+			token: 'my-token',
+		})
+		try {
+			const result = await client.callTool({ name: 'Secrets.reveal', arguments: {} })
+			expect(result.isError).toBeFalsy()
+			expect(receivedToken).toBe('my-token')
+		} finally {
+			await client.close()
+		}
+	})
+
+	test('a custom header (matching a custom tokenHeader guard) also works', async () => {
+		let receivedToken
+		const Service = {
+			name: 'Secrets',
+			resolveToken: async (tokenKey) => {
+				receivedToken = tokenKey
+				return { name: 'Bob' }
+			},
+			actions: { reveal: async () => 'secret' },
+		}
+		server = serveMcpHttp(
+			{
+				name: 'x',
+				version: '1.0.0',
+				services: [Service],
+				guard: { tokenHeader: 'x-token-key' },
+			},
+			{ port: 0 },
+		)
+
+		const client = await connectHttpClient({
+			name: 'c',
+			version: '1.0.0',
+			url: server.url.toString(),
+			headers: { 'X-Token-Key': 'custom-token' },
+		})
+		try {
+			const result = await client.callTool({ name: 'Secrets.reveal', arguments: {} })
+			expect(result.isError).toBeFalsy()
+			expect(receivedToken).toBe('custom-token')
+		} finally {
+			await client.close()
+		}
+	})
+})

package/test/Gateway.test.js

@@ -0,0 +1,179 @@
+import { describe, test, expect, afterEach } from 'bun:test'
+import { InMemoryTransport } from '@modelcontextprotocol/server'
+import { Client } from '@modelcontextprotocol/client'
+import { string } from '@empyria/common'
+import { createMcpServer } from '../lib/Server.js'
+import { createMcpGateway } from '../lib/Gateway.js'
+
+const openClients = []
+
+afterEach(async () => {
+	await Promise.all(openClients.splice(0).map((c) => c.close()))
+})
+
+/** Builds a backend server from `services` and returns a connected client to it. */
+async function backendClient(services) {
+	const backend = createMcpServer({ name: 'backend', version: '1.0.0', services })
+	const [clientTransport, serverTransport] = InMemoryTransport.createLinkedPair()
+	await backend.connect(serverTransport)
+	const client = new Client({ name: 'upstream-client', version: '1.0.0' })
+	await client.connect(clientTransport)
+	openClients.push(client)
+	return client
+}
+
+/** Connects a client to an already-built gateway server. */
+async function connectTo(server) {
+	const [clientTransport, serverTransport] = InMemoryTransport.createLinkedPair()
+	await server.connect(serverTransport)
+	const client = new Client({ name: 'gateway-client', version: '1.0.0' })
+	await client.connect(clientTransport)
+	openClients.push(client)
+	return client
+}
+
+describe('createMcpGateway', () => {
+	test('aggregates tools from every upstream, namespaced by upstream name', async () => {
+		const weather = await backendClient([
+			{ name: 'Weather', actions: { getForecast: async () => 'sunny' } },
+		])
+		const search = await backendClient([
+			{ name: 'Search', actions: { query: async () => 'results' } },
+		])
+
+		const gateway = await createMcpGateway({
+			name: 'gw',
+			version: '1.0.0',
+			upstreams: [
+				{ name: 'WeatherSrv', client: weather },
+				{ name: 'SearchSrv', client: search },
+			],
+		})
+		const client = await connectTo(gateway)
+
+		const { tools } = await client.listTools()
+		expect(tools.map((t) => t.name).sort()).toEqual([
+			'SearchSrv.Search.query',
+			'WeatherSrv.Weather.getForecast',
+		])
+	})
+
+	test('forwards a call to the owning upstream and returns its result unchanged', async () => {
+		const weather = await backendClient([
+			{
+				name: 'Weather',
+				actions: {
+					getForecast: {
+						params: { city: string() },
+						handler: async ({ city }) => `sunny in ${city}`,
+					},
+				},
+			},
+		])
+		const gateway = await createMcpGateway({
+			name: 'gw',
+			version: '1.0.0',
+			upstreams: [{ name: 'WeatherSrv', client: weather }],
+		})
+		const client = await connectTo(gateway)
+
+		const result = await client.callTool({
+			name: 'WeatherSrv.Weather.getForecast',
+			arguments: { city: 'Zurich' },
+		})
+		expect(result.content).toEqual([{ type: 'text', text: 'sunny in Zurich' }])
+	})
+
+	test('an invalid-argument error from the upstream is forwarded, not swallowed', async () => {
+		const weather = await backendClient([
+			{
+				name: 'Weather',
+				actions: {
+					getForecast: { params: { city: string() }, handler: async ({ city }) => city },
+				},
+			},
+		])
+		const gateway = await createMcpGateway({
+			name: 'gw',
+			version: '1.0.0',
+			upstreams: [{ name: 'WeatherSrv', client: weather }],
+		})
+		const client = await connectTo(gateway)
+
+		const result = await client.callTool({
+			name: 'WeatherSrv.Weather.getForecast',
+			arguments: {},
+		})
+		expect(result.isError).toBe(true)
+		expect(result.content[0].text).toContain('city')
+	})
+
+	test('a schema-less upstream tool proxies correctly too', async () => {
+		const svc = await backendClient([{ name: 'Svc', actions: { ping: async () => 'pong' } }])
+		const gateway = await createMcpGateway({
+			name: 'gw',
+			version: '1.0.0',
+			upstreams: [{ name: 'SvcSrv', client: svc }],
+		})
+		const client = await connectTo(gateway)
+
+		const result = await client.callTool({ name: 'SvcSrv.Svc.ping', arguments: {} })
+		expect(result.content[0].text).toBe('pong')
+	})
+
+	test('rejects two upstreams sharing a name, before connecting anything', async () => {
+		const weather = await backendClient([
+			{ name: 'Weather', actions: { ping: async () => 'a' } },
+		])
+		const search = await backendClient([{ name: 'Search', actions: { ping: async () => 'b' } }])
+
+		await expect(
+			createMcpGateway({
+				name: 'gw',
+				version: '1.0.0',
+				upstreams: [
+					{ name: 'Dup', client: weather },
+					{ name: 'Dup', client: search },
+				],
+			}),
+		).rejects.toThrow(/Duplicate upstream name/)
+	})
+
+	test('an empty upstream list produces a server with no tools', async () => {
+		const gateway = await createMcpGateway({ name: 'gw', version: '1.0.0', upstreams: [] })
+		const client = await connectTo(gateway)
+		expect((await client.listTools()).tools).toEqual([])
+	})
+
+	test('one built gateway instance, reused (not rebuilt) as the factory, serves multiple HTTP requests', async () => {
+		// Gateways are expensive to build (a listTools() round trip per upstream) — the
+		// documented pattern is build once, hand createMcpHandler a factory that returns
+		// that same instance every time, rather than a factory that rebuilds per request.
+		const svc = await backendClient([{ name: 'Svc', actions: { ping: async () => 'pong' } }])
+		const gateway = await createMcpGateway({
+			name: 'gw',
+			version: '1.0.0',
+			upstreams: [{ name: 'SvcSrv', client: svc }],
+		})
+
+		const { createMcpHandler } = await import('@modelcontextprotocol/server')
+		const { StreamableHTTPClientTransport } = await import('@modelcontextprotocol/client')
+		const handler = createMcpHandler(() => gateway)
+		const bunServer = Bun.serve({ port: 0, fetch: handler.fetch })
+
+		try {
+			for (let i = 0; i < 2; i++) {
+				const client = new Client({ name: `http-client-${i}`, version: '1.0.0' })
+				await client.connect(
+					new StreamableHTTPClientTransport(new URL(bunServer.url.toString())),
+				)
+				const result = await client.callTool({ name: 'SvcSrv.Svc.ping', arguments: {} })
+				expect(result.content[0].text).toBe('pong')
+				await client.close()
+			}
+		} finally {
+			await handler.close()
+			bunServer.stop()
+		}
+	})
+})

package/test/Guard.test.js

@@ -0,0 +1,174 @@
+import { describe, test, expect, afterEach } from 'bun:test'
+import { Client, StreamableHTTPClientTransport } from '@modelcontextprotocol/client'
+import { InMemoryTransport } from '@modelcontextprotocol/server'
+import { string } from '@empyria/common'
+import { createMcpServer } from '../lib/Server.js'
+import { serveMcpHttp } from '../lib/Http.js'
+import { withMetaGuard } from '../lib/Guard.js'
+
+let server
+
+afterEach(async () => {
+	if (server) {
+		await server.close()
+		server = undefined
+	}
+})
+
+describe('withMetaGuard', () => {
+	test('returns the service unchanged when it has no resolveToken', () => {
+		const service = { name: 'Open', actions: { ping: async () => 'pong' } }
+		expect(withMetaGuard(service)).toBe(service)
+	})
+
+	test('wraps every action of a service that declares resolveToken', () => {
+		const service = {
+			name: 'Guarded',
+			resolveToken: async () => ({ id: 'u1' }),
+			actions: { a: async () => 'a', b: { params: {}, handler: async () => 'b' } },
+		}
+		const guarded = withMetaGuard(service)
+		expect(guarded).not.toBe(service)
+		expect(typeof guarded.actions.a).toBe('function')
+		expect(typeof guarded.actions.b.handler).toBe('function')
+		// non-handler action config (params, description, ...) is preserved
+		expect(guarded.actions.b.params).toEqual({})
+	})
+})
+
+// Auth tokens only exist as HTTP headers — `extra.http.req` is undefined over stdio (and any
+// other non-HTTP transport), so these run against a real Bun.serve HTTP server, not
+// InMemoryTransport, to exercise real header extraction.
+describe('withMetaGuard: end-to-end over HTTP', () => {
+	function protectedServer(resolveToken, guardOptions) {
+		const Service = {
+			name: 'Secrets',
+			resolveToken,
+			actions: {
+				reveal: {
+					params: { id: string() },
+					handler: async ({ id }, extra) => `secret-${id}-for-${extra.user.name}`,
+				},
+			},
+		}
+		return serveMcpHttp(
+			{ name: 'guard-test', version: '1.0.0', services: [Service], guard: guardOptions },
+			{ port: 0 },
+		)
+	}
+
+	async function connectWithHeaders(headers) {
+		const client = new Client({ name: 'c', version: '1.0.0' })
+		const transport = new StreamableHTTPClientTransport(new URL(server.url.toString()), {
+			requestInit: { headers },
+		})
+		await client.connect(transport)
+		return client
+	}
+
+	test('rejects a call with no token at all', async () => {
+		server = protectedServer(async () => ({ name: 'Bob' }))
+		const client = await connectWithHeaders({})
+		const result = await client.callTool({ name: 'Secrets.reveal', arguments: { id: '1' } })
+		expect(result.isError).toBe(true)
+		expect(result.content[0].text).toContain('missing auth token')
+		await client.close()
+	})
+
+	test('rejects a call whose token resolves to nothing', async () => {
+		server = protectedServer(async () => undefined)
+		const client = await connectWithHeaders({ Authorization: 'Bearer bad-token' })
+		const result = await client.callTool({ name: 'Secrets.reveal', arguments: { id: '1' } })
+		expect(result.isError).toBe(true)
+		expect(result.content[0].text).toContain('invalid auth token')
+		await client.close()
+	})
+
+	test('accepts a Bearer token, strips the prefix, and resolves it into extra.user', async () => {
+		let receivedToken
+		server = protectedServer(async (tokenKey) => {
+			receivedToken = tokenKey
+			return { name: 'Bob' }
+		})
+		const client = await connectWithHeaders({ Authorization: 'Bearer good-token' })
+		const result = await client.callTool({ name: 'Secrets.reveal', arguments: { id: '1' } })
+		expect(result.isError).toBeFalsy()
+		expect(result.content[0].text).toBe('secret-1-for-Bob')
+		expect(receivedToken).toBe('good-token')
+		await client.close()
+	})
+
+	test('passes service/action context to resolveToken, mirroring getUser(ctx, action)', async () => {
+		let seenContext
+		server = protectedServer(async (tokenKey, context) => {
+			seenContext = context
+			return { name: 'Bob' }
+		})
+		const client = await connectWithHeaders({ Authorization: 'Bearer t' })
+		await client.callTool({ name: 'Secrets.reveal', arguments: { id: '1' } })
+		expect(seenContext.service).toBe('Secrets')
+		expect(seenContext.action).toBe('reveal')
+		expect(seenContext.extra).toBeDefined()
+		await client.close()
+	})
+
+	test('a configurable tokenHeader reads from a custom header instead of Authorization', async () => {
+		let receivedToken
+		server = protectedServer(
+			async (tokenKey) => {
+				receivedToken = tokenKey
+				return { name: 'Bob' }
+			},
+			{ tokenHeader: 'x-token-key' },
+		)
+		const client = await connectWithHeaders({ 'X-Token-Key': 'custom-key' })
+		const result = await client.callTool({ name: 'Secrets.reveal', arguments: { id: '1' } })
+		expect(result.isError).toBeFalsy()
+		expect(receivedToken).toBe('custom-key')
+		await client.close()
+	})
+
+	test('a service without resolveToken stays public even when others are guarded', async () => {
+		const PublicService = { name: 'Public', actions: { ping: async () => 'pong' } }
+		const GuardedService = {
+			name: 'Guarded',
+			resolveToken: async () => ({ name: 'Bob' }),
+			actions: { secret: async () => 'shh' },
+		}
+		server = serveMcpHttp(
+			{ name: 'mixed', version: '1.0.0', services: [PublicService, GuardedService] },
+			{ port: 0 },
+		)
+		const client = await connectWithHeaders({})
+
+		const publicResult = await client.callTool({ name: 'Public.ping', arguments: {} })
+		expect(publicResult.isError).toBeFalsy()
+		expect(publicResult.content[0].text).toBe('pong')
+
+		const guardedResult = await client.callTool({ name: 'Guarded.secret', arguments: {} })
+		expect(guardedResult.isError).toBe(true)
+
+		await client.close()
+	})
+})
+
+describe('withMetaGuard: no HTTP context (stdio-equivalent)', () => {
+	test('rejects — there is no request/headers to read a token from', async () => {
+		const Service = {
+			name: 'Secrets',
+			resolveToken: async () => ({ name: 'Bob' }),
+			actions: { reveal: async () => 'secret' },
+		}
+		const mcpServer = createMcpServer({ name: 'x', version: '1.0.0', services: [Service] })
+		const [clientTransport, serverTransport] = InMemoryTransport.createLinkedPair()
+		await mcpServer.connect(serverTransport)
+		const client = new Client({ name: 'c', version: '1.0.0' })
+		await client.connect(clientTransport)
+
+		const result = await client.callTool({ name: 'Secrets.reveal', arguments: {} })
+		expect(result.isError).toBe(true)
+		expect(result.content[0].text).toContain('missing auth token')
+
+		await client.close()
+	})
+})