@mcpflo/server-everything 0.0.1

package/README.md

@@ -0,0 +1,84 @@
+# @mcpflo/server-everything
+
+A deterministic, stdio-only MCP test-fixture server, built for stress-testing
+[MCPFlo](../..) — a desktop testing tool for MCP servers. It exercises the
+full protocol surface (tools, resources, prompts, elicitation, sampling,
+tasks, logging, subscriptions) so MCPFlo's own UI has something real to
+render against, beyond the official
+[`@modelcontextprotocol/server-everything`](https://github.com/modelcontextprotocol/servers/tree/main/src/everything)
+it was originally seeded with.
+
+Every tool's description ends with "Demo/test fixture." so a user connecting
+to this server doesn't mistake an intentional failure, delay, or capability
+mismatch for a bug in MCPFlo itself.
+
+## Quick start
+
+```bash
+npm run build
+node dist/index.js
+```
+
+Or point any MCP client at it directly via stdio — no configuration required,
+every tool has sane defaults for its arguments.
+
+## What's here
+
+**Tools** — 19, covering every tool in the upstream reference server
+(including capability-gated ones like `get-roots-list` and
+`trigger-url-elicitation`), plus fixes for several real bugs found while
+porting them (see `docs/` for specifics). Capability-gated tools are
+registered from the SDK's `oninitialized` hook, not eagerly — they only
+appear in `tools/list` for clients that actually declare the capability they
+need, matching upstream's own behavior exactly.
+
+**Prompts** — 4: a no-argument prompt, one with required/optional arguments,
+one with dependent argument completion, and one that embeds a resource.
+
+**Resources** — 7 static documentation files (this package's own `docs/`,
+describing its architecture, features, and how to extend it) plus 2 dynamic
+resource templates (`mcpflo://dynamic/text/{resourceId}`,
+`mcpflo://dynamic/blob/{resourceId}`) that regenerate content with a live
+timestamp on every read and are deliberately excluded from `resources/list`.
+
+Read [`docs/architecture.md`](docs/architecture.md) and
+[`docs/extension.md`](docs/extension.md) for the actual code layout and how
+to add a new tool or resource — those docs are themselves served by this
+server, so they're worth reading through a connected client too.
+
+## Testing
+
+```bash
+npm test
+```
+
+61 tests across 26 files, one test file per tool/prompt/resource module,
+using the MCP SDK's `InMemoryTransport` to connect a real `Client` to a real
+server instance in-process — no spawned child processes, no mocking of
+protocol behavior. Most of the suite runs in milliseconds; a handful of tests
+that verify actual timing/polling behavior (`simulate-research-query`, the
+async trigger tools) deliberately use real timers and take a few seconds
+each.
+
+## Design notes
+
+- **Deterministic by default.** No Playwright, no browser automation, no
+  live network calls — with one intentional exception: `gzip-file-as-resource`
+  defaults to fetching a real URL, kept for parity with the upstream
+  reference server it was ported from.
+- **Tools/resources are added one at a time, by hand.** There's no bulk
+  generator, even for template-shaped families (see `docs/extension.md`).
+- **Not yet wired as MCPFlo's seeded default server.** Currently a
+  workspace-local devDependency, exercised by this package's own test suite.
+  If it's ever seeded for real end users, it should launch a `sane`/`benign`
+  preset, not the full adversarial catalog — that preset system doesn't
+  exist yet.
+
+## Publishing
+
+This package declares `mcpName` for eventual MCP registry publication, in
+addition to standard npm publishing. Neither has happened yet. When it does,
+pin the exact version anywhere this package is spawned via `npx` (e.g. in
+MCPFlo's own seeded server config) rather than leaving it unpinned — a new
+publish should only reach users through a reviewed MCPFlo release, not
+silently on next connect.

package/dist/createServer.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createServer = createServer;
+const mcp_js_1 = require("@modelcontextprotocol/sdk/server/mcp.js");
+const index_js_1 = require("@modelcontextprotocol/sdk/experimental/tasks/index.js");
+const index_1 = require("./tools/index");
+const session_1 = require("./resources/session");
+const logging_1 = require("./server/logging");
+const subscriptions_1 = require("./resources/subscriptions");
+const index_2 = require("./resources/index");
+const index_3 = require("./prompts/index");
+// Builds a fully-configured server, not yet connected to any transport.
+// Shared by index.ts (stdio, real usage) and the test harness (in-memory).
+function createServer() {
+    const server = new mcp_js_1.McpServer({
+        name: '@mcpflo/server-everything',
+        version: '0.0.1'
+    }, {
+        taskStore: new index_js_1.InMemoryTaskStore(),
+        instructions: (0, index_2.readInstructions)(),
+        // Unlike tools/resources, task-creation support isn't auto-declared by
+        // registering a task tool — it must be advertised explicitly here. Same
+        // for resources.subscribe: registering a resource never implies it.
+        capabilities: {
+            tasks: { requests: { tools: { call: {} } } },
+            logging: {},
+            resources: { subscribe: true }
+        }
+    });
+    (0, index_1.registerTools)(server);
+    (0, session_1.initSessionResources)(server);
+    (0, logging_1.registerLoggingCapability)(server);
+    (0, subscriptions_1.registerSubscriptionsCapability)(server);
+    (0, index_2.registerResources)(server);
+    (0, index_3.registerPrompts)(server);
+    // Capability-gated tools are registered here, once the client's initialize
+    // handshake has completed and its declared capabilities are actually known.
+    server.server.oninitialized = () => {
+        (0, index_1.registerConditionalTools)(server);
+    };
+    return server;
+}

package/dist/docs/architecture.md

@@ -0,0 +1,19 @@
+# Architecture
+
+`@mcpflo/server-everything` is a single stdio MCP server (`src/index.ts`) built
+from small, individually-registered pieces:
+
+- `src/tools/` — one file per tool, each exporting a `register<Name>(server)`
+  function that calls `server.registerTool(...)` directly. `src/tools/index.ts`
+  is a barrel that aggregates them into `registerTools(server)`.
+- `src/resources/` — resource-side infrastructure: static file resources
+  (this doc set), session-scoped dynamic resources (e.g. gzip output),
+  templated resources, and the subscribe/unsubscribe handlers.
+- `src/server/` — server-wide capability plumbing that isn't resource- or
+  tool-specific, e.g. the simulated logging level tracking.
+
+Tools and resources are added one at a time by hand — there is no bulk
+generator. `index.ts` wires everything together: constructs the `McpServer`,
+declares capabilities that aren't auto-detected by the SDK (`tasks`,
+`logging`, `resources.subscribe`), registers all tools/resources, then
+connects over stdio.

package/dist/docs/extension.md

@@ -0,0 +1,20 @@
+# Extending This Server
+
+To add a new tool:
+
+1. Create `src/tools/my-new-tool.ts`, exporting `registerMyNewTool(server)`
+   that calls `server.registerTool(...)` directly (raw-shape zod for
+   `inputSchema`, not a wrapped `z.object(...)`, to match the rest of this
+   codebase).
+2. Append its description text with `Demo/test fixture.` so a real user
+   connecting to this server understands intentional failures/delays aren't
+   a bug.
+3. Import and add it to the array in `src/tools/index.ts`.
+4. Rebuild (`npm run build`) and manually verify with a raw JSON-RPC smoke
+   test over stdio before wiring it into MCPFlo or the e2e suite.
+
+To add a new resource, follow the same one-file-per-item pattern under
+`src/resources/`. If it needs a capability the SDK doesn't auto-declare
+(check by trying it first — `tasks`, `logging`, and `resources.subscribe`
+all needed this), add it explicitly to the `capabilities` object in
+`src/index.ts`.

package/dist/docs/features.md

@@ -0,0 +1,23 @@
+# Features
+
+This server exercises a broad slice of the MCP protocol, deliberately kept
+deterministic — no real chaos, no live browser automation, one exception
+(the gzip tool's default network fetch, kept for compatibility with the
+upstream reference server it was ported from).
+
+- **Tools**: primitives, structured content, resource links, binary content,
+  progress notifications, cancellation-safe long-running work.
+- **Resources**: static file resources, session-scoped dynamic resources,
+  subscribe/unsubscribe with simulated update notifications.
+- **Elicitation**: form-mode and URL-mode, both request-path
+  (`elicitation/create`) and error-path (`UrlElicitationRequiredError`).
+- **Sampling**: server-initiated `sampling/createMessage`, synchronous and
+  task-based (bidirectional MCP Tasks).
+- **Tasks (SEP-1686)**: long-running tool execution via `tasks/get` and
+  `tasks/result`, including a mid-flight elicitation pause
+  (`input_required`).
+- **Logging**: `logging/setLevel` with real RFC 5424 severity filtering.
+
+Every tool's description ends with a "Demo/test fixture" note so a user
+connecting to this server doesn't mistake intentional failures or delays for
+a bug in MCPFlo itself.

package/dist/docs/how-it-works.md

@@ -0,0 +1,22 @@
+# How It Works
+
+A single Node process talks MCP over stdio — no HTTP, no browser, no
+external services except where a tool's whole purpose is to demonstrate one
+(the gzip tool's optional network fetch).
+
+Request lifecycle for a typical tool call:
+
+1. Client sends `tools/call`.
+2. The registered handler runs, using only what the SDK gives it
+   (`args`, `extra.sendRequest`, `extra.sessionId`, etc.) — no shared mutable
+   state between unrelated tools.
+3. Tools that need server-initiated round trips (elicitation, sampling) call
+   `extra.sendRequest(...)` and await the client's reply on the same
+   connection.
+4. Tools that register a resource at call time (e.g. gzip output) do so
+   through `server.registerResource(...)`, which triggers
+   `notifications/resources/list_changed` automatically.
+
+Several capabilities are intentionally *not* auto-declared by the SDK and
+have to be turned on explicitly at server construction: `tasks`, `logging`,
+and `resources.subscribe`. See `architecture.md` for where that happens.

package/dist/docs/instructions.md

@@ -0,0 +1,16 @@
+# Instructions
+
+Connect to this server the same way as any stdio MCP server: spawn
+`node dist/index.js` (or the published `mcpflo-server-everything` bin) and
+speak MCP over its stdin/stdout.
+
+Nothing here requires configuration to get started — every tool has sane
+defaults for its arguments. A few tools depend on the connecting client's
+declared capabilities and will return a clear `isError` message instead of
+failing silently if the client doesn't support what they need:
+
+- `trigger-elicitation-request` / `-async` need `capabilities.elicitation`.
+- `trigger-url-elicitation` needs `capabilities.elicitation.url`.
+- `trigger-sampling-request` / `-async` need `capabilities.sampling`.
+
+Everything else works with a bare-minimum client.

package/dist/docs/startup.md

@@ -0,0 +1,20 @@
+# Startup
+
+On launch, before the transport connects:
+
+1. The `McpServer` is constructed with an in-memory task store and explicit
+   `tasks`/`logging`/`resources.subscribe` capabilities (none of these are
+   inferred automatically by the SDK from registering a tool or resource).
+2. All tools register themselves via `registerTools(server)`.
+3. A throwaway resource is registered and immediately disabled
+   (`initSessionResources`) — purely to work around an SDK quirk where the
+   very first `registerResource()` call tries to finalize the resources
+   capability, which throws if it happens after `connect()`. Warming it up
+   here means later, real dynamic resource registrations (e.g. from the
+   gzip tool) work without special-casing.
+4. Logging (`registerLoggingCapability`) and subscription
+   (`registerSubscriptionsCapability`) request handlers are wired up.
+5. The server connects over stdio and starts serving requests.
+
+There is no seeding of demo data beyond this file-resource set — everything
+else appears only when a tool creates it.

package/dist/docs/structure.md

@@ -0,0 +1,21 @@
+# Structure
+
+```
+packages/server-everything/
+├── docs/                     this file set — copied into dist/ at build time
+├── src/
+│   ├── index.ts              server construction, capability wiring, connect
+│   ├── tools/                one file per tool + a barrel (index.ts)
+│   ├── resources/
+│   │   ├── templates.ts      static text/blob resource-reference helpers
+│   │   ├── session.ts        dynamic session-scoped resource registration
+│   │   ├── subscriptions.ts  resources/subscribe + simulated update loop
+│   │   └── file-resources.ts registers this docs/ set as static resources
+│   └── server/
+│       └── logging.ts        logging/setLevel + simulated log messages
+├── package.json
+└── tsconfig.json
+```
+
+New tools and resources are added one file at a time, then wired into the
+relevant barrel — never generated in bulk.

package/dist/index.js

@@ -0,0 +1,10 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const stdio_js_1 = require("@modelcontextprotocol/sdk/server/stdio.js");
+const createServer_1 = require("./createServer");
+const server = (0, createServer_1.createServer)();
+server.connect(new stdio_js_1.StdioServerTransport()).catch((error) => {
+    console.error(error);
+    process.exit(1);
+});

package/dist/prompts/args.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerArgumentsPrompt = registerArgumentsPrompt;
+const zod_1 = require("zod");
+function registerArgumentsPrompt(server) {
+    server.registerPrompt('args-prompt', {
+        title: 'Arguments Prompt',
+        description: 'A prompt with two arguments, one required and one optional. Demo/test fixture.',
+        argsSchema: {
+            city: zod_1.z.string().describe('Name of the city'),
+            state: zod_1.z.string().optional().describe('Name of the state')
+        }
+    }, (args) => {
+        const location = `${args.city}${args.state ? `, ${args.state}` : ''}`;
+        return {
+            messages: [{ role: 'user', content: { type: 'text', text: `What's weather in ${location}?` } }]
+        };
+    });
+}

package/dist/prompts/completions.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerPromptWithCompletions = registerPromptWithCompletions;
+const zod_1 = require("zod");
+const completable_js_1 = require("@modelcontextprotocol/sdk/server/completable.js");
+const DEPARTMENT_MEMBERS = {
+    Engineering: ['Alice', 'Bob', 'Charlie'],
+    Sales: ['David', 'Eve', 'Frank'],
+    Marketing: ['Grace', 'Henry', 'Iris'],
+    Support: ['John', 'Kim', 'Lee']
+};
+function registerPromptWithCompletions(server) {
+    server.registerPrompt('completable-prompt', {
+        title: 'Team Management',
+        description: 'First argument choice narrows values for second argument. Demo/test fixture.',
+        argsSchema: {
+            department: (0, completable_js_1.completable)(zod_1.z.string().describe('Choose the department.'), (value) => ['Engineering', 'Sales', 'Marketing', 'Support'].filter((d) => d.startsWith(value))),
+            name: (0, completable_js_1.completable)(zod_1.z.string().describe('Choose a team member to lead the selected department.'), (value, context) => {
+                const department = context?.arguments?.['department'];
+                const members = department ? (DEPARTMENT_MEMBERS[department] ?? []) : [];
+                return members.filter((n) => n.startsWith(value));
+            })
+        }
+    }, ({ department, name }) => ({
+        messages: [
+            {
+                role: 'user',
+                content: { type: 'text', text: `Please promote ${name} to the head of the ${department} team.` }
+            }
+        ]
+    }));
+}

package/dist/prompts/index.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerPrompts = registerPrompts;
+const simple_1 = require("./simple");
+const args_1 = require("./args");
+const completions_1 = require("./completions");
+const resource_1 = require("./resource");
+// Add one entry per prompt file here as prompts are added, one at a time.
+const registerFns = [
+    simple_1.registerSimplePrompt,
+    args_1.registerArgumentsPrompt,
+    completions_1.registerPromptWithCompletions,
+    resource_1.registerEmbeddedResourcePrompt
+];
+function registerPrompts(server) {
+    for (const register of registerFns) {
+        register(server);
+    }
+}

package/dist/prompts/resource.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerEmbeddedResourcePrompt = registerEmbeddedResourcePrompt;
+const templates_1 = require("../resources/templates");
+function registerEmbeddedResourcePrompt(server) {
+    server.registerPrompt('resource-prompt', {
+        title: 'Resource Prompt',
+        description: 'A prompt that includes an embedded resource reference. Demo/test fixture.',
+        argsSchema: {
+            resourceType: templates_1.resourceTypeCompleter,
+            resourceId: templates_1.resourceIdForPromptCompleter
+        }
+    }, (args) => {
+        const resourceId = Number(args.resourceId);
+        if (!Number.isFinite(resourceId) || !Number.isInteger(resourceId) || resourceId < 1) {
+            throw new Error(`Invalid resourceId: ${args.resourceId}. Must be a finite positive integer.`);
+        }
+        const uri = args.resourceType === templates_1.RESOURCE_TYPE_TEXT ? (0, templates_1.textResourceUri)(resourceId) : (0, templates_1.blobResourceUri)(resourceId);
+        const resource = args.resourceType === templates_1.RESOURCE_TYPE_TEXT
+            ? (0, templates_1.textResource)(uri, resourceId)
+            : (0, templates_1.blobResource)(uri, resourceId);
+        return {
+            messages: [
+                {
+                    role: 'user',
+                    content: {
+                        type: 'text',
+                        text: `This prompt includes the ${args.resourceType} resource with id: ${resourceId}. Please analyze the following resource:`
+                    }
+                },
+                { role: 'user', content: { type: 'resource', resource } }
+            ]
+        };
+    });
+}

package/dist/prompts/simple.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerSimplePrompt = registerSimplePrompt;
+function registerSimplePrompt(server) {
+    server.registerPrompt('simple-prompt', {
+        title: 'Simple Prompt',
+        description: 'A prompt with no arguments. Demo/test fixture.'
+    }, () => ({
+        messages: [
+            {
+                role: 'user',
+                content: { type: 'text', text: 'This is a simple prompt without arguments.' }
+            }
+        ]
+    }));
+}

package/dist/resources/docsDir.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveDocsDir = resolveDocsDir;
+const path_1 = require("path");
+const fs_1 = require("fs");
+// The build script copies docs/ into dist/docs so the published package is
+// self-contained (dist/resources/../docs resolves correctly at runtime).
+// Vitest runs directly against src/ instead of the compiled output, where
+// that same relative path would land on a nonexistent src/docs — the real
+// docs/ is one level further up, at the package root. Rather than
+// duplicating docs/ into src/ just for tests, resolve whichever actually
+// exists.
+function resolveDocsDir(fromDir) {
+    const distRelative = (0, path_1.join)(fromDir, '..', 'docs');
+    if ((0, fs_1.existsSync)(distRelative))
+        return distRelative;
+    return (0, path_1.join)(fromDir, '..', '..', 'docs');
+}

package/dist/resources/file-resources.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerFileResources = registerFileResources;
+const path_1 = require("path");
+const fs_1 = require("fs");
+const docsDir_1 = require("./docsDir");
+function getMimeType(fileName) {
+    const lower = fileName.toLowerCase();
+    if (lower.endsWith('.md') || lower.endsWith('.markdown'))
+        return 'text/markdown';
+    if (lower.endsWith('.txt'))
+        return 'text/plain';
+    if (lower.endsWith('.json'))
+        return 'application/json';
+    return 'text/plain';
+}
+function readFileSafe(path) {
+    try {
+        return (0, fs_1.readFileSync)(path, 'utf-8');
+    }
+    catch (error) {
+        return `Error reading file: ${path}. ${error}`;
+    }
+}
+function registerFileResources(server) {
+    // __dirname is a real CommonJS module-scope binding here, no import.meta
+    // shim needed.
+    const docsDir = (0, docsDir_1.resolveDocsDir)(__dirname);
+    let entries = [];
+    try {
+        entries = (0, fs_1.readdirSync)(docsDir);
+    }
+    catch {
+        return;
+    }
+    for (const name of entries) {
+        const fullPath = (0, path_1.join)(docsDir, name);
+        try {
+            if (!(0, fs_1.statSync)(fullPath).isFile())
+                continue;
+        }
+        catch {
+            continue;
+        }
+        const uri = `mcpflo://static/document/${encodeURIComponent(name)}`;
+        const mimeType = getMimeType(name);
+        const description = `Static document file exposed from docs/: ${name}`;
+        server.registerResource(name, uri, { mimeType, description }, async (readUri) => ({
+            contents: [{ uri: readUri.toString(), mimeType, text: readFileSafe(fullPath) }]
+        }));
+    }
+}

package/dist/resources/index.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerResources = registerResources;
+exports.readInstructions = readInstructions;
+const path_1 = require("path");
+const fs_1 = require("fs");
+const templates_1 = require("./templates");
+const file_resources_1 = require("./file-resources");
+const docsDir_1 = require("./docsDir");
+function registerResources(server) {
+    (0, templates_1.registerResourceTemplates)(server);
+    (0, file_resources_1.registerFileResources)(server);
+}
+function readInstructions() {
+    // __dirname is a real CommonJS module-scope binding here, no import.meta
+    // shim needed.
+    const filePath = (0, path_1.join)((0, docsDir_1.resolveDocsDir)(__dirname), 'instructions.md');
+    try {
+        return (0, fs_1.readFileSync)(filePath, 'utf-8');
+    }
+    catch (error) {
+        return `Server instructions not loaded: ${error}`;
+    }
+}

package/dist/resources/session.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initSessionResources = initSessionResources;
+exports.getSessionResourceURI = getSessionResourceURI;
+exports.registerSessionResource = registerSessionResource;
+let counter = 0;
+// McpServer.registerResource() calls the SDK's registerCapabilities() on its
+// very first-ever invocation, which throws once server.connect() has already
+// run. Tools register session resources at call-time, which is always
+// post-connect, so we register (and immediately disable) one throwaway
+// resource before connect to trip that one-time init path early. Disabling
+// it hides it from resources/list without undoing the warm-up.
+function initSessionResources(server) {
+    server.registerResource('__session_warmup__', 'mcpflo://session/warmup', { mimeType: 'text/plain' }, async (uri) => ({ contents: [{ uri: uri.href, mimeType: 'text/plain', text: '' }] })).disable();
+}
+function getSessionResourceURI(name) {
+    counter += 1;
+    return `mcpflo://session/resource/${counter}/${encodeURIComponent(name)}`;
+}
+function registerSessionResource(server, resource, kind, data) {
+    server.registerResource(resource.name, resource.uri, { mimeType: resource.mimeType }, async (uri) => ({
+        contents: [
+            kind === 'blob'
+                ? { uri: uri.href, mimeType: resource.mimeType, blob: data }
+                : { uri: uri.href, mimeType: resource.mimeType, text: data }
+        ]
+    }));
+    return {
+        type: 'resource_link',
+        uri: resource.uri,
+        name: resource.name,
+        mimeType: resource.mimeType
+    };
+}

package/dist/resources/subscriptions.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerSubscriptionsCapability = registerSubscriptionsCapability;
+exports.beginSimulatedResourceUpdates = beginSimulatedResourceUpdates;
+exports.stopSimulatedResourceUpdates = stopSimulatedResourceUpdates;
+const types_js_1 = require("@modelcontextprotocol/sdk/types.js");
+const INTERVAL_MS = 5000;
+const sessionSubscriptions = new Map();
+const sessionTimers = new Map();
+function registerSubscriptionsCapability(server) {
+    server.server.setRequestHandler(types_js_1.SubscribeRequestSchema, async (request, extra) => {
+        const uris = sessionSubscriptions.get(extra.sessionId) ?? new Set();
+        uris.add(request.params.uri);
+        sessionSubscriptions.set(extra.sessionId, uris);
+        return {};
+    });
+    server.server.setRequestHandler(types_js_1.UnsubscribeRequestSchema, async (request, extra) => {
+        sessionSubscriptions.get(extra.sessionId)?.delete(request.params.uri);
+        return {};
+    });
+}
+function beginSimulatedResourceUpdates(server, sessionId) {
+    const timer = setInterval(() => {
+        const uris = sessionSubscriptions.get(sessionId);
+        if (!uris || uris.size === 0)
+            return;
+        for (const uri of uris) {
+            server.server.sendResourceUpdated({ uri }).catch(() => { });
+        }
+    }, INTERVAL_MS);
+    sessionTimers.set(sessionId, timer);
+}
+function stopSimulatedResourceUpdates(sessionId) {
+    const timer = sessionTimers.get(sessionId);
+    if (timer)
+        clearInterval(timer);
+    sessionTimers.delete(sessionId);
+}