@futdevpro/nts-dynamo 1.15.102 → 1.15.104

package/src/_modules/mcp/_models/interfaces/dynts-mcp.interface.ts

@@ -1,111 +1,111 @@
-/**
- * MCP-réteg shared vokabulár (BFR-AM-003) — a domain-agnosztikus MCP-szerver-base + adaptor közös
- * típusai. Egy fájlban a szorosan összetartozó tool-/transport-típusok (`*.interface.ts` az
- * egy-export-per-file konvenció ismert kivétele a tightly-coupled shape-ekre).
- *
- * Boundary: a `DyNTS_McpToolDefinition` + a `DyNTS_Mcp_Adapter` egyetlen `registerTool` choke-pontot
- * ad — a hivatalos `@modelcontextprotocol/sdk` KIZÁRÓLAG az adaptor mögött él, így egy jövőbeli
- * transport-/SDK-csere NEM-breaking (csak az adaptor cserélődik, a `DyNTS_Mcp_Server_ServiceBase` + a
- * consumer-tool-ok változatlanok). A consumer a SAJÁT tool-jait regisztrálja (a bedrock NEM definiál
- * domain-tool-okat — csak a server-base + a transport + a registry).
- */
-
-/**
- * Egy JSON-schema fragment (a tool input-schema-jának típusa). Szabad-formájú JSON-objektum (a
- * draft-07 / MCP tool-schema dialektusa); a `properties`/`required`/`type` mezők gyakoriak, de a
- * shape nem kényszerített (az MCP-kliens a `tools/list`-ben kapja vissza, ahogy van).
- */
-export interface DyNTS_Mcp_JsonSchema {
-    /** A JSON-schema gyökér-típusa (a tool input-ja jellemzően `object`). */
-    type: string;
-    /** A property-leírások (kulcs → al-schema). */
-    properties?: { [key: string]: DyNTS_Mcp_JsonSchema };
-    /** Kötelező property-nevek. */
-    required?: string[];
-    /** Array-elem schema (`type: 'array'` esetén). */
-    items?: DyNTS_Mcp_JsonSchema;
-    /** Enum-értékek (string/number/boolean literál-halmaz). */
-    enum?: (string | number | boolean)[];
-    /** Emberi leírás (a tool-választáshoz; az LLM ezt olvassa). */
-    description?: string;
-    /** Default érték (a kliens-hint). */
-    default?: unknown;
-    /** Engedi-e a nem-leírt property-ket (`object` schema-n). */
-    additionalProperties?: boolean;
-    /** Beágyazott `oneOf`/`anyOf` alternatívák. */
-    oneOf?: DyNTS_Mcp_JsonSchema[];
-}
-
-/**
- * Egy MCP tool-handler kimenete (a transport-agnosztikus core ezt adja; az adaptor MCP-tool-result-tá
- * fordítja). A `data` a strukturált JSON-payload; az `isError` jelzi a strukturált hibát — a néma
- * hiba TILOS (a hiba MINDIG `isError:true` payload VAGY dobott exception, amit az adaptor egységesen
- * `isError`-re fordít).
- */
-export interface DyNTS_Mcp_ToolOutcome {
-    /** A strukturált eredmény-payload (a tool output-shape JSON-ja). */
-    data: unknown;
-    /** `true`, ha a kimenet strukturált hiba — az adaptor `isError`-re fordítja. */
-    isError?: boolean;
-}
-
-/**
- * Egy tool-handler aláírása. Az `args` a nyers tool-argumentumok (JSON); a handler a saját
- * input-shape-jére validál + a `DyNTS_Mcp_ToolOutcome`-ot adja. A hibát NEM nyeli el (strukturált
- * hiba-payload `isError:true`-val VAGY dobott exception, amit az adaptor egységes MCP-error-ré fordít).
- */
-export type DyNTS_Mcp_ToolHandler = (args: unknown) => Promise<DyNTS_Mcp_ToolOutcome>;
-
-/**
- * Egy MCP tool-definíció (a `registerTool` egységes shape-je). A consumer ezt a shape-et használja az
- * advertised halmazba (`name`+`description`+`inputSchema`+`handler`). A `tools/list` a regisztrált
- * tool-ok `name`/`description`/`inputSchema`-ját hirdeti.
- */
-export interface DyNTS_Mcp_ToolDefinition {
-    /** A tool neve (a `tools/list`-ben + a `tools/call` dispatch-kulcsa — UNIK kell legyen). */
-    name: string;
-    /** Agent-barát leírás (mikor melyik tool; az LLM ezt olvassa a tool-választáshoz). */
-    description: string;
-    /** A tool input JSON-schema-ja (a `tools/list` ezt hirdeti). */
-    inputSchema: DyNTS_Mcp_JsonSchema;
-    /** A handler (a transport-agnosztikus core-logika). */
-    handler: DyNTS_Mcp_ToolHandler;
-}
-
-/**
- * Az MCP-szerver identitása (a SDK `serverInfo`-ja). A `name`/`version` a kliensnek hirdetett.
- */
-export interface DyNTS_Mcp_ServerInfo {
-    /** A szerver neve (a kliensnek hirdetett `serverInfo.name`). */
-    name: string;
-    /** A szerver verziója (a kliensnek hirdetett `serverInfo.version`). */
-    version: string;
-}
-
-/**
- * A támogatott transport-fajták. MVP: `stdio` (a JSON-RPC a stdin/stdout-on). A `start({transport})`
- * ezzel választ — egy jövőbeli transport (pl. `http`/`sse`) NON-breaking módon bővíthető (csak az
- * adaptor `start`-ja kap új ágat; a server-base + a tool-ok változatlanok).
- */
-export type DyNTS_Mcp_TransportKind = 'stdio';
-
-/**
- * A `start()` opciói. A `transport` választja a csatornát (default `stdio`).
- */
-export interface DyNTS_Mcp_StartOptions {
-    /** A transport-csatorna (default `stdio`). */
-    transport?: DyNTS_Mcp_TransportKind;
-}
-
-/**
- * Egy MCP `tools/call` strukturált eredménye (a transport-payload shape-je). Az adaptor ezt termeli;
- * a `content` egy text-JSON blokk, az `isError` a strukturált-hiba jelzés. Ez a SDK
- * `CallToolResult`-tal wire-kompatibilis al-shape (a SDK-t az adaptor izolálja, ezért itt a saját,
- * SDK-független shape él).
- */
-export interface DyNTS_Mcp_CallResult {
-    /** A tartalom-blokkok (MVP: egyetlen `text`-JSON blokk). */
-    content: { type: 'text'; text: string }[];
-    /** `true`, ha a hívás strukturált hibával végződött (no-silent-failure). */
-    isError?: boolean;
-}
+/**
+ * MCP-réteg shared vokabulár (BFR-AM-003) — a domain-agnosztikus MCP-szerver-base + adaptor közös
+ * típusai. Egy fájlban a szorosan összetartozó tool-/transport-típusok (`*.interface.ts` az
+ * egy-export-per-file konvenció ismert kivétele a tightly-coupled shape-ekre).
+ *
+ * Boundary: a `DyNTS_McpToolDefinition` + a `DyNTS_Mcp_Adapter` egyetlen `registerTool` choke-pontot
+ * ad — a hivatalos `@modelcontextprotocol/sdk` KIZÁRÓLAG az adaptor mögött él, így egy jövőbeli
+ * transport-/SDK-csere NEM-breaking (csak az adaptor cserélődik, a `DyNTS_Mcp_Server_ServiceBase` + a
+ * consumer-tool-ok változatlanok). A consumer a SAJÁT tool-jait regisztrálja (a bedrock NEM definiál
+ * domain-tool-okat — csak a server-base + a transport + a registry).
+ */
+
+/**
+ * Egy JSON-schema fragment (a tool input-schema-jának típusa). Szabad-formájú JSON-objektum (a
+ * draft-07 / MCP tool-schema dialektusa); a `properties`/`required`/`type` mezők gyakoriak, de a
+ * shape nem kényszerített (az MCP-kliens a `tools/list`-ben kapja vissza, ahogy van).
+ */
+export interface DyNTS_Mcp_JsonSchema {
+    /** A JSON-schema gyökér-típusa (a tool input-ja jellemzően `object`). */
+    type: string;
+    /** A property-leírások (kulcs → al-schema). */
+    properties?: { [key: string]: DyNTS_Mcp_JsonSchema };
+    /** Kötelező property-nevek. */
+    required?: string[];
+    /** Array-elem schema (`type: 'array'` esetén). */
+    items?: DyNTS_Mcp_JsonSchema;
+    /** Enum-értékek (string/number/boolean literál-halmaz). */
+    enum?: (string | number | boolean)[];
+    /** Emberi leírás (a tool-választáshoz; az LLM ezt olvassa). */
+    description?: string;
+    /** Default érték (a kliens-hint). */
+    default?: unknown;
+    /** Engedi-e a nem-leírt property-ket (`object` schema-n). */
+    additionalProperties?: boolean;
+    /** Beágyazott `oneOf`/`anyOf` alternatívák. */
+    oneOf?: DyNTS_Mcp_JsonSchema[];
+}
+
+/**
+ * Egy MCP tool-handler kimenete (a transport-agnosztikus core ezt adja; az adaptor MCP-tool-result-tá
+ * fordítja). A `data` a strukturált JSON-payload; az `isError` jelzi a strukturált hibát — a néma
+ * hiba TILOS (a hiba MINDIG `isError:true` payload VAGY dobott exception, amit az adaptor egységesen
+ * `isError`-re fordít).
+ */
+export interface DyNTS_Mcp_ToolOutcome {
+    /** A strukturált eredmény-payload (a tool output-shape JSON-ja). */
+    data: unknown;
+    /** `true`, ha a kimenet strukturált hiba — az adaptor `isError`-re fordítja. */
+    isError?: boolean;
+}
+
+/**
+ * Egy tool-handler aláírása. Az `args` a nyers tool-argumentumok (JSON); a handler a saját
+ * input-shape-jére validál + a `DyNTS_Mcp_ToolOutcome`-ot adja. A hibát NEM nyeli el (strukturált
+ * hiba-payload `isError:true`-val VAGY dobott exception, amit az adaptor egységes MCP-error-ré fordít).
+ */
+export type DyNTS_Mcp_ToolHandler = (args: unknown) => Promise<DyNTS_Mcp_ToolOutcome>;
+
+/**
+ * Egy MCP tool-definíció (a `registerTool` egységes shape-je). A consumer ezt a shape-et használja az
+ * advertised halmazba (`name`+`description`+`inputSchema`+`handler`). A `tools/list` a regisztrált
+ * tool-ok `name`/`description`/`inputSchema`-ját hirdeti.
+ */
+export interface DyNTS_Mcp_ToolDefinition {
+    /** A tool neve (a `tools/list`-ben + a `tools/call` dispatch-kulcsa — UNIK kell legyen). */
+    name: string;
+    /** Agent-barát leírás (mikor melyik tool; az LLM ezt olvassa a tool-választáshoz). */
+    description: string;
+    /** A tool input JSON-schema-ja (a `tools/list` ezt hirdeti). */
+    inputSchema: DyNTS_Mcp_JsonSchema;
+    /** A handler (a transport-agnosztikus core-logika). */
+    handler: DyNTS_Mcp_ToolHandler;
+}
+
+/**
+ * Az MCP-szerver identitása (a SDK `serverInfo`-ja). A `name`/`version` a kliensnek hirdetett.
+ */
+export interface DyNTS_Mcp_ServerInfo {
+    /** A szerver neve (a kliensnek hirdetett `serverInfo.name`). */
+    name: string;
+    /** A szerver verziója (a kliensnek hirdetett `serverInfo.version`). */
+    version: string;
+}
+
+/**
+ * A támogatott transport-fajták. MVP: `stdio` (a JSON-RPC a stdin/stdout-on). A `start({transport})`
+ * ezzel választ — egy jövőbeli transport (pl. `http`/`sse`) NON-breaking módon bővíthető (csak az
+ * adaptor `start`-ja kap új ágat; a server-base + a tool-ok változatlanok).
+ */
+export type DyNTS_Mcp_TransportKind = 'stdio';
+
+/**
+ * A `start()` opciói. A `transport` választja a csatornát (default `stdio`).
+ */
+export interface DyNTS_Mcp_StartOptions {
+    /** A transport-csatorna (default `stdio`). */
+    transport?: DyNTS_Mcp_TransportKind;
+}
+
+/**
+ * Egy MCP `tools/call` strukturált eredménye (a transport-payload shape-je). Az adaptor ezt termeli;
+ * a `content` egy text-JSON blokk, az `isError` a strukturált-hiba jelzés. Ez a SDK
+ * `CallToolResult`-tal wire-kompatibilis al-shape (a SDK-t az adaptor izolálja, ezért itt a saját,
+ * SDK-független shape él).
+ */
+export interface DyNTS_Mcp_CallResult {
+    /** A tartalom-blokkok (MVP: egyetlen `text`-JSON blokk). */
+    content: { type: 'text'; text: string }[];
+    /** `true`, ha a hívás strukturált hibával végződött (no-silent-failure). */
+    isError?: boolean;
+}

