MCP Fundamentals

// One MCP server program, used unchanged by two different "AI apps".
import { fileURLToPath } from "node:url";

if (process.argv[2] === "server") {
  // Written once, by the team that owns the room devices.
  const { McpServer } = await import("@modelcontextprotocol/sdk/server/mcp.js");
  const { StdioServerTransport } = await import("@modelcontextprotocol/sdk/server/stdio.js");
  const { z } = await import("zod"); // zod: a schema library; the SDK turns these schemas into JSON Schema for the client
  const server = new McpServer({ name: "rooms", version: "1.0.0" });
  server.registerTool("get_room_status", { description: "Status of a meeting room", inputSchema: { roomId: z.string() } },
    async ({ roomId }) => {
      const who = server.server.getClientVersion().name; // the client said who it is during initialize
      console.error(`[rooms server] ${who} asked about ${roomId}`); // stderr: logs, never stdout
      return { content: [{ type: "text", text: `${roomId}: in a call, camera on` }] };
    });
  await server.connect(new StdioServerTransport());
} else {
  // Two different hosts. Neither contains any code specific to the rooms server.
  const { Client } = await import("@modelcontextprotocol/sdk/client/index.js");
  const { StdioClientTransport } = await import("@modelcontextprotocol/sdk/client/stdio.js");
  const config = { command: process.execPath, args: [fileURLToPath(import.meta.url), "server"] }; // like a host's config entry
  for (const hostName of ["ide-assistant", "support-chat"]) {
    const client = new Client({ name: hostName, version: "1.0.0" });
    const transport = new StdioClientTransport({ ...config, stderr: "pipe" });
    let serverLog = "";
    transport.stderr.on("data", (d) => (serverLog += d));
    await client.connect(transport); // spawns its own copy of the server process
    const { tools } = await client.listTools(); // discovered at runtime, not compiled in
    const result = await client.callTool({ name: tools[0].name, arguments: { roomId: "huddle-2" } });
    await client.close();
    console.log(`${hostName}: found [${tools.map((t) => t.name)}] → "${result.content[0].text}"`);
    console.log(`  ${serverLog.trim()}`);
  }
}

ide-assistant: found [get_room_status] → "huddle-2: in a call, camera on"
  [rooms server] ide-assistant asked about huddle-2
support-chat: found [get_room_status] → "huddle-2: in a call, camera on"
  [rooms server] support-chat asked about huddle-2

// A toy host: one Client per server, one merged tool list for the model, approval before anything risky.
import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
import { Client } from "@modelcontextprotocol/sdk/client/index.js";
import { InMemoryTransport } from "@modelcontextprotocol/sdk/inMemory.js";
import { z } from "zod";

function roomsServer() {
  const s = new McpServer({ name: "rooms", version: "1.0.0" });
  s.registerTool("search", { description: "Find rooms by name", inputSchema: { q: z.string() }, annotations: { readOnlyHint: true } },
    async ({ q }) => ({ content: [{ type: "text", text: ["huddle-2", "board-1"].filter((r) => r.includes(q)).join(", ") }] }));
  s.registerTool("reboot_room", { description: "Reboot a room device", inputSchema: { roomId: z.string() }, annotations: { destructiveHint: true } },
    async ({ roomId }) => ({ content: [{ type: "text", text: `${roomId} rebooting` }] }));
  return s;
}
function ticketsServer() {
  const s = new McpServer({ name: "tickets", version: "1.0.0" });
  s.registerTool("search", { description: "Find support tickets", inputSchema: { q: z.string() }, annotations: { readOnlyHint: true } },
    async ({ q }) => ({ content: [{ type: "text", text: `T-81 "${q} has no audio" (open)` }] }));
  return s;
}

// The host: starts one client per configured server and keeps them apart.
const clients = {};
for (const [name, make] of Object.entries({ rooms: roomsServer, tickets: ticketsServer })) {
  const [c, s] = InMemoryTransport.createLinkedPair();
  await make().connect(s);
  clients[name] = new Client({ name: "toy-host", version: "1.0.0" });
  await clients[name].connect(c);
}
const catalogue = new Map(); // what the model sees → which client, which real tool
for (const [server, client] of Object.entries(clients))
  for (const tool of (await client.listTools()).tools) catalogue.set(`${server}.${tool.name}`, { server, tool });
console.log("tools offered to the model:", [...catalogue.keys()].join(", "));

const askUser = (text) => { const yes = !text.includes("reboot"); console.log(`  ask user: ${text} → ${yes ? "allow" : "deny"}`); return yes; };
const modelWants = [ // scripted, standing in for the LLM's tool-use requests
  ["rooms.search", { q: "huddle" }],
  ["tickets.search", { q: "huddle-2" }],
  ["rooms.reboot_room", { roomId: "huddle-2" }],
];
for (const [qualified, args] of modelWants) {
  const { server, tool } = catalogue.get(qualified);
  console.log(`model asks for ${qualified}(${JSON.stringify(args)})`);
  const autoRun = tool.annotations?.readOnlyHint === true; // a hint, trusted only because we trust these servers
  if (!autoRun && !askUser(`${server} wants to run ${tool.name} ${JSON.stringify(args)}`)) {
    console.log("  → not sent; the model is told the user declined");
    continue;
  }
  const result = await clients[server].callTool({ name: tool.name, arguments: args });
  console.log(`  → sent to the ${server} client only; result: ${result.content[0].text}`);
}
for (const client of Object.values(clients)) await client.close();

tools offered to the model: rooms.search, rooms.reboot_room, tickets.search
model asks for rooms.search({"q":"huddle"})
  → sent to the rooms client only; result: huddle-2
model asks for tickets.search({"q":"huddle-2"})
  → sent to the tickets client only; result: T-81 "huddle-2 has no audio" (open)
model asks for rooms.reboot_room({"roomId":"huddle-2"})
  ask user: rooms wants to run reboot_room {"roomId":"huddle-2"} → deny
  → not sent; the model is told the user declined

// The parent plays the MCP client by hand; the child is a real SDK server on stdio.
import { spawn } from "node:child_process";
import { fileURLToPath } from "node:url";
import { createInterface } from "node:readline";

if (process.argv[2] === "server") {
  const { McpServer } = await import("@modelcontextprotocol/sdk/server/mcp.js");
  const { StdioServerTransport } = await import("@modelcontextprotocol/sdk/server/stdio.js");
  const { z } = await import("zod");
  const server = new McpServer({ name: "rooms", version: "1.0.0" });
  server.registerTool(
    "get_room_status",
    { description: "Current status of a meeting room device", inputSchema: { roomId: z.string() } },
    async ({ roomId }) => ({ content: [{ type: "text", text: `${roomId}: in a call, camera on` }] }),
  );
  await server.connect(new StdioServerTransport()); // reads stdin, writes stdout
} else {
  const child = spawn(process.execPath, [fileURLToPath(import.meta.url), "server"], {
    stdio: ["pipe", "pipe", "inherit"],
  });
  const replies = new Map(); // request id → resolve function
  createInterface({ input: child.stdout }).on("line", (line) => {
    console.log(`← ${line}`);
    const msg = JSON.parse(line);
    replies.get(msg.id)?.(msg);
  });
  const send = (msg) => {
    const line = JSON.stringify(msg); // one message = one line, no embedded newlines
    console.log(`→ ${line}`);
    child.stdin.write(line + "\n");
    if (msg.id !== undefined) return new Promise((resolve) => replies.set(msg.id, resolve));
  };

  await send({ jsonrpc: "2.0", id: 1, method: "initialize", params: {
    protocolVersion: "2025-11-25", capabilities: {}, clientInfo: { name: "by-hand", version: "0.1.0" } } });
  send({ jsonrpc: "2.0", method: "notifications/initialized" }); // a notification: no id, no reply
  await send({ jsonrpc: "2.0", id: 2, method: "tools/list" });
  await send({ jsonrpc: "2.0", id: 3, method: "tools/call", params: {
    name: "get_room_status", arguments: { roomId: "huddle-2" } } });
  child.stdin.end(); // closing stdin is how a stdio client shuts the server down
}

→ {"jsonrpc":"2.0","id":1,"method":"initialize","params":{"protocolVersion":"2025-11-25","capabilities":{},"clientInfo":{"name":"by-hand","version":"0.1.0"}}}
← {"result":{"protocolVersion":"2025-11-25","capabilities":{"tools":{"listChanged":true}},"serverInfo":{"name":"rooms","version":"1.0.0"}},"jsonrpc":"2.0","id":1}
→ {"jsonrpc":"2.0","method":"notifications/initialized"}
→ {"jsonrpc":"2.0","id":2,"method":"tools/list"}
← {"result":{"tools":[{"name":"get_room_status","description":"Current status of a meeting room device","inputSchema":{"$schema":"http://json-schema.org/draft-07/schema#","type":"object","properties":{"roomId":{"type":"string"}},"required":["roomId"]},"execution":{"taskSupport":"forbidden"}}]},"jsonrpc":"2.0","id":2}
→ {"jsonrpc":"2.0","id":3,"method":"tools/call","params":{"name":"get_room_status","arguments":{"roomId":"huddle-2"}}}
← {"result":{"content":[{"type":"text","text":"huddle-2: in a call, camera on"}]},"jsonrpc":"2.0","id":3}

// One well-described tool: what the SDK puts on the wire, and what a call returns.
import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
import { Client } from "@modelcontextprotocol/sdk/client/index.js";
import { InMemoryTransport } from "@modelcontextprotocol/sdk/inMemory.js";
import { z } from "zod";

const rooms = { "huddle-2": { inCall: true, camera: "on", firmware: "4.3.1" } };
const server = new McpServer({ name: "rooms", version: "1.0.0" });
server.registerTool(
  "get_room_status",
  {
    title: "Room status",
    description: "Live status of one meeting-room device. Use list_rooms first if you don't know the id.",
    inputSchema: { roomId: z.string().describe("Room id, e.g. huddle-2") },
    outputSchema: { roomId: z.string(), inCall: z.boolean(), camera: z.enum(["on", "off"]), firmware: z.string() },
    annotations: { readOnlyHint: true, openWorldHint: false },
  },
  async ({ roomId }) => {
    const status = { roomId, ...rooms[roomId] };
    return {
      content: [{ type: "text", text: JSON.stringify(status) }], // for hosts that only read text
      structuredContent: status, // typed data matching outputSchema
    };
  },
);

const client = new Client({ name: "host", version: "1.0.0" });
const [c, s] = InMemoryTransport.createLinkedPair();
await server.connect(s);
await client.connect(c);

const { tools } = await client.listTools();
console.log("tools/list returned one tool:");
for (const [key, value] of Object.entries(tools[0])) if (value !== undefined) console.log(`  ${key}: ${JSON.stringify(value)}`);
const result = await client.callTool({ name: "get_room_status", arguments: { roomId: "huddle-2" } });
console.log("tools/call returned:");
for (const [key, value] of Object.entries(result)) console.log(`  ${key}: ${JSON.stringify(value)}`);
await client.close();

tools/list returned one tool:
  name: "get_room_status"
  title: "Room status"
  description: "Live status of one meeting-room device. Use list_rooms first if you don't know the id."
  inputSchema: {"type":"object","properties":{"roomId":{"type":"string","description":"Room id, e.g. huddle-2"}},"required":["roomId"],"$schema":"http://json-schema.org/draft-07/schema#"}
  outputSchema: {"type":"object","properties":{"roomId":{"type":"string"},"inCall":{"type":"boolean"},"camera":{"type":"string","enum":["on","off"]},"firmware":{"type":"string"}},"required":["roomId","inCall","camera","firmware"],"$schema":"http://json-schema.org/draft-07/schema#","additionalProperties":false}
  annotations: {"readOnlyHint":true,"openWorldHint":false}
  execution: {"taskSupport":"forbidden"}
tools/call returned:
  content: [{"type":"text","text":"{\"roomId\":\"huddle-2\",\"inCall\":true,\"camera\":\"on\",\"firmware\":\"4.3.1\"}"}]
  structuredContent: {"roomId":"huddle-2","inCall":true,"camera":"on","firmware":"4.3.1"}

// A fixed resource, a resource template, and what reading them looks like.
import { McpServer, ResourceTemplate } from "@modelcontextprotocol/sdk/server/mcp.js";
import { Client } from "@modelcontextprotocol/sdk/client/index.js";
import { InMemoryTransport } from "@modelcontextprotocol/sdk/inMemory.js";
import { McpError, ErrorCode } from "@modelcontextprotocol/sdk/types.js";

const rooms = { "huddle-2": { inCall: true, firmware: "4.3.1" }, "board-1": { inCall: false, firmware: "4.2.0" }, lobby: null };
const server = new McpServer({ name: "rooms", version: "1.0.0" });

// 1. One fixed URI.
server.registerResource("runbook", "docs://runbooks/no-audio",
  { title: "Runbook: no audio", mimeType: "text/markdown" },
  async (uri) => ({ contents: [{ uri: uri.href, mimeType: "text/markdown", text: "# No audio\n1. Check mute\n2. Check USB" }] }));

// 2. A family of URIs: rooms://{roomId}/status
server.registerResource("room-status",
  new ResourceTemplate("rooms://{roomId}/status", {
    list: async () => ({ resources: Object.keys(rooms).map((id) => ({ uri: `rooms://${id}/status`, name: `${id} status` })) }),
  }),
  { title: "Room status", mimeType: "application/json" },
  async (uri, { roomId }) => {
    if (!(roomId in rooms)) throw new McpError(ErrorCode.InvalidParams, `No room called ${roomId}`, { uri: uri.href });
    if (rooms[roomId] === null) throw new Error(`${roomId} device is offline`); // a plain Error
    return { contents: [{ uri: uri.href, mimeType: "application/json", text: JSON.stringify(rooms[roomId]) }] };
  });

const client = new Client({ name: "host", version: "1.0.0" });
const [c, s] = InMemoryTransport.createLinkedPair();
await server.connect(s);
await client.connect(c);

console.log("resources/list:");
for (const r of (await client.listResources()).resources) console.log(`  ${r.uri}  (${r.name}, ${r.mimeType})`);
console.log("resources/templates/list:");
for (const t of (await client.listResourceTemplates()).resourceTemplates) console.log(`  ${t.uriTemplate}  (${t.name})`);
for (const uri of ["docs://runbooks/no-audio", "rooms://board-1/status", "rooms://atrium/status", "rooms://lobby/status", "rooms://board-1/logs"]) {
  try {
    const { contents } = await client.readResource({ uri });
    console.log(`read ${uri} → ${contents[0].mimeType}: ${JSON.stringify(contents[0].text)}`);
  } catch (e) {
    console.log(`read ${uri} → error ${e.code}: ${e.message}`);
  }
}
await client.close();

resources/list:
  docs://runbooks/no-audio  (runbook, text/markdown)
  rooms://huddle-2/status  (huddle-2 status, application/json)
  rooms://board-1/status  (board-1 status, application/json)
  rooms://lobby/status  (lobby status, application/json)
resources/templates/list:
  rooms://{roomId}/status  (room-status)
read docs://runbooks/no-audio → text/markdown: "# No audio\n1. Check mute\n2. Check USB"
read rooms://board-1/status → application/json: "{\"inCall\":false,\"firmware\":\"4.2.0\"}"
read rooms://atrium/status → error -32602: MCP error -32602: MCP error -32602: No room called atrium
read rooms://lobby/status → error -32603: MCP error -32603: lobby device is offline
read rooms://board-1/logs → error -32602: MCP error -32602: MCP error -32602: Resource rooms://board-1/logs not found

// A prompt: a named, parameterised message template the user picks, e.g. from a "/" menu.
import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
import { completable } from "@modelcontextprotocol/sdk/server/completable.js";
import { Client } from "@modelcontextprotocol/sdk/client/index.js";
import { InMemoryTransport } from "@modelcontextprotocol/sdk/inMemory.js";
import { z } from "zod";

const rooms = ["huddle-2", "huddle-3", "board-1"];
const server = new McpServer({ name: "rooms", version: "1.0.0" });
server.registerPrompt(
  "triage-room",
  {
    title: "Triage a room",
    description: "Start a structured troubleshooting conversation about one room",
    argsSchema: {
      roomId: completable(z.string(), (typed) => rooms.filter((id) => id.startsWith(typed))),
      symptom: z.string().optional(),
    },
  },
  ({ roomId, symptom }) => ({
    messages: [
      { role: "user", content: { type: "text", text: `Room ${roomId} reports: ${symptom ?? "unknown problem"}. ` +
          "Read its status first, then list likely causes, most likely first. Don't change settings without asking me." } },
      { role: "user", content: { type: "resource", resource: { uri: `rooms://${roomId}/status`, mimeType: "application/json", text: '{"inCall":false}' } } },
    ],
  }),
);

const client = new Client({ name: "host", version: "1.0.0" });
const [c, s] = InMemoryTransport.createLinkedPair();
await server.connect(s);
await client.connect(c);

console.log("server capabilities:", JSON.stringify(client.getServerCapabilities()));
const { prompts } = await client.listPrompts();
console.log("prompts/list:", JSON.stringify(prompts));
const typed = await client.complete({ ref: { type: "ref/prompt", name: "triage-room" }, argument: { name: "roomId", value: "hud" } });
console.log("completion/complete for 'hud':", JSON.stringify(typed.completion));
const got = await client.getPrompt({ name: "triage-room", arguments: { roomId: "huddle-3", symptom: "no audio" } });
got.messages.forEach((m, i) => console.log(`message ${i + 1} (${m.role}, ${m.content.type}):`, m.content.text ?? m.content.resource.uri));
try {
  await client.getPrompt({ name: "triage-room", arguments: {} });
} catch (e) {
  console.log("prompts/get without roomId → error", e.code);
}
await client.close();

server capabilities: {"completions":{},"prompts":{"listChanged":true}}
prompts/list: [{"name":"triage-room","title":"Triage a room","description":"Start a structured troubleshooting conversation about one room","arguments":[{"name":"roomId","required":true},{"name":"symptom","required":false}]}]
completion/complete for 'hud': {"values":["huddle-2","huddle-3"],"total":2,"hasMore":false}
message 1 (user, text): Room huddle-3 reports: no audio. Read its status first, then list likely causes, most likely first. Don't change settings without asking me.
message 2 (user, resource): rooms://huddle-3/status
prompts/get without roomId → error -32602

// The same MCP messages over Streamable HTTP (2025-11-25 shape, as SDK 1.32.2 implements it).
import { createServer } from "node:http";
import { randomUUID } from "node:crypto";
import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";

const mcp = new McpServer({ name: "rooms", version: "1.0.0" });
mcp.registerTool("list_rooms", { description: "All meeting rooms" }, async () => ({ content: [{ type: "text", text: "huddle-2, board-1" }] }));
const transport = new StreamableHTTPServerTransport({ sessionIdGenerator: () => randomUUID() });
await mcp.connect(transport);
const http = createServer((req, res) => transport.handleRequest(req, res));
await new Promise((resolve) => http.listen(0, "127.0.0.1", resolve)); // port 0: any free port
const url = `http://127.0.0.1:${http.address().port}/mcp`;

let session; // random per run, so it's printed as <session-id>
const hide = (s) => (session ? s.replaceAll(session, "<session-id>") : s);
async function post(label, body, headers = {}) {
  const res = await fetch(url, {
    method: "POST",
    headers: { "content-type": "application/json", accept: "application/json, text/event-stream", ...headers },
    body: JSON.stringify(body),
  });
  session ??= res.headers.get("mcp-session-id");
  const sid = res.headers.get("mcp-session-id");
  console.log(`${label}: ${res.status} ${res.headers.get("content-type") ?? "(empty body)"}${sid ? `, Mcp-Session-Id: ${hide(sid)}` : ""}`);
  const text = (await res.text()).trimEnd();
  if (text) console.log(hide(text).split("\n").map((line) => `    ${line}`).join("\n"));
}

await post("POST initialize", { jsonrpc: "2.0", id: 1, method: "initialize",
  params: { protocolVersion: "2025-11-25", capabilities: {}, clientInfo: { name: "fetch", version: "0" } } });
const sessionHeaders = { "mcp-session-id": session, "mcp-protocol-version": "2025-11-25" };
await post("POST notifications/initialized", { jsonrpc: "2.0", method: "notifications/initialized" }, sessionHeaders);
await post("POST tools/call", { jsonrpc: "2.0", id: 2, method: "tools/call", params: { name: "list_rooms", arguments: {} } }, sessionHeaders);
await post("POST tools/list, no session header", { jsonrpc: "2.0", id: 3, method: "tools/list" }, { "mcp-protocol-version": "2025-11-25" });
await post("POST tools/list, unknown session", { jsonrpc: "2.0", id: 4, method: "tools/list" }, { ...sessionHeaders, "mcp-session-id": "made-up" });
await post("POST tools/list as 2026-07-28", { jsonrpc: "2.0", id: 5, method: "tools/list" }, { ...sessionHeaders, "mcp-protocol-version": "2026-07-28" });
await transport.close();
http.close();

POST initialize: 200 text/event-stream, Mcp-Session-Id: <session-id>
    event: message
    data: {"result":{"protocolVersion":"2025-11-25","capabilities":{"tools":{"listChanged":true}},"serverInfo":{"name":"rooms","version":"1.0.0"}},"jsonrpc":"2.0","id":1}
POST notifications/initialized: 202 (empty body)
POST tools/call: 200 text/event-stream, Mcp-Session-Id: <session-id>
    event: message
    data: {"result":{"content":[{"type":"text","text":"huddle-2, board-1"}]},"jsonrpc":"2.0","id":2}
POST tools/list, no session header: 400 application/json
    {"jsonrpc":"2.0","error":{"code":-32000,"message":"Bad Request: Mcp-Session-Id header is required"},"id":null}
POST tools/list, unknown session: 404 application/json
    {"jsonrpc":"2.0","error":{"code":-32001,"message":"Session not found"},"id":null}
POST tools/list as 2026-07-28: 400 application/json
    {"jsonrpc":"2.0","error":{"code":-32000,"message":"Bad Request: Unsupported protocol version: 2026-07-28 (supported versions: 2025-11-25, 2025-06-18, 2025-03-26, 2024-11-05, 2024-10-07)"},"id":null}

// A tool that needs three things only the client has: its roots, its LLM and its user.
import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
import { Client } from "@modelcontextprotocol/sdk/client/index.js";
import { InMemoryTransport } from "@modelcontextprotocol/sdk/inMemory.js";
import { ListRootsRequestSchema, CreateMessageRequestSchema, ElicitRequestSchema } from "@modelcontextprotocol/sdk/types.js";
import { z } from "zod";

const server = new McpServer({ name: "rooms", version: "1.0.0" });
server.registerTool("collect_logs", { description: "Bundle a room's logs", inputSchema: { roomId: z.string() } },
  async ({ roomId }) => {
    const { roots } = await server.server.listRoots(); // where may I write?
    const answer = await server.server.elicitInput({ // ask the user
      message: `Copy ${roomId} logs into ${roots[0].uri}?`,
      requestedSchema: { type: "object", properties: { includeCallHistory: { type: "boolean" } }, required: ["includeCallHistory"] },
    });
    if (answer.action !== "accept") return { content: [{ type: "text", text: `Cancelled (${answer.action})` }] };
    const summary = await server.server.createMessage({ // borrow the host's model
      messages: [{ role: "user", content: { type: "text", text: "Summarise: 09:02 wifi drop; 09:05 call ended" } }],
      maxTokens: 60,
    });
    return { content: [{ type: "text", text: `Saved to ${roots[0].uri}/${roomId}.zip. ${summary.content.text}` }] };
  });

const client = new Client({ name: "host", version: "1.0.0" },
  { capabilities: { roots: {}, elicitation: { form: {} }, sampling: {} } });
client.setRequestHandler(ListRootsRequestSchema, async () => ({ roots: [{ uri: "file:///home/rohit/support", name: "support" }] }));
client.setRequestHandler(ElicitRequestSchema, async () => ({ action: "accept", content: { includeCallHistory: false } }));
client.setRequestHandler(CreateMessageRequestSchema, async () => ({
  role: "assistant", content: { type: "text", text: "A Wi-Fi drop ended the call." }, model: "fake-llm", stopReason: "endTurn" }));

const [clientSide, serverSide] = InMemoryTransport.createLinkedPair();
const show = (dir, m) => { if (m.method !== "initialize" && !m.result?.protocolVersion && m.method !== "notifications/initialized") console.log(dir, JSON.stringify(m)); };
const send = clientSide.send.bind(clientSide);
clientSide.send = (m, o) => (show("host → server", m), send(m, o));
let onmessage;
Object.defineProperty(clientSide, "onmessage", { get: () => onmessage, set: (fn) => (onmessage = (m, e) => (show("server → host", m), fn(m, e))) });

await server.connect(serverSide);
await client.connect(clientSide);
const result = await client.callTool({ name: "collect_logs", arguments: { roomId: "huddle-2" } });
console.log("tool result:", result.content[0].text);
await client.close();

host → server {"method":"tools/call","params":{"name":"collect_logs","arguments":{"roomId":"huddle-2"}},"jsonrpc":"2.0","id":1}
server → host {"method":"roots/list","jsonrpc":"2.0","id":0}
host → server {"result":{"roots":[{"uri":"file:///home/rohit/support","name":"support"}]},"jsonrpc":"2.0","id":0}
server → host {"method":"elicitation/create","params":{"message":"Copy huddle-2 logs into file:///home/rohit/support?","requestedSchema":{"type":"object","properties":{"includeCallHistory":{"type":"boolean"}},"required":["includeCallHistory"]},"mode":"form"},"jsonrpc":"2.0","id":1}
host → server {"result":{"action":"accept","content":{"includeCallHistory":false}},"jsonrpc":"2.0","id":1}
server → host {"method":"sampling/createMessage","params":{"messages":[{"role":"user","content":{"type":"text","text":"Summarise: 09:02 wifi drop; 09:05 call ended"}}],"maxTokens":60},"jsonrpc":"2.0","id":2}
host → server {"result":{"model":"fake-llm","stopReason":"endTurn","role":"assistant","content":{"type":"text","text":"A Wi-Fi drop ended the call."}},"jsonrpc":"2.0","id":2}
server → host {"result":{"content":[{"type":"text","text":"Saved to file:///home/rohit/support/huddle-2.zip. A Wi-Fi drop ended the call."}]},"jsonrpc":"2.0","id":1}
tool result: Saved to file:///home/rohit/support/huddle-2.zip. A Wi-Fi drop ended the call.