MCP for a Device Platform

// A SIMULATED room device's REST API (Express 5), wrapped as MCP tools with SDK 1.32.2.
import express from "express";
import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
import { Client } from "@modelcontextprotocol/sdk/client/index.js";
import { InMemoryTransport } from "@modelcontextprotocol/sdk/inMemory.js";
import { ElicitRequestSchema } from "@modelcontextprotocol/sdk/types.js";
import { z } from "zod";

// 1. The device: a made-up API, not any vendor's.
const device = { status: { deviceId: "huddle-2", firmware: "2.3.1", inCall: false, health: "ok" },
  settings: { "audio.volume": 60, "video.cameraTracking": "off" } };
const httpLog = [];
const app = express().use(express.json());
app.use((req, res, next) => { httpLog.push(`${req.method} ${req.path}`); req.get("authorization") === "Bearer lab-token" ? next() : res.sendStatus(401); });
app.get("/api/v1/status", (req, res) => res.json(device.status));
app.get("/api/v1/settings", (req, res) => res.json(device.settings));
app.patch("/api/v1/settings", (req, res) => { Object.assign(device.settings, req.body); res.json(device.settings); });
app.post("/api/v1/reboot", (req, res) => res.status(202).json({ rebooting: true }));
const http = app.listen(0, "127.0.0.1");
await new Promise((r) => http.once("listening", r));
const base = `http://127.0.0.1:${http.address().port}/api/v1`;
const api = async (method, path, body) => {
  const res = await fetch(base + path, { method, headers: { authorization: "Bearer lab-token", "content-type": "application/json" },
    body: body && JSON.stringify(body) });
  return res.json();
};

// 2. The MCP server: one tool per job, read-only ones marked, writes confirmed by the user.
const server = new McpServer({ name: "room-devices", version: "1.0.0" });
const text = (value) => ({ content: [{ type: "text", text: JSON.stringify(value) }], structuredContent: value });
server.registerTool("get_device_status", { title: "Device status", description: "Live status of one room device: firmware, whether it is in a call, health.",
  inputSchema: { deviceId: z.string() }, outputSchema: { deviceId: z.string(), firmware: z.string(), inCall: z.boolean(), health: z.string() },
  annotations: { readOnlyHint: true, openWorldHint: false } }, async () => text(await api("GET", "/status")));
server.registerTool("get_settings", { title: "Device settings", description: "Current settings of one room device, as key/value pairs.",
  inputSchema: { deviceId: z.string() }, annotations: { readOnlyHint: true, openWorldHint: false } },
  async () => ({ content: [{ type: "text", text: JSON.stringify(await api("GET", "/settings")) }] }));

async function confirm(message) { // the human answers, not the model
  const answer = await server.server.elicitInput({ message,
    requestedSchema: { type: "object", properties: { confirm: { type: "boolean", title: "Apply this change" } }, required: ["confirm"] } });
  return answer.action === "accept" && answer.content?.confirm === true;
}
server.registerTool("change_setting", { title: "Change a setting", description: "Change one setting on one device. The user is asked to confirm.",
  inputSchema: { deviceId: z.string(), key: z.enum(["audio.volume", "video.cameraTracking"]), value: z.union([z.number(), z.string()]) },
  annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: true, openWorldHint: false } },
  async ({ deviceId, key, value }) => {
    const before = (await api("GET", "/settings"))[key];
    if (!(await confirm(`Change ${key} on ${deviceId} from ${JSON.stringify(before)} to ${JSON.stringify(value)}?`)))
      return { content: [{ type: "text", text: "Not changed: the user did not confirm." }] };
    const after = await api("PATCH", "/settings", { [key]: value });
    return { content: [{ type: "text", text: `${key} is now ${JSON.stringify(after[key])}` }] };
  });
server.registerTool("reboot_device", { title: "Reboot a device", description: "Reboot one device. Drops any call in progress. The user is asked to confirm.",
  inputSchema: { deviceId: z.string() }, annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: false } },
  async ({ deviceId }) => {
    if (!(await confirm(`Reboot ${deviceId}? It will be unavailable for about 2 minutes.`)))
      return { content: [{ type: "text", text: "Not rebooted: the user did not confirm." }] };
    await api("POST", "/reboot");
    return { content: [{ type: "text", text: `${deviceId} is rebooting` }] };
  });

// 3. A host whose "user" accepts the first confirmation and declines the second.
const client = new Client({ name: "support-host", version: "1.0.0" }, { capabilities: { elicitation: { form: {} } } });
const userSays = [true, false];
client.setRequestHandler(ElicitRequestSchema, async (req) => {
  const yes = userSays.shift();
  console.log(`  [user sees] ${req.params.message} → ${yes ? "Confirm" : "Decline"}`);
  return yes ? { action: "accept", content: { confirm: true } } : { action: "decline" };
});
const [c, s] = InMemoryTransport.createLinkedPair();
await server.connect(s);
await client.connect(c);

for (const t of (await client.listTools()).tools) {
  const a = t.annotations;
  console.log(`${t.name.padEnd(18)} readOnly=${a.readOnlyHint} destructive=${a.destructiveHint ?? "-"} idempotent=${a.idempotentHint ?? "-"}`);
}
for (const [name, args] of [["get_device_status", { deviceId: "huddle-2" }], ["change_setting", { deviceId: "huddle-2", key: "audio.volume", value: 75 }],
  ["reboot_device", { deviceId: "huddle-2" }], ["change_setting", { deviceId: "huddle-2", key: "admin.password", value: "x" }]]) {
  console.log(`call ${name} ${JSON.stringify(args)}`);
  const r = await client.callTool({ name, arguments: args });
  console.log(`  → ${r.isError ? "isError: " : ""}${r.content[0].text.split("\n").slice(0, 2).join(" ").slice(0, 400)}`);
}
console.log("HTTP calls the device received:", httpLog.join(", "));
await client.close();
http.close();

get_device_status  readOnly=true destructive=- idempotent=-
get_settings       readOnly=true destructive=- idempotent=-
change_setting     readOnly=false destructive=true idempotent=true
reboot_device      readOnly=false destructive=true idempotent=false
call get_device_status {"deviceId":"huddle-2"}
  → {"deviceId":"huddle-2","firmware":"2.3.1","inCall":false,"health":"ok"}
call change_setting {"deviceId":"huddle-2","key":"audio.volume","value":75}
  [user sees] Change audio.volume on huddle-2 from 60 to 75? → Confirm
  → audio.volume is now 75
call reboot_device {"deviceId":"huddle-2"}
  [user sees] Reboot huddle-2? It will be unavailable for about 2 minutes. → Decline
  → Not rebooted: the user did not confirm.
call change_setting {"deviceId":"huddle-2","key":"admin.password","value":"x"}
  → isError: MCP error -32602: Input validation error: Invalid arguments for tool change_setting: Invalid option: expected one of "audio.volume"|"video.cameraTracking" at key
HTTP calls the device received: GET /api/v1/status, GET /api/v1/settings, PATCH /api/v1/settings

// Device logs and API docs as MCP resources (SDK 1.32.2). The device and its logs are SIMULATED.
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 { z } from "zod";

const logs = { // what the device's log endpoint would return
  "huddle-2": { system: ["09:00:01 boot ok", "09:01:12 sip registered", "09:02:40 auth admin password=S3cret! ok",
    "09:04:58 usb port 2 overcurrent", "09:04:58 camera disconnected", "09:05:03 call 4411 video muted: no camera"] },
  "board-1": { system: ["08:30:00 boot ok"] },
};
const TAIL = 4; // never hand a whole log bundle to a model
const redact = (line) => line.replace(/(password|token|pin)=\S+/gi, "$1=[redacted]");

const server = new McpServer({ name: "room-devices", version: "1.0.0" });
server.registerResource("api-errors", "docs://device-api/errors", { title: "Device API error codes", mimeType: "text/markdown" },
  async (uri) => ({ contents: [{ uri: uri.href, mimeType: "text/markdown", text: "| code | meaning |\n|---|---|\n| 409 | device busy (in a call) |\n| 503 | device offline |" }] }));
server.registerResource("device-log",
  new ResourceTemplate("device://{deviceId}/logs/{log}", {
    list: async () => ({ resources: Object.entries(logs).flatMap(([id, l]) => Object.keys(l).map((name) =>
      ({ uri: `device://${id}/logs/${name}`, name: `${id} ${name} log`, mimeType: "text/plain" }))) }),
    complete: { deviceId: (value) => Object.keys(logs).filter((id) => id.startsWith(value)) },
  }),
  { title: "Device log (last lines, redacted)", mimeType: "text/plain" },
  async (uri, { deviceId, log }) => {
    const lines = logs[deviceId]?.[log];
    if (!lines) throw new Error(`No ${log} log for ${deviceId}`);
    return { contents: [{ uri: uri.href, mimeType: "text/plain", text: lines.slice(-TAIL).map(redact).join("\n") }] };
  });
server.registerTool("find_log_errors", { description: "Scan a device's system log for errors; returns matching lines and a link to the log.",
  inputSchema: { deviceId: z.string() }, annotations: { readOnlyHint: true } },
  async ({ deviceId }) => {
    const hits = (logs[deviceId]?.system ?? []).filter((l) => /overcurrent|disconnected|fail/.test(l)).map(redact);
    return { content: [{ type: "text", text: `${hits.length} error line(s):\n${hits.join("\n")}` },
      { type: "resource_link", uri: `device://${deviceId}/logs/system`, name: `${deviceId} system log`, mimeType: "text/plain" }] };
  });

const client = new Client({ name: "support-host", version: "1.0.0" });
const [a, b] = InMemoryTransport.createLinkedPair();
await server.connect(b);
await client.connect(a);
console.log("server capabilities:", Object.keys(client.getServerCapabilities()).join(", "));
console.log("resources/list:", (await client.listResources()).resources.map((r) => r.uri).join(", "));
console.log("templates:", (await client.listResourceTemplates()).resourceTemplates.map((t) => t.uriTemplate).join(", "));
const done = await client.complete({ ref: { type: "ref/resource", uri: "device://{deviceId}/logs/{log}" }, argument: { name: "deviceId", value: "hu" } });
console.log(`complete deviceId "hu" → ${JSON.stringify(done.completion.values)}`);
const tool = await client.callTool({ name: "find_log_errors", arguments: { deviceId: "huddle-2" } });
console.log("find_log_errors →", JSON.stringify(tool.content[0].text), "+", tool.content[1].type, tool.content[1].uri);
const read = await client.readResource({ uri: tool.content[1].uri });
console.log(`read ${read.contents[0].uri} (${read.contents[0].mimeType}):\n${read.contents[0].text}`);
try { await client.readResource({ uri: "device://lobby/logs/system" }); } catch (e) { console.log("read device://lobby/logs/system →", e.code, e.message.replace(/^(MCP error -?\d+: )+/, "")); }
await client.close();

server capabilities: completions, resources, tools
resources/list: docs://device-api/errors, device://huddle-2/logs/system, device://board-1/logs/system
templates: device://{deviceId}/logs/{log}
complete deviceId "hu" → ["huddle-2"]
find_log_errors → "2 error line(s):\n09:04:58 usb port 2 overcurrent\n09:04:58 camera disconnected" + resource_link device://huddle-2/logs/system
read device://huddle-2/logs/system (text/plain):
09:02:40 auth admin password=[redacted] ok
09:04:58 usb port 2 overcurrent
09:04:58 camera disconnected
09:05:03 call 4411 video muted: no camera
read device://lobby/logs/system → -32603 No system log for lobby

// Guardrails in front of tools that change SIMULATED hardware: scope, allowlist, dry-run, busy check,
// maintenance window, rate limit, audit log, and no secrets in output. SDK 1.32.2, fake clock.
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 fleet = {
  "huddle-2": { site: "austin", inCall: false, settings: { "audio.volume": 60, "admin.password": "S3cret!", "snmp.community": "public2" } },
  "board-1": { site: "austin", inCall: true, settings: { "audio.volume": 40 } },
  "blr-5": { site: "bengaluru", inCall: false, settings: { "audio.volume": 50 } },
};
const caller = { user: "asha@example.com", sites: ["austin"] }; // from the server's auth, never from tool arguments
let now = Date.UTC(2026, 9, 27, 15, 0); // fake clock: 15:00 UTC
const ALLOWED = { "audio.volume": z.number().int().min(0).max(100), "video.cameraTracking": z.enum(["off", "group", "speaker"]) };
const SECRET = /password|secret|token|community|pin/i;
const audit = [];
const recent = []; // timestamps of applied writes, for the rate limit

function guard(op, deviceId, check) {
  const d = fleet[deviceId];
  if (!d || !caller.sites.includes(d.site)) return `${deviceId} is not a device you can manage`; // same answer for "missing" and "not yours"
  const problem = check(d); // allowlist, value rules, state, window: the per-operation checks
  if (problem) return problem;
  const windowStart = now - 10 * 60_000; // rate limit last: it counts applied writes only
  return recent.filter((t) => t > windowStart).length >= 2 ? "rate limit: 2 changes per 10 minutes; try later" : null;
}
function record(op, deviceId, args, outcome) {
  const safe = SECRET.test(String(args.key)) ? { ...args, value: "[redacted]" } : args; // never log a secret value
  audit.push(`${new Date(now).toISOString().slice(11, 16)} ${caller.user} ${op} ${deviceId} ${JSON.stringify(safe)} → ${outcome}`);
}
const reply = (text, isError = false) => ({ isError, content: [{ type: "text", text }] });

const server = new McpServer({ name: "room-devices", version: "1.0.0" });
server.registerTool("get_settings", { description: "Settings of one device. Secrets are never returned.", inputSchema: { deviceId: z.string() },
  annotations: { readOnlyHint: true } }, async ({ deviceId }) => {
  const d = fleet[deviceId];
  if (!d || !caller.sites.includes(d.site)) return reply(`${deviceId} is not a device you can manage`, true);
  return reply(JSON.stringify(Object.fromEntries(Object.entries(d.settings).map(([k, v]) => [k, SECRET.test(k) ? "[hidden]" : v]))));
});
server.registerTool("change_setting", { description: "Change one allowlisted setting. dryRun defaults to true: it shows the change without making it.",
  inputSchema: { deviceId: z.string(), key: z.string(), value: z.union([z.number(), z.string()]), dryRun: z.boolean().default(true) },
  annotations: { destructiveHint: true, idempotentHint: true } }, async ({ deviceId, key, value, dryRun }) => {
  const problem = guard("change_setting", deviceId, () => {
    if (!(key in ALLOWED)) return `${key} can't be changed through this tool (allowed: ${Object.keys(ALLOWED).join(", ")})`;
    const ok = ALLOWED[key].safeParse(value);
    return ok.success ? null : `${key}: ${ok.error.issues[0].message}`;
  });
  if (problem) { record("change_setting", deviceId, { key, value }, `denied: ${problem}`); return reply(problem, true); }
  const before = fleet[deviceId].settings[key];
  if (dryRun) { record("change_setting", deviceId, { key, value }, "dry run"); return reply(`DRY RUN: ${key} ${before} → ${value}. Call again with dryRun=false to apply.`); }
  fleet[deviceId].settings[key] = value;
  recent.push(now);
  record("change_setting", deviceId, { key, value }, "applied");
  return reply(`${key} changed ${before} → ${value}`);
});
server.registerTool("reboot_device", { description: "Reboot one device. Refused during a call or outside the 02:00–05:00 UTC maintenance window.",
  inputSchema: { deviceId: z.string() }, annotations: { destructiveHint: true } }, async ({ deviceId }) => {
  const problem = guard("reboot", deviceId, (d) => {
    if (d.inCall) return `${deviceId} is in a call; rebooting would drop it`;
    const hour = new Date(now).getUTCHours();
    return hour >= 2 && hour < 5 ? null : `outside the maintenance window (02:00–05:00 UTC, now ${String(hour).padStart(2, "0")}:00)`;
  });
  if (problem) { record("reboot", deviceId, {}, `denied: ${problem}`); return reply(problem, true); }
  recent.push(now);
  record("reboot", deviceId, {}, "applied");
  return reply(`${deviceId} is rebooting`);
});

const client = new Client({ name: "support-host", version: "1.0.0" });
const [a, b] = InMemoryTransport.createLinkedPair();
await server.connect(b);
await client.connect(a);
const attempts = [
  ["get_settings", { deviceId: "huddle-2" }],
  ["change_setting", { deviceId: "huddle-2", key: "audio.volume", value: 75 }],
  ["change_setting", { deviceId: "huddle-2", key: "audio.volume", value: 75, dryRun: false }],
  ["change_setting", { deviceId: "huddle-2", key: "audio.volume", value: 140, dryRun: false }],
  ["change_setting", { deviceId: "huddle-2", key: "admin.password", value: "hunter2", dryRun: false }],
  ["change_setting", { deviceId: "blr-5", key: "audio.volume", value: 30, dryRun: false }],
  ["reboot_device", { deviceId: "board-1" }],
  ["reboot_device", { deviceId: "huddle-2" }],
  ["advance clock to 03:00 UTC next day"],
  ["reboot_device", { deviceId: "huddle-2" }],
  ["change_setting", { deviceId: "board-1", key: "audio.volume", value: 45, dryRun: false }],
  ["change_setting", { deviceId: "board-1", key: "video.cameraTracking", value: "group", dryRun: false }],
];
for (const [name, args] of attempts) {
  if (!args) { now = Date.UTC(2026, 9, 28, 3, 0); console.log(`-- ${name}`); continue; }
  const r = await client.callTool({ name, arguments: args });
  console.log(`${name} ${JSON.stringify(args)}\n  → ${r.isError ? "ERROR " : ""}${r.content[0].text}`);
}
console.log("audit log:\n  " + audit.join("\n  "));
await client.close();

get_settings {"deviceId":"huddle-2"}
  → {"audio.volume":60,"admin.password":"[hidden]","snmp.community":"[hidden]"}
change_setting {"deviceId":"huddle-2","key":"audio.volume","value":75}
  → DRY RUN: audio.volume 60 → 75. Call again with dryRun=false to apply.
change_setting {"deviceId":"huddle-2","key":"audio.volume","value":75,"dryRun":false}
  → audio.volume changed 60 → 75
change_setting {"deviceId":"huddle-2","key":"audio.volume","value":140,"dryRun":false}
  → ERROR audio.volume: Too big: expected number to be <=100
change_setting {"deviceId":"huddle-2","key":"admin.password","value":"hunter2","dryRun":false}
  → ERROR admin.password can't be changed through this tool (allowed: audio.volume, video.cameraTracking)
change_setting {"deviceId":"blr-5","key":"audio.volume","value":30,"dryRun":false}
  → ERROR blr-5 is not a device you can manage
reboot_device {"deviceId":"board-1"}
  → ERROR board-1 is in a call; rebooting would drop it
reboot_device {"deviceId":"huddle-2"}
  → ERROR outside the maintenance window (02:00–05:00 UTC, now 15:00)
-- advance clock to 03:00 UTC next day
reboot_device {"deviceId":"huddle-2"}
  → huddle-2 is rebooting
change_setting {"deviceId":"board-1","key":"audio.volume","value":45,"dryRun":false}
  → audio.volume changed 40 → 45
change_setting {"deviceId":"board-1","key":"video.cameraTracking","value":"group","dryRun":false}
  → ERROR rate limit: 2 changes per 10 minutes; try later
audit log:
  15:00 asha@example.com change_setting huddle-2 {"key":"audio.volume","value":75} → dry run
  15:00 asha@example.com change_setting huddle-2 {"key":"audio.volume","value":75} → applied
  15:00 asha@example.com change_setting huddle-2 {"key":"audio.volume","value":140} → denied: audio.volume: Too big: expected number to be <=100
  15:00 asha@example.com change_setting huddle-2 {"key":"admin.password","value":"[redacted]"} → denied: admin.password can't be changed through this tool (allowed: audio.volume, video.cameraTracking)
  15:00 asha@example.com change_setting blr-5 {"key":"audio.volume","value":30} → denied: blr-5 is not a device you can manage
  15:00 asha@example.com reboot board-1 {} → denied: board-1 is in a call; rebooting would drop it
  15:00 asha@example.com reboot huddle-2 {} → denied: outside the maintenance window (02:00–05:00 UTC, now 15:00)
  03:00 asha@example.com reboot huddle-2 {} → applied
  03:00 asha@example.com change_setting board-1 {"key":"audio.volume","value":45} → applied
  03:00 asha@example.com change_setting board-1 {"key":"video.cameraTracking","value":"group"} → denied: rate limit: 2 changes per 10 minutes; try later

// End-to-end troubleshooting over stdio: a scripted "assistant" (no LLM) drives a device MCP server
// running as a child process. The device and its fault are SIMULATED. SDK 1.32.2.
import { fileURLToPath } from "node:url";

if (process.argv[2] === "server") {
  const { McpServer, ResourceTemplate } = await import("@modelcontextprotocol/sdk/server/mcp.js");
  const { StdioServerTransport } = await import("@modelcontextprotocol/sdk/server/stdio.js");
  const { z } = await import("zod");
  const dev = { deviceId: "huddle-2", inCall: true, health: "degraded",
    usb: { 1: { device: "touch-controller", state: "ok" }, 2: { device: "camera", state: "overcurrent-latched" } },
    log: ["09:01:12 sip registered", "09:04:58 usb port 2 overcurrent", "09:04:58 camera disconnected", "09:05:03 call 4411 video muted: no camera"] };
  const audit = (line) => console.error(`[audit] ${line}`); // stderr: stdout is the protocol
  const json = (v) => ({ content: [{ type: "text", text: JSON.stringify(v) }], structuredContent: v });
  const server = new McpServer({ name: "room-devices", version: "1.0.0" });
  const ro = { readOnlyHint: true, openWorldHint: false };
  server.registerTool("get_device_status", { description: "Live status of a device", inputSchema: { deviceId: z.string() },
    outputSchema: { deviceId: z.string(), inCall: z.boolean(), health: z.string() }, annotations: ro },
    async () => json({ deviceId: dev.deviceId, inCall: dev.inCall, health: dev.health }));
  server.registerTool("list_peripherals", { description: "USB peripherals and port states", inputSchema: { deviceId: z.string() }, annotations: ro },
    async () => json({ ports: Object.entries(dev.usb).map(([port, p]) => ({ port: Number(port), ...p })) }));
  server.registerResource("device-log", new ResourceTemplate("device://{deviceId}/logs/system", { list: undefined }),
    { title: "System log (last lines)", mimeType: "text/plain" },
    async (uri) => ({ contents: [{ uri: uri.href, mimeType: "text/plain", text: dev.log.slice(-4).join("\n") }] }));
  server.registerTool("power_cycle_usb_port", { description: "Cut and restore power on one USB port. Does not drop a call. Asks the user first.",
    inputSchema: { deviceId: z.string(), port: z.number().int().min(1).max(2), dryRun: z.boolean().default(true) },
    annotations: { destructiveHint: true, idempotentHint: true, openWorldHint: false } },
    async ({ deviceId, port, dryRun }) => {
      const p = dev.usb[port];
      if (dryRun) return { content: [{ type: "text", text: `DRY RUN: would power-cycle port ${port} (${p.device}, ${p.state}) on ${deviceId}; call stays up` }] };
      const answer = await server.server.elicitInput({ message: `Power-cycle USB port ${port} (${p.device}) on ${deviceId}? The call stays connected.`,
        requestedSchema: { type: "object", properties: { confirm: { type: "boolean" } }, required: ["confirm"] } });
      if (answer.action !== "accept" || !answer.content.confirm) { audit(`power_cycle ${deviceId} port ${port} → declined`); return { content: [{ type: "text", text: "Not done: declined" }] }; }
      p.state = "ok"; dev.health = "ok"; dev.log.push("09:12:30 usb port 2 power cycled", "09:12:33 camera connected");
      audit(`power_cycle ${deviceId} port ${port} → applied`);
      return { content: [{ type: "text", text: `Port ${port} power-cycled` }] };
    });
  await server.connect(new StdioServerTransport());
} else {
  const { Client } = await import("@modelcontextprotocol/sdk/client/index.js");
  const { StdioClientTransport } = await import("@modelcontextprotocol/sdk/client/stdio.js");
  const { ElicitRequestSchema } = await import("@modelcontextprotocol/sdk/types.js");
  const transport = new StdioClientTransport({ command: process.execPath, args: [fileURLToPath(import.meta.url), "server"], stderr: "pipe" });
  let serverLog = "";
  transport.stderr.on("data", (d) => (serverLog += d));
  const client = new Client({ name: "support-assistant", version: "1.0.0" }, { capabilities: { elicitation: { form: {} } } });
  client.setRequestHandler(ElicitRequestSchema, async (req) => {
    say("host", `asks the engineer: "${req.params.message}" → Confirm`);
    return { action: "accept", content: { confirm: true } };
  });
  const say = (who, text) => console.log(`${who.padEnd(9)} ${text}`);
  const tool = async (name, args) => {
    const r = await client.callTool({ name, arguments: args });
    say("tool", `${name}(${JSON.stringify(args)}) → ${r.content[0].text}`);
    return r.structuredContent ?? r.content[0].text;
  };

  say("engineer", '"The camera in huddle-2 stopped during the 09:00 call. What happened?"');
  await client.connect(transport);
  say("assist.", `tools: ${(await client.listTools()).tools.map((t) => t.name).join(", ")}`);
  say("assist.", `resource templates: ${(await client.listResourceTemplates()).resourceTemplates.map((t) => t.uriTemplate).join(", ")}`);
  const status = await tool("get_device_status", { deviceId: "huddle-2" });
  const { ports } = await tool("list_peripherals", { deviceId: "huddle-2" });
  const log = (await client.readResource({ uri: "device://huddle-2/logs/system" })).contents[0].text;
  say("resource", `device://huddle-2/logs/system →\n${log.replace(/^/gm, "            ")}`);
  const bad = ports.find((p) => p.state !== "ok");
  const evidence = log.split("\n").find((l) => l.includes(`port ${bad.port} overcurrent`));
  say("assist.", `Diagnosis: ${bad.device} on USB port ${bad.port} is "${bad.state}" (log: "${evidence}"). The device is in a call (${status.inCall}), so no reboot. Proposed fix: power-cycle port ${bad.port}.`);
  await tool("power_cycle_usb_port", { deviceId: "huddle-2", port: bad.port });
  await tool("power_cycle_usb_port", { deviceId: "huddle-2", port: bad.port, dryRun: false });
  const after = await tool("list_peripherals", { deviceId: "huddle-2" });
  const health = (await tool("get_device_status", { deviceId: "huddle-2" })).health;
  const fixed = after.ports.every((p) => p.state === "ok") && health === "ok";
  say("assist.", fixed ? `Verified: all ports ok, health ok. If it recurs, the camera or its cable is drawing too much current: replace it.` : "Not fixed: escalate.");
  await client.close();
  console.log(`server stderr: ${serverLog.trim()}`);
}

engineer  "The camera in huddle-2 stopped during the 09:00 call. What happened?"
assist.   tools: get_device_status, list_peripherals, power_cycle_usb_port
assist.   resource templates: device://{deviceId}/logs/system
tool      get_device_status({"deviceId":"huddle-2"}) → {"deviceId":"huddle-2","inCall":true,"health":"degraded"}
tool      list_peripherals({"deviceId":"huddle-2"}) → {"ports":[{"port":1,"device":"touch-controller","state":"ok"},{"port":2,"device":"camera","state":"overcurrent-latched"}]}
resource  device://huddle-2/logs/system →
            09:01:12 sip registered
            09:04:58 usb port 2 overcurrent
            09:04:58 camera disconnected
            09:05:03 call 4411 video muted: no camera
assist.   Diagnosis: camera on USB port 2 is "overcurrent-latched" (log: "09:04:58 usb port 2 overcurrent"). The device is in a call (true), so no reboot. Proposed fix: power-cycle port 2.
tool      power_cycle_usb_port({"deviceId":"huddle-2","port":2}) → DRY RUN: would power-cycle port 2 (camera, overcurrent-latched) on huddle-2; call stays up
host      asks the engineer: "Power-cycle USB port 2 (camera) on huddle-2? The call stays connected." → Confirm
tool      power_cycle_usb_port({"deviceId":"huddle-2","port":2,"dryRun":false}) → Port 2 power-cycled
tool      list_peripherals({"deviceId":"huddle-2"}) → {"ports":[{"port":1,"device":"touch-controller","state":"ok"},{"port":2,"device":"camera","state":"ok"}]}
tool      get_device_status({"deviceId":"huddle-2"}) → {"deviceId":"huddle-2","inCall":true,"health":"ok"}
assist.   Verified: all ports ok, health ok. If it recurs, the camera or its cable is drawing too much current: replace it.
server stderr: [audit] power_cycle huddle-2 port 2 → applied