package/src/_modules/mcp/_services/dynts-mcp-server.service-base.spec.ts

@@ -1,151 +1,151 @@
-import { DyNTS_Mcp_Server_ServiceBase } from './dynts-mcp-server.service-base';
-import {
-  DyNTS_Mcp_CallResult,
-  DyNTS_Mcp_ServerInfo,
-  DyNTS_Mcp_ToolDefinition
-} from '../_models/interfaces/dynts-mcp.interface';
-
-/**
- * CONTRACT — `DyNTS_Mcp_Server_ServiceBase` tool-registry + dispatch (BFR-AM-003). A transportot NEM nyitjuk
- * meg (nincs valódi stdio-szerver) — a `build()` + `callTool()` közvetlen dispatch-ét teszteljük,
- * ami UGYANAZ a logika, mint a SDK `tools/call`-ja:
- *   - N tool regisztrálása → `getAdvertisedToolNames` PONTOSAN ezeket listázza,
- *   - `callTool` a megfelelő handler-re dispatch-el (a `name` szerint),
- *   - ismeretlen tool → strukturált `isError:true` (NEM néma, NEM crash),
- *   - handler-dobott hiba → `isError:true` fordítás (a payload tartalmazza a message-et),
- *   - `isError:true` outcome → `isError:true` call-result.
- */
-describe('| DyNTS_Mcp_Server_ServiceBase (tool-registry + dispatch, BFR-AM-003)', () => {
-
-  /** A handler-hívások nyoma (melyik tool, milyen args) — a dispatch-helyesség igazolásához. */
-  let calls: { name: string; args: unknown }[];
-
-  /** Egy teszt-tool-definíció gyára (a handler `data`-ba teszi a tool-nevet + az args-ot). */
-  const makeTool = (name: string): DyNTS_Mcp_ToolDefinition => ({
-    name: name,
-    description: `Test tool ${name}.`,
-    inputSchema: { type: 'object', properties: { x: { type: 'string' } } },
-    handler: async (args: unknown) => {
+import { DyNTS_Mcp_Server_ServiceBase } from './dynts-mcp-server.service-base';
+import {
+  DyNTS_Mcp_CallResult,
+  DyNTS_Mcp_ServerInfo,
+  DyNTS_Mcp_ToolDefinition
+} from '../_models/interfaces/dynts-mcp.interface';
+
+/**
+ * CONTRACT — `DyNTS_Mcp_Server_ServiceBase` tool-registry + dispatch (BFR-AM-003). A transportot NEM nyitjuk
+ * meg (nincs valódi stdio-szerver) — a `build()` + `callTool()` közvetlen dispatch-ét teszteljük,
+ * ami UGYANAZ a logika, mint a SDK `tools/call`-ja:
+ *   - N tool regisztrálása → `getAdvertisedToolNames` PONTOSAN ezeket listázza,
+ *   - `callTool` a megfelelő handler-re dispatch-el (a `name` szerint),
+ *   - ismeretlen tool → strukturált `isError:true` (NEM néma, NEM crash),
+ *   - handler-dobott hiba → `isError:true` fordítás (a payload tartalmazza a message-et),
+ *   - `isError:true` outcome → `isError:true` call-result.
+ */
+describe('| DyNTS_Mcp_Server_ServiceBase (tool-registry + dispatch, BFR-AM-003)', () => {
+
+  /** A handler-hívások nyoma (melyik tool, milyen args) — a dispatch-helyesség igazolásához. */
+  let calls: { name: string; args: unknown }[];
+
+  /** Egy teszt-tool-definíció gyára (a handler `data`-ba teszi a tool-nevet + az args-ot). */
+  const makeTool = (name: string): DyNTS_Mcp_ToolDefinition => ({
+    name: name,
+    description: `Test tool ${name}.`,
+    inputSchema: { type: 'object', properties: { x: { type: 'string' } } },
+    handler: async (args: unknown) => {
       calls.push({ name: name, args: args });
-
-      return { data: { tool: name, echo: args } };
-    },
-  });
-
-  /** A teszt-szerver: 3 tool + egy szándékosan dobó tool. */
-  class TestServer extends DyNTS_Mcp_Server_ServiceBase {
-    protected getServerInfo(): DyNTS_Mcp_ServerInfo {
-      return { name: 'test-mcp', version: '0.0.1-spec' };
-    }
-    protected getTools(): DyNTS_Mcp_ToolDefinition[] {
-      return [
-        makeTool('alpha'),
-        makeTool('beta'),
-        {
-          name: 'boom',
-          description: 'Always throws.',
-          inputSchema: { type: 'object' },
-          handler: async () => {
-            throw new Error('kaboom from handler');
-          },
-        },
-        {
-          name: 'structuredError',
-          description: 'Returns a structured error outcome.',
-          inputSchema: { type: 'object' },
-          handler: async () => ({ data: { reason: 'nope' }, isError: true }),
-        },
-      ];
-    }
-  }
-
-  let server: TestServer;
-
-  beforeEach(() => {
-    calls = [];
-    server = new TestServer();
-  });
-
-  /** A `content[0].text` JSON-payload kiparse-olása (a transport text-JSON shape-je). */
-  const payloadOf = (result: DyNTS_Mcp_CallResult): { [key: string]: unknown } =>
-        JSON.parse(result.content[0].text) as { [key: string]: unknown };
-
-  describe('| registry — getTools → advertised', () => {
-    it('| a deklarált tool-okat hirdeti build ELŐTT is (determinisztikus)', () => {
-      expect(server.getAdvertisedToolNames().sort())
-        .toEqual([ 'alpha', 'beta', 'boom', 'structuredError' ]);
-    });
-
-    it('| build() után UGYANAZOK a hirdetett tool-ok (idempotens build)', () => {
-      const adapter1 = server.build();
+
+      return { data: { tool: name, echo: args } };
+    },
+  });
+
+  /** A teszt-szerver: 3 tool + egy szándékosan dobó tool. */
+  class TestServer extends DyNTS_Mcp_Server_ServiceBase {
+    protected getServerInfo(): DyNTS_Mcp_ServerInfo {
+      return { name: 'test-mcp', version: '0.0.1-spec' };
+    }
+    protected getTools(): DyNTS_Mcp_ToolDefinition[] {
+      return [
+        makeTool('alpha'),
+        makeTool('beta'),
+        {
+          name: 'boom',
+          description: 'Always throws.',
+          inputSchema: { type: 'object' },
+          handler: async () => {
+            throw new Error('kaboom from handler');
+          },
+        },
+        {
+          name: 'structuredError',
+          description: 'Returns a structured error outcome.',
+          inputSchema: { type: 'object' },
+          handler: async () => ({ data: { reason: 'nope' }, isError: true }),
+        },
+      ];
+    }
+  }
+
+  let server: TestServer;
+
+  beforeEach(() => {
+    calls = [];
+    server = new TestServer();
+  });
+
+  /** A `content[0].text` JSON-payload kiparse-olása (a transport text-JSON shape-je). */
+  const payloadOf = (result: DyNTS_Mcp_CallResult): { [key: string]: unknown } =>
+        JSON.parse(result.content[0].text) as { [key: string]: unknown };
+
+  describe('| registry — getTools → advertised', () => {
+    it('| a deklarált tool-okat hirdeti build ELŐTT is (determinisztikus)', () => {
+      expect(server.getAdvertisedToolNames().sort())
+        .toEqual([ 'alpha', 'beta', 'boom', 'structuredError' ]);
+    });
+
+    it('| build() után UGYANAZOK a hirdetett tool-ok (idempotens build)', () => {
+      const adapter1 = server.build();
       const adapter2 = server.build();
-
-      expect(adapter1).toBe(adapter2);
-      expect(adapter1.getAdvertisedToolNames().sort())
-        .toEqual([ 'alpha', 'beta', 'boom', 'structuredError' ]);
-    });
-  });
-
-  describe('| dispatch — callTool a megfelelő handler-re route-ol', () => {
-    it('| alpha → az alpha handler fut (a data a tool-nevet + az args-ot adja)', async () => {
+
+      expect(adapter1).toBe(adapter2);
+      expect(adapter1.getAdvertisedToolNames().sort())
+        .toEqual([ 'alpha', 'beta', 'boom', 'structuredError' ]);
+    });
+  });
+
+  describe('| dispatch — callTool a megfelelő handler-re route-ol', () => {
+    it('| alpha → az alpha handler fut (a data a tool-nevet + az args-ot adja)', async () => {
       const result: DyNTS_Mcp_CallResult = await server.callTool({ name: 'alpha', arguments: { x: '1' } });
-
-      expect(result.isError).toBe(false);
-      expect(calls).toEqual([{ name: 'alpha', args: { x: '1' } }]);
-      expect(payloadOf(result)).toEqual({ tool: 'alpha', echo: { x: '1' } });
-    });
-
-    it('| beta → a beta handler fut (a dispatch a `name` szerint választ)', async () => {
-      await server.callTool({ name: 'beta', arguments: { x: '2' } });
-      expect(calls).toEqual([{ name: 'beta', args: { x: '2' } }]);
-    });
-  });
-
-  describe('| strukturált hiba (no-silent-failure)', () => {
-    it('| ismeretlen tool → isError:true + advertised-lista a message-ben (NEM néma/crash)', async () => {
+
+      expect(result.isError).toBe(false);
+      expect(calls).toEqual([{ name: 'alpha', args: { x: '1' } }]);
+      expect(payloadOf(result)).toEqual({ tool: 'alpha', echo: { x: '1' } });
+    });
+
+    it('| beta → a beta handler fut (a dispatch a `name` szerint választ)', async () => {
+      await server.callTool({ name: 'beta', arguments: { x: '2' } });
+      expect(calls).toEqual([{ name: 'beta', args: { x: '2' } }]);
+    });
+  });
+
+  describe('| strukturált hiba (no-silent-failure)', () => {
+    it('| ismeretlen tool → isError:true + advertised-lista a message-ben (NEM néma/crash)', async () => {
       const result: DyNTS_Mcp_CallResult = await server.callTool({ name: 'does_not_exist' });
-
-      expect(result.isError).toBe(true);
+
+      expect(result.isError).toBe(true);
       const payload = payloadOf(result) as { ok: boolean; error: { message: string } };
-
-      expect(payload.ok).toBe(false);
-      expect(payload.error.message).toContain('does_not_exist');
-      expect(payload.error.message).toContain('alpha');
-      // egyetlen ismeretlen tool sem futtatott handlert.
-      expect(calls.length).toBe(0);
-    });
-
-    it('| handler-dobott hiba → isError:true + a hiba message-e a payload-ban (NEM crash)', async () => {
+
+      expect(payload.ok).toBe(false);
+      expect(payload.error.message).toContain('does_not_exist');
+      expect(payload.error.message).toContain('alpha');
+      // egyetlen ismeretlen tool sem futtatott handlert.
+      expect(calls.length).toBe(0);
+    });
+
+    it('| handler-dobott hiba → isError:true + a hiba message-e a payload-ban (NEM crash)', async () => {
       const result: DyNTS_Mcp_CallResult = await server.callTool({ name: 'boom' });
-
-      expect(result.isError).toBe(true);
+
+      expect(result.isError).toBe(true);
       const payload = payloadOf(result) as { ok: boolean; error: { message: string } };
-
-      expect(payload.ok).toBe(false);
-      expect(payload.error.message).toContain('kaboom from handler');
-    });
-
-    it('| isError:true outcome → isError:true call-result (a strukturált hiba átmegy)', async () => {
+
+      expect(payload.ok).toBe(false);
+      expect(payload.error.message).toContain('kaboom from handler');
+    });
+
+    it('| isError:true outcome → isError:true call-result (a strukturált hiba átmegy)', async () => {
       const result: DyNTS_Mcp_CallResult = await server.callTool({ name: 'structuredError' });
-
-      expect(result.isError).toBe(true);
-      expect(payloadOf(result)).toEqual({ reason: 'nope' });
-    });
-  });
-
-  describe('| start — transport-választás', () => {
-    it('| ismeretlen transport → dob (exhaustiveness-guard); stdio nem nyílik a spec-ben', async () => {
+
+      expect(result.isError).toBe(true);
+      expect(payloadOf(result)).toEqual({ reason: 'nope' });
+    });
+  });
+
+  describe('| start — transport-választás', () => {
+    it('| ismeretlen transport → dob (exhaustiveness-guard); stdio nem nyílik a spec-ben', async () => {
       let thrown: unknown;
-
-      try {
-        // Szándékosan érvénytelen transport (a típus-szűkítés megkerülésével) — a guard-ágat teszteli,
-        // valódi stdio-szervert NEM indítunk.
-        await server.start({ transport: 'http' as never });
-      } catch (error) {
-        thrown = error;
-      }
-      expect(thrown).toBeDefined();
-      expect((thrown as Error).message).toContain('Unsupported MCP transport');
-    });
-  });
-});
+
+      try {
+        // Szándékosan érvénytelen transport (a típus-szűkítés megkerülésével) — a guard-ágat teszteli,
+        // valódi stdio-szervert NEM indítunk.
+        await server.start({ transport: 'http' as never });
+      } catch (error) {
+        thrown = error;
+      }
+      expect(thrown).toBeDefined();
+      expect((thrown as Error).message).toContain('Unsupported MCP transport');
+    });
+  });
+});