Skip to content

AI-native design editor. Open-source Figma alternative.

fix(mcp): release cancelled requests and preserve HTTP method semantics (#1278)

Paolo Musolino4ee5c39ae0fc
diff --git a/changes/1278/fixed.md b/changes/1278/fixed.md
new file mode 100644
index 000000000..d50707748
--- /dev/null
+++ b/changes/1278/fixed.md
@@ -0,0 +1 @@
+- The MCP HTTP server no longer runs out of sessions after failed initializations, session-less GET requests, or cancelled tool calls, and closes sessions idle for 15 minutes (`OPENPENCIL_MCP_SESSION_IDLE_TIMEOUT_MS`).
diff --git a/package.json b/package.json
index 94942187e..9bc749fd2 100644
--- a/package.json
+++ b/package.json
@@ -63,8 +63,8 @@
"benchmark:navigation": "bun tools/dev/navigation-benchmark/src/cli.ts run",
"test:native": "bun run build:native-test && wdio run wdio.conf.ts",
"lint": "bun run lint:structure && oxlint -c oxlint.json --type-aware --type-check src/ packages/scene-graph/src/ packages/core/src/ packages/vue/src/ packages/cli/src/ packages/mcp/src/ packages/harness/src/ packages/feedback/src/ packages/cloud/src/ packages/dom-css/src/ packages/pen/src/ packages/design-jsx/src/ packages/emit/src/ packages/kiwi/src/ packages/fig/src/ packages/docs/.vitepress/theme/landing/",
- "lint:structure": "oxlint -c oxlint.json commitlint.config.ts vite.config.ts vite/ .storybook/ src/ packages/scene-graph/src/ packages/scene-graph/scripts/ packages/core/src/ packages/vue/src/ packages/cli/src/ packages/mcp/src/ packages/harness/src/ packages/harness/tests/ packages/feedback/src/ packages/feedback/tests/ packages/cloud/src/ packages/cloud/tests/ packages/cloud/deploy/ packages/dom-css/src/ packages/dom-css/tests/ packages/dom-css/scripts/ packages/pen/src/ packages/pen/scripts/ packages/design-jsx/src/ packages/design-jsx/tests/ packages/design-jsx/scripts/ packages/emit/src/ packages/emit/tests/ packages/emit/scripts/ packages/kiwi/src/ packages/kiwi/tests/ packages/kiwi/scripts/ packages/fig/src/ packages/fig/tests/ packages/fig/scripts/ packages/core/tests/ packages/cli/tests/ packages/scene-graph/tests/ packages/vue/tests/ tests/ scripts/ tools/ packages/docs/.vitepress/theme/landing/",
- "format": "oxfmt --write .oxfmtrc.json commitlint.config.ts vite.config.ts vite/ .storybook/ src/ packages/scene-graph/src/ packages/scene-graph/scripts/ packages/core/src/ packages/cli/src/ packages/mcp/src/ packages/harness/src/ packages/harness/tests/ packages/feedback/src/ packages/feedback/tests/ packages/cloud/src/ packages/cloud/tests/ packages/cloud/deploy/ packages/cloud/tsdown.config.ts packages/cloud/tsdown.standalone.config.ts packages/vue/src/ packages/dom-css/src/ packages/dom-css/tests/ packages/dom-css/scripts/ packages/pen/src/ packages/pen/scripts/ packages/design-jsx/src/ packages/design-jsx/tests/ packages/design-jsx/scripts/ packages/emit/src/ packages/emit/tests/ packages/emit/scripts/ packages/kiwi/src/ packages/kiwi/tests/ packages/kiwi/scripts/ packages/fig/src/ packages/fig/tests/ packages/fig/scripts/ tests scripts/ tools/ packages/docs/.vitepress/theme/landing/",
+ "lint:structure": "oxlint -c oxlint.json commitlint.config.ts vite.config.ts vite/ .storybook/ src/ packages/scene-graph/src/ packages/scene-graph/scripts/ packages/core/src/ packages/vue/src/ packages/cli/src/ packages/mcp/src/ packages/mcp/tests/ packages/harness/src/ packages/harness/tests/ packages/feedback/src/ packages/feedback/tests/ packages/cloud/src/ packages/cloud/tests/ packages/cloud/deploy/ packages/dom-css/src/ packages/dom-css/tests/ packages/dom-css/scripts/ packages/pen/src/ packages/pen/scripts/ packages/design-jsx/src/ packages/design-jsx/tests/ packages/design-jsx/scripts/ packages/emit/src/ packages/emit/tests/ packages/emit/scripts/ packages/kiwi/src/ packages/kiwi/tests/ packages/kiwi/scripts/ packages/fig/src/ packages/fig/tests/ packages/fig/scripts/ packages/core/tests/ packages/cli/tests/ packages/scene-graph/tests/ packages/vue/tests/ tests/ scripts/ tools/ packages/docs/.vitepress/theme/landing/",
+ "format": "oxfmt --write .oxfmtrc.json commitlint.config.ts vite.config.ts vite/ .storybook/ src/ packages/scene-graph/src/ packages/scene-graph/scripts/ packages/core/src/ packages/cli/src/ packages/mcp/src/ packages/mcp/tests/ packages/harness/src/ packages/harness/tests/ packages/feedback/src/ packages/feedback/tests/ packages/cloud/src/ packages/cloud/tests/ packages/cloud/deploy/ packages/cloud/tsdown.config.ts packages/cloud/tsdown.standalone.config.ts packages/vue/src/ packages/dom-css/src/ packages/dom-css/tests/ packages/dom-css/scripts/ packages/pen/src/ packages/pen/scripts/ packages/design-jsx/src/ packages/design-jsx/tests/ packages/design-jsx/scripts/ packages/emit/src/ packages/emit/tests/ packages/emit/scripts/ packages/kiwi/src/ packages/kiwi/tests/ packages/kiwi/scripts/ packages/fig/src/ packages/fig/tests/ packages/fig/scripts/ tests scripts/ tools/ packages/docs/.vitepress/theme/landing/",
"format:check": "bun run format && status=$(git status --porcelain -uall) && test -z \"$status\" || (echo \"$status\" && exit 1)",
"check": "bun run check:icons && bun run build:packages && bun run lint && tsgo --noEmit && bun run check:vue && bun run check:native-test && bun run check:i18n && bun run check:docs && bun run check:changelog && bun run check:packages && bun run check:deps && bun run check:audit && bun run check:secrets && bun run check:monorepo && bun run check:arch && bun run check:test-homes && bun run check:cloud-off && bun run check:test-types && bun run test:type-shapes && bun run check:tools && bun run test:tools && bun run test:dupes",
"check:commits": "commitlint",
diff --git a/packages/mcp/README.md b/packages/mcp/README.md
index ae77889f3..d8dd41ef9 100644
--- a/packages/mcp/README.md
+++ b/packages/mcp/README.md
@@ -10,6 +10,8 @@ openpencil-mcp-http # Streamable HTTP transport for browser extensions and scr
On macOS and Linux, local clients prefer a private Unix domain socket; Windows and unavailable sockets fall back to localhost TCP. File access is limited to the effective MCP root.
+Streamable HTTP clients initialize with a POST, then open GET/SSE with the returned `Mcp-Session-Id`; DELETE ends the session. The server keeps at most 10 sessions and closes those idle for 15 minutes (`OPENPENCIL_MCP_SESSION_IDLE_TIMEOUT_MS`, `0` disables). Running requests keep a session alive, an open SSE stream alone does not, and an expired session ID returns 404.
+
- Setup and client configuration: https://openpencil.dev/programmable/mcp-server
- Source and issues: https://github.com/open-pencil/open-pencil
diff --git a/packages/mcp/src/index.ts b/packages/mcp/src/index.ts
index cd265c05f..91699fd96 100644
--- a/packages/mcp/src/index.ts
+++ b/packages/mcp/src/index.ts
@@ -27,6 +27,9 @@ if (process.argv.includes('--help') || process.argv.includes('-h')) {
` OPENPENCIL_MCP_AUTH_TOKEN Bearer token for MCP and RPC auth\n` +
` OPENPENCIL_MCP_ROOT Allowed directory for file-scoped tools (default: home directory on Windows, current working directory elsewhere)\n` +
` OPENPENCIL_MCP_EVAL Set to 1 to enable the eval tool\n` +
+ ` OPENPENCIL_MCP_SESSION_IDLE_TIMEOUT_MS\n` +
+ ` Close sessions idle this long, in ms (default: 900000;\n` +
+ ` 0 disables). An open GET/SSE stream is not activity.\n` +
` OPENPENCIL_MCP_DISABLED_TOOLS Comma-separated tool names to omit\n` +
` OPENPENCIL_MCP_SCOPE "selection" to let clients read only the selected layers\n` +
` (default: "document")\n` +
@@ -60,25 +63,25 @@ const port = rawPort
// the PORT value alone determines whether TCP is enabled (PORT=0 is the kill switch).
const withTcp = port > 0
-const MAX_APP_TIMEOUT_MS = 2_147_483_647
-const rawAppTimeoutText = process.env.OPENPENCIL_MCP_APP_TIMEOUT_MS?.trim()
-let appAttachTimeoutMs: number | undefined
-if (rawAppTimeoutText) {
- if (!/^\d+$/.test(rawAppTimeoutText)) {
- process.stderr.write(
- `Error: OPENPENCIL_MCP_APP_TIMEOUT_MS must be a non-negative integer, got "${rawAppTimeoutText}"\n`
- )
- process.exit(1)
- }
- appAttachTimeoutMs = Number.parseInt(rawAppTimeoutText, 10)
- if (!Number.isSafeInteger(appAttachTimeoutMs) || appAttachTimeoutMs > MAX_APP_TIMEOUT_MS) {
+const MAX_TIMEOUT_MS = 2_147_483_647
+
+/** Read a millisecond timeout from the environment, exiting on an invalid value. */
+function readTimeoutEnv(name: string): number | undefined {
+ const text = process.env[name]?.trim()
+ if (!text) return undefined
+ const timeoutMs = Number(text)
+ if (!/^\d+$/.test(text) || timeoutMs > MAX_TIMEOUT_MS) {
process.stderr.write(
- `Error: OPENPENCIL_MCP_APP_TIMEOUT_MS must be an integer in 0–${MAX_APP_TIMEOUT_MS}, got "${rawAppTimeoutText}"\n`
+ `Error: ${name} must be an integer in 0–${MAX_TIMEOUT_MS}, got "${text}"\n`
)
process.exit(1)
}
+ return timeoutMs
}
+const appAttachTimeoutMs = readTimeoutEnv('OPENPENCIL_MCP_APP_TIMEOUT_MS')
+const sessionIdleTimeoutMs = readTimeoutEnv('OPENPENCIL_MCP_SESSION_IDLE_TIMEOUT_MS')
+
const toolPolicy = readToolPolicyFromEnv()
const handle = await startServer({
@@ -107,7 +110,8 @@ const handle = await startServer({
return trimmed
})(),
corsOrigin: resolveCORSOrigins(process.env.OPENPENCIL_MCP_CORS_ORIGIN),
- appAttachTimeoutMs
+ appAttachTimeoutMs,
+ sessionIdleTimeoutMs
})
const readyMarker = process.env.OPENPENCIL_MCP_READY_MARKER
diff --git a/packages/mcp/src/server.ts b/packages/mcp/src/server.ts
index 56ebee88b..4253c334a 100644
--- a/packages/mcp/src/server.ts
+++ b/packages/mcp/src/server.ts
@@ -41,6 +41,7 @@ import {
export const MCP_VERSION: string = packageJSON.version
const HEARTBEAT_INTERVAL_MS = 5_000
+const MCP_METHODS: readonly string[] = ['GET', 'POST', 'DELETE']
let installCommandPromise: Promise<string> | null = null
@@ -105,6 +106,12 @@ export interface ServerOptions {
* app opts in when it spawns the server.
*/
appAttachTimeoutMs?: number
+ /**
+ * How long an MCP session may sit without requests before it is closed.
+ * Defaults to 15 minutes; 0 disables expiration. An open GET/SSE stream
+ * does not count as activity.
+ */
+ sessionIdleTimeoutMs?: number
/**
* How long a tool call waits for the app to register before it fails with
* APP_NOT_CONNECTED. Defaults to 10 s so a stdio bridge started slightly
@@ -200,18 +207,16 @@ function createHonoApp(options: {
return c.json({ error: 'Unauthorized' }, 401)
}
}
- const sessionId = c.req.header('mcp-session-id') ?? undefined
- // Reject anonymous DELETE requests before they allocate a session.
- // Without this guard, a DELETE without a session ID would call
- // resolveTransport(undefined), which creates a fresh session just
- // to no-op on deleteSession(undefined) — burning a session slot.
- if (c.req.method === 'DELETE' && !sessionId) {
- return c.json({ error: 'Missing MCP session id' }, 400)
+ if (!MCP_METHODS.includes(c.req.method)) {
+ return c.json(
+ { error: 'Method not allowed' },
+ { status: 405, headers: { Allow: MCP_METHODS.join(', ') } }
+ )
}
- // For DELETE, look up the existing session without creating a new one.
- // resolveTransport() would allocate a fresh session for an unknown ID,
- // only to immediately delete it — wasting a session slot.
- if (c.req.method === 'DELETE' && sessionId) {
+ const sessionId = c.req.header('mcp-session-id') ?? undefined
+ if (sessionId) {
+ // Never allocate a session for an unknown ID: DELETE or a stale client
+ // would burn a slot it can never use.
const existing = mcpSessions.getExistingTransport(sessionId)
if ('error' in existing) {
if (existing.error === 'closed') {
@@ -219,22 +224,16 @@ function createHonoApp(options: {
}
return c.json({ error: 'MCP session not found' }, 404)
}
+ if (c.req.method !== 'DELETE') return existing.handleRequest(c.req.raw)
try {
return await existing.handleRequest(c.req.raw)
} finally {
- mcpSessions.deleteSession(sessionId)
+ await mcpSessions.deleteSession(sessionId)
}
}
- if (sessionId) {
- const existing = mcpSessions.getExistingTransport(sessionId)
- if ('error' in existing) {
- if (existing.error === 'closed') {
- return c.json({ error: 'MCP server is shutting down' }, 503)
- }
- return c.json({ error: 'MCP session not found' }, 404)
- }
- mcpSessions.touch(sessionId, existing)
- return existing.handleRequest(c.req.raw)
+ // Only an initializing POST may start a session.
+ if (c.req.method !== 'POST') {
+ return c.json({ error: 'Missing MCP session id' }, 400)
}
const transport = await mcpSessions.resolveTransport(
undefined,
@@ -249,7 +248,6 @@ function createHonoApp(options: {
{ status: 503, headers: { 'Retry-After': '5' } }
)
}
- mcpSessions.touch(undefined, transport)
return transport.handleRequest(c.req.raw)
})
@@ -338,12 +336,14 @@ function buildServerContext(options: ServerOptions) {
const mcpSessions = createMCPSessionManager({
serverVersion: MCP_VERSION,
- registerTools: (mcpServer: McpServer, agentSession: MCPAgentSession) =>
+ sessionIdleTimeoutMs: options.sessionIdleTimeoutMs,
+ registerTools: (mcpServer: McpServer, agentSession: MCPAgentSession, onToolSettled) =>
registerTools(mcpServer, {
policy: toolPolicy,
mcpRoot,
sendRPC: sendToBrowser,
- agentSession
+ agentSession,
+ onToolSettled
}),
onSessionClosed: (sessionId) => {
// Best-effort: the app may be gone already, and then it shows no agents anyway.
@@ -476,6 +476,7 @@ function buildHandle(
export async function startServer(options: ServerOptions = {}): Promise<ServerHandle> {
validateTimeoutOption('appAttachTimeoutMs', options.appAttachTimeoutMs)
validateTimeoutOption('appWaitTimeoutMs', options.appWaitTimeoutMs)
+ validateTimeoutOption('sessionIdleTimeoutMs', options.sessionIdleTimeoutMs)
const ctx = buildServerContext(options)
// Wire shared connection handling BEFORE starting listeners so that
diff --git a/packages/mcp/src/server/pending-requests.ts b/packages/mcp/src/server/pending-requests.ts
new file mode 100644
index 000000000..b4ce742f3
--- /dev/null
+++ b/packages/mcp/src/server/pending-requests.ts
@@ -0,0 +1,62 @@
+import type {
+ ServerContext,
+ WebStandardStreamableHTTPServerTransport
+} from '@modelcontextprotocol/server'
+
+const REQUEST_CANCELLED = -32800
+
+/**
+ * In JSON response mode the SDK never settles the HTTP response of a request
+ * that was cancelled or that was still running when the transport closed.
+ * This tracks each POST so both cases can be answered.
+ */
+export function createPendingRequests(transport: WebStandardStreamableHTTPServerTransport) {
+ const waiting = new Map<Request, (response: Response) => void>()
+ let closed = false
+
+ function settled(request: Request): Promise<Response> {
+ if (closed) return Promise.resolve(sessionNotFound())
+ return new Promise((resolve) => {
+ waiting.set(request, resolve)
+ })
+ }
+
+ async function handle(request: Request): Promise<Response> {
+ const handling = transport.handleRequest(request)
+ if (request.method !== 'POST') return handling
+ try {
+ return await Promise.race([handling, settled(request)])
+ } finally {
+ waiting.delete(request)
+ }
+ }
+
+ /** End a cancelled tool call's HTTP request without a JSON-RPC result. */
+ async function releaseCancelled(context: ServerContext): Promise<void> {
+ const request = context.http?.req
+ const respond = request && waiting.get(request)
+ if (!respond || !context.mcpReq.signal.aborted) return
+ respond(new Response(null, { status: 202 }))
+ // The SDK drops the cancelled result, so its stream bookkeeping waits for
+ // a response that never comes. Send one to release it.
+ await transport
+ .send({
+ jsonrpc: '2.0',
+ id: context.mcpReq.id,
+ error: { code: REQUEST_CANCELLED, message: 'Request cancelled' }
+ })
+ .catch(() => undefined)
+ }
+
+ function close() {
+ closed = true
+ for (const respond of waiting.values()) respond(sessionNotFound())
+ waiting.clear()
+ }
+
+ return { close, handle, releaseCancelled }
+}
+
+function sessionNotFound() {
+ return Response.json({ error: 'MCP session not found' }, { status: 404 })
+}
diff --git a/packages/mcp/src/server/sessions.ts b/packages/mcp/src/server/sessions.ts
index 6e5b741dc..f725dfd94 100644
--- a/packages/mcp/src/server/sessions.ts
+++ b/packages/mcp/src/server/sessions.ts
@@ -1,8 +1,14 @@
import { randomUUID } from 'node:crypto'
-import { McpServer, WebStandardStreamableHTTPServerTransport } from '@modelcontextprotocol/server'
+import {
+ isJSONRPCResultResponse,
+ McpServer,
+ WebStandardStreamableHTTPServerTransport
+} from '@modelcontextprotocol/server'
+import { withTimeout } from 'es-toolkit/promise'
-import type { MCPAgentKind, MCPAgentSession } from '#mcp/tool/registration'
+import { createPendingRequests } from '#mcp/server/pending-requests'
+import type { MCPAgentKind, MCPAgentSession, MCPToolSettled } from '#mcp/tool/registration'
export type MCPTransport = {
handleRequest: (request: Request) => Promise<Response>
@@ -12,69 +18,81 @@ export type MCPTransport = {
type MCPSession = {
transport: MCPTransport
server: McpServer
+ requests: ReturnType<typeof createPendingRequests>
lastSeen: number
+ activeRequests: number
+ initialized: boolean
}
type MCPSessionManagerOptions = {
serverVersion: string
- registerTools: (server: McpServer, session: MCPAgentSession) => void
+ registerTools: (
+ server: McpServer,
+ session: MCPAgentSession,
+ onToolSettled: MCPToolSettled
+ ) => void
/** Told when a session ends, so the app stops showing its agent. */
onSessionClosed?: (sessionId: string) => void
+ /** Idle lifetime in ms; 0 disables expiration. Defaults to 15 minutes. */
+ sessionIdleTimeoutMs?: number
}
const MAX_MCP_SESSIONS = 10
-const MCP_SESSION_TTL_MS = 15 * 60_000
+const MCP_SESSION_IDLE_TIMEOUT_MS = 15 * 60_000
+const MAX_SWEEP_INTERVAL_MS = 60_000
+// The MCP SDK's close() does not enforce a timeout internally.
const SESSION_CLOSE_TIMEOUT_MS = 5_000
function describeError(e: unknown): string {
return e instanceof Error ? e.message : String(e)
}
-/**
- * Wraps a promise with a timeout. Resolves with undefined if the timeout
- * elapses before the promise settles. Used to prevent `transport.close()`
- * from hanging indefinitely — the MCP SDK's close() does not enforce a
- * timeout internally.
- */
-function withTimeout<T>(promise: Promise<T>, ms: number): Promise<T | undefined> {
- let timer: ReturnType<typeof setTimeout> | undefined
- return Promise.race([
- promise.finally(() => {
- if (timer) clearTimeout(timer)
- }),
- new Promise<T | undefined>((resolve) => {
- timer = setTimeout(() => resolve(undefined), ms)
- })
- ])
-}
-
-async function closeSession(session: MCPSession): Promise<void> {
+async function closeSession(session: Pick<MCPSession, 'transport' | 'server'>): Promise<void> {
try {
- await withTimeout(session.transport.close(), SESSION_CLOSE_TIMEOUT_MS)
+ await withTimeout(() => session.transport.close(), SESSION_CLOSE_TIMEOUT_MS)
} catch (e) {
// Best-effort: the transport may already be closed or in a bad state
process.stderr.write(` MCP session: transport close warning (${describeError(e)})\n`)
}
try {
- await withTimeout(session.server.close(), SESSION_CLOSE_TIMEOUT_MS)
+ await withTimeout(() => session.server.close(), SESSION_CLOSE_TIMEOUT_MS)
} catch (e) {
// Best-effort
process.stderr.write(` MCP session: server close warning (${describeError(e)})\n`)
}
}
+/**
+ * The SDK assigns the session ID before it validates the InitializeRequest,
+ * so a 200 carrying the session header can still be a JSON-RPC error.
+ */
+async function isInitializeResult(response: Response, id: string): Promise<boolean> {
+ if (!response.ok || response.headers.get('mcp-session-id') !== id) return false
+ const message: unknown = await response
+ .clone()
+ .json()
+ .catch(() => undefined)
+ return isJSONRPCResultResponse(message)
+}
+
export function createMCPSessionManager({
serverVersion,
registerTools,
- onSessionClosed
+ onSessionClosed,
+ sessionIdleTimeoutMs = MCP_SESSION_IDLE_TIMEOUT_MS
}: MCPSessionManagerOptions) {
const sessions = new Map<string, MCPSession>()
- const closing = new Set<Promise<void>>()
+ const closing = new Map<string, Promise<void>>()
- function scheduleClose(session: MCPSession, id?: string): Promise<void> {
- if (id) onSessionClosed?.(id)
- const task = closeSession(session).finally(() => closing.delete(task))
- closing.add(task)
+ function scheduleClose(session: MCPSession, id: string): Promise<void> {
+ try {
+ if (session.initialized) onSessionClosed?.(id)
+ } catch (e) {
+ // Application notification must not prevent resource cleanup.
+ process.stderr.write(` MCP session: close notification warning (${describeError(e)})\n`)
+ }
+ const task = closeSession(session).finally(() => closing.delete(id))
+ closing.set(id, task)
return task
}
@@ -89,15 +107,21 @@ export function createMCPSessionManager({
}
function cleanupExpired() {
+ if (sessionIdleTimeoutMs === 0) return
const now = Date.now()
for (const [id, session] of sessions) {
- if (now - session.lastSeen > MCP_SESSION_TTL_MS) {
+ if (session.activeRequests === 0 && now - session.lastSeen >= sessionIdleTimeoutMs) {
sessions.delete(id)
void scheduleClose(session, id)
}
}
}
+ const sweep =
+ sessionIdleTimeoutMs > 0
+ ? setInterval(cleanupExpired, Math.min(sessionIdleTimeoutMs, MAX_SWEEP_INTERVAL_MS)).unref()
+ : undefined
+
const creating = new Map<string, Promise<MCPTransport>>()
let closed = false
@@ -108,22 +132,20 @@ export function createMCPSessionManager({
const promise = (async () => {
const server = new McpServer({ name: 'open-pencil', version: serverVersion })
- registerTools(server, { id, kind })
const transport = new WebStandardStreamableHTTPServerTransport({
sessionIdGenerator: () => id,
enableJsonResponse: true
})
- // Await the MCP handshake before storing/returning the transport so
- // handleRequest cannot race the SDK's initialization on a fresh
- // session. Without this, the /mcp route calls resolveTransport() and
- // immediately awaits handleRequest(), which can fail if connect() has
- // not completed yet.
+ const requests = createPendingRequests(transport)
+ // Connect the SDK before exposing its transport. The client's HTTP
+ // InitializeRequest is processed later by handleRequest; connect() alone
+ // does not establish a valid MCP session.
try {
+ registerTools(server, { id, kind }, requests.releaseCancelled)
await server.connect(transport)
} catch (e) {
- await transport.close().catch(() => undefined)
- await server.close().catch(() => undefined)
+ await closeSession({ transport, server })
throw e
}
// `closed` is mutated by clear() which can run concurrently — TypeScript's
@@ -131,12 +153,34 @@ export function createMCPSessionManager({
// oxlint-disable-next-line no-unnecessary-condition
if (closed) {
// Manager was closed while we were connecting — clean up immediately.
- await transport.close().catch(() => undefined)
- await server.close().catch(() => undefined)
+ await closeSession({ transport, server })
throw new Error('Session manager closed during session creation')
}
- sessions.set(id, { transport, server, lastSeen: Date.now() })
- return transport
+ const session: MCPSession = {
+ server,
+ requests,
+ lastSeen: Date.now(),
+ activeRequests: 0,
+ initialized: false,
+ transport: {
+ close: () => transport.close(),
+ handleRequest: (request) => handleSessionRequest(id, session, request)
+ }
+ }
+ // Closing a GET/SSE stream does not close the transport, so only a full
+ // close ends the session. Keep the SDK's own protocol cleanup.
+ const onclose = transport.onclose
+ transport.onclose = () => {
+ requests.close()
+ try {
+ onclose?.()
+ } finally {
+ void deleteSession(id)
+ }
+ }
+ sessions.set(id, session)
+ creating.delete(id)
+ return session.transport
})()
creating.set(id, promise)
@@ -147,6 +191,29 @@ export function createMCPSessionManager({
}
}
+ async function handleSessionRequest(
+ id: string,
+ session: MCPSession,
+ request: Request
+ ): Promise<Response> {
+ session.activeRequests++
+ session.lastSeen = Date.now()
+ try {
+ const response = await session.requests.handle(request)
+ if (!session.initialized) {
+ session.initialized = await isInitializeResult(response, id)
+ if (!session.initialized) await deleteSession(id)
+ }
+ return response
+ } catch (error) {
+ if (!session.initialized) await deleteSession(id)
+ throw error
+ } finally {
+ session.activeRequests--
+ session.lastSeen = Date.now()
+ }
+ }
+
function resolveTransport(
sessionId: string | undefined,
kind: MCPAgentKind = 'mcp'
@@ -178,14 +245,6 @@ export function createMCPSessionManager({
})
}
- function touch(sessionId: string | undefined, transport: MCPTransport) {
- const resolvedSessionId =
- sessionId ?? [...sessions.entries()].find(([, entry]) => entry.transport === transport)?.[0]
- if (!resolvedSessionId) return
- const session = sessions.get(resolvedSessionId)
- if (session) session.lastSeen = Date.now()
- }
-
/**
* Look up an existing session's transport without creating a new session.
* Used for DELETE requests where creating a session just to delete it
@@ -195,23 +254,25 @@ export function createMCPSessionManager({
sessionId: string | undefined
): MCPTransport | { error: 'not_found' | 'closed' } {
if (closed) return { error: 'closed' }
+ cleanupExpired()
if (!sessionId) return { error: 'not_found' }
const existing = sessions.get(sessionId)
if (existing) return existing.transport
return { error: 'not_found' }
}
- function deleteSession(sessionId: string | undefined) {
+ async function deleteSession(sessionId: string | undefined): Promise<void> {
if (closed) return
if (!sessionId) return
const session = sessions.get(sessionId)
- if (!session) return
+ if (!session) return closing.get(sessionId)
sessions.delete(sessionId)
- void scheduleClose(session, sessionId)
+ await scheduleClose(session, sessionId)
}
async function clear() {
closed = true
+ clearInterval(sweep)
// Collect sessions before awaiting in-flight creations so new sessions
// can't be added during shutdown.
const all = [...sessions]
@@ -224,10 +285,10 @@ export function createMCPSessionManager({
// Await both previously-scheduled closes (from cleanupExpired/deleteSession)
// and closes for sessions still alive at clear() time.
await Promise.allSettled([
- ...closing,
+ ...closing.values(),
...all.map(([id, session]) => scheduleClose(session, id))
])
}
- return { clear, deleteSession, getExistingTransport, notifyToolsChanged, resolveTransport, touch }
+ return { clear, deleteSession, getExistingTransport, notifyToolsChanged, resolveTransport }
}
diff --git a/packages/mcp/src/tool/registration.ts b/packages/mcp/src/tool/registration.ts
index 469df4c34..0148a9828 100644
--- a/packages/mcp/src/tool/registration.ts
+++ b/packages/mcp/src/tool/registration.ts
@@ -1,7 +1,12 @@
import { Buffer } from 'node:buffer'
import { resolve } from 'node:path'
-import type { McpServer, ToolCallback, ToolAnnotations } from '@modelcontextprotocol/server'
+import type {
+ McpServer,
+ ToolCallback,
+ ToolAnnotations,
+ ServerContext
+} from '@modelcontextprotocol/server'
// eslint-disable-next-line open-pencil/no-mixed-case-acronym-identifiers -- Upstream export spelling.
import { toStandardJsonSchema as toStandardJSONSchema } from '@valibot/to-json-schema'
import * as v from 'valibot'
@@ -17,6 +22,7 @@ import { isToolEnabled } from '#mcp/tool/policy'
import { SELECTION_SCOPE_FILE_OUTPUT_ERROR } from '#mcp/tool/scope'
export type RPCSender = (body: Record<string, unknown>) => Promise<unknown>
+export type MCPToolSettled = (context: ServerContext) => Promise<void>
const automationTargetSchema = {
document_id: v.optional(
@@ -74,6 +80,8 @@ export interface RegisterToolsOptions {
mcpRoot?: string | null
sendRPC: RPCSender
agentSession?: MCPAgentSession
+ /** Transport lifecycle cleanup after tool execution, including cancellation. */
+ onToolSettled?: MCPToolSettled
}
function toolAnnotations(effect: ToolEffect): ToolAnnotations {
@@ -116,7 +124,13 @@ export function registerTools(mcpServer: McpServer, options: RegisterToolsOption
annotations: toolAnnotations(descriptor.effect),
_meta: { 'openpencil/capabilities': descriptor.capabilities }
},
- handler
+ async (args, context) => {
+ try {
+ return await handler(args, context)
+ } finally {
+ await options.onToolSettled?.(context)
+ }
+ }
)
}
diff --git a/packages/mcp/tests/server/sessions.test.ts b/packages/mcp/tests/server/sessions.test.ts
new file mode 100644
index 000000000..7aa65283e
--- /dev/null
+++ b/packages/mcp/tests/server/sessions.test.ts
@@ -0,0 +1,438 @@
+import { afterEach, describe, expect, spyOn, test } from 'bun:test'
+
+import { McpServer } from '@modelcontextprotocol/server'
+
+import { createMCPSessionManager, type MCPTransport } from '#mcp/server/sessions'
+import { registerTools } from '#mcp/tool/registration'
+
+const managers: ReturnType<typeof createMCPSessionManager>[] = []
+afterEach(async () => {
+ await Promise.all(managers.splice(0).map((manager) => manager.clear()))
+})
+
+function manager(options: Partial<Parameters<typeof createMCPSessionManager>[0]> = {}) {
+ const instance = createMCPSessionManager({
+ serverVersion: '0.0.0',
+ registerTools: () => undefined,
+ ...options
+ })
+ managers.push(instance)
+ return instance
+}
+
+function request(body: unknown, sessionId?: string) {
+ return new Request('http://localhost/mcp', {
+ method: 'POST',
+ headers: {
+ accept: 'application/json, text/event-stream',
+ 'content-type': 'application/json',
+ ...(sessionId ? { 'mcp-session-id': sessionId } : {})
+ },
+ body: JSON.stringify(body)
+ })
+}
+
+const initialize = {
+ jsonrpc: '2.0',
+ id: 1,
+ method: 'initialize',
+ params: {
+ protocolVersion: '2025-06-18',
+ capabilities: {},
+ clientInfo: { name: 'test', version: '1' }
+ }
+}
+
+async function transport(instance: ReturnType<typeof manager>): Promise<MCPTransport> {
+ const result = await instance.resolveTransport(undefined)
+ if ('error' in result) throw new Error(result.error)
+ return result
+}
+
+async function initialized(instance: ReturnType<typeof manager>) {
+ const connection = await transport(instance)
+ const response = await connection.handleRequest(request(initialize))
+ expect(response.status).toBe(200)
+ const id = response.headers.get('mcp-session-id')
+ if (!id) throw new Error('Missing session id')
+ return { connection, id }
+}
+
+describe('MCP session lifecycle', () => {
+ test('registration and SDK connection failures release reservations and close resources', async () => {
+ const close = spyOn(McpServer.prototype, 'close')
+ const connect = spyOn(McpServer.prototype, 'connect')
+ try {
+ const broken = manager({
+ registerTools: () => {
+ throw new Error('registration failed')
+ }
+ })
+ for (let i = 0; i < 12; i++) {
+ const result = await broken.resolveTransport(undefined).catch((error: unknown) => error)
+ expect(result).toEqual(new Error('registration failed'))
+ }
+ expect(close).toHaveBeenCalledTimes(12)
+ const instance = manager()
+ connect.mockRejectedValueOnce(new Error('connect failed'))
+ const result = await instance.resolveTransport(undefined).catch((error: unknown) => error)
+ expect(result).toEqual(new Error('connect failed'))
+ expect(close).toHaveBeenCalledTimes(13)
+ await initialized(instance)
+ } finally {
+ connect.mockRestore()
+ close.mockRestore()
+ }
+ })
+
+ test('shutdown during SDK connection closes the allocation without publishing a session', async () => {
+ const release = deferred<undefined>()
+ const connect = spyOn(McpServer.prototype, 'connect').mockImplementationOnce(async () => {
+ await release.promise
+ })
+ try {
+ const instance = manager()
+ const creating = instance.resolveTransport(undefined)
+ const closing = instance.clear()
+ release.resolve(undefined)
+ expect(await creating).toEqual({ error: 'closed' })
+ await closing
+ expect(await instance.resolveTransport(undefined)).toEqual({ error: 'closed' })
+ } finally {
+ release.resolve(undefined)
+ connect.mockRestore()
+ }
+ })
+ test('rejected requests do not consume session slots', async () => {
+ const instance = manager()
+ for (let i = 0; i < 12; i++) {
+ const connection = await transport(instance)
+ const response = await connection.handleRequest(
+ new Request('http://localhost/mcp', {
+ headers: { accept: 'text/event-stream' }
+ })
+ )
+ expect(response.status).toBe(400)
+ }
+ await initialized(instance)
+ })
+
+ test('JSON-RPC initialization errors release their allocated session', async () => {
+ const ended: string[] = []
+ const instance = manager({
+ onSessionClosed: (id) => {
+ ended.push(id)
+ }
+ })
+ for (let i = 0; i < 12; i++) {
+ const connection = await transport(instance)
+ await connection.handleRequest(request({ ...initialize, params: { protocolVersion: 42 } }))
+ }
+ expect(ended).toHaveLength(0)
+ await initialized(instance)
+ })
+
+ test('concurrent initializations respect capacity and DELETE permits repeated reconnects', async () => {
+ const instance = manager()
+ const results = await Promise.all(
+ Array.from({ length: 12 }, () => instance.resolveTransport(undefined))
+ )
+ const connections = results.filter((result): result is MCPTransport => !('error' in result))
+ expect(connections).toHaveLength(10)
+ expect(results.filter((result) => 'error' in result)).toHaveLength(2)
+ for (const connection of connections) {
+ const response = await connection.handleRequest(request(initialize))
+ const id = response.headers.get('mcp-session-id')
+ if (!id) throw new Error('Missing session id')
+ await instance.deleteSession(id)
+ }
+ for (let i = 0; i < 12; i++) {
+ const { id } = await initialized(instance)
+ await instance.deleteSession(id)
+ expect(instance.getExistingTransport(id)).toEqual({ error: 'not_found' })
+ }
+ })
+
+ test('counts resources still closing until cleanup completes', async () => {
+ const instance = manager()
+ const connections = await Promise.all(Array.from({ length: 10 }, () => initialized(instance)))
+ const first = connections[0]
+ if (!first) throw new Error('Missing session')
+ const release = deferred<undefined>()
+ const originalClose = first.connection.close
+ const close = spyOn(first.connection, 'close').mockImplementationOnce(async () => {
+ await release.promise
+ await originalClose()
+ })
+ try {
+ const closing = instance.deleteSession(first.id)
+ expect(await instance.resolveTransport(undefined)).toEqual({ error: 'too_many' })
+ release.resolve(undefined)
+ await closing
+ await initialized(instance)
+ } finally {
+ release.resolve(undefined)
+ close.mockRestore()
+ }
+ })
+})
+
+function deferred<T>() {
+ let resolve: (value: T) => void = () => undefined
+ const promise = new Promise<T>((done) => {
+ resolve = done
+ })
+ return { promise, resolve }
+}
+
+describe('MCP idle expiration', () => {
+ test('completed cancelled tools do not pin sessions or send a JSON-RPC response', async () => {
+ const started = deferred<undefined>()
+ const finish = deferred<undefined>()
+ const instance = manager({
+ sessionIdleTimeoutMs: 1000,
+ registerTools: (server, agentSession, onToolSettled) =>
+ registerTools(server, {
+ policy: { allowEval: false, disabledTools: [], scope: 'document' },
+ agentSession,
+ onToolSettled,
+ sendRPC: async () => {
+ started.resolve(undefined)
+ await finish.promise
+ return { ok: true, result: { id: 'page', name: 'Page' } }
+ }
+ })
+ })
+ const { connection, id } = await initialized(instance)
+ const pending = connection.handleRequest(
+ request(
+ {
+ jsonrpc: '2.0',
+ id: 2,
+ method: 'tools/call',
+ params: { name: 'get_current_page', arguments: {} }
+ },
+ id
+ )
+ )
+ await started.promise
+ try {
+ const cancelled = await connection.handleRequest(
+ request(
+ {
+ jsonrpc: '2.0',
+ method: 'notifications/cancelled',
+ params: { requestId: 2 }
+ },
+ id
+ )
+ )
+ expect(cancelled.status).toBe(202)
+ const clockWhileRunning = spyOn(Date, 'now').mockReturnValue(Date.now() + 10_000)
+ try {
+ expect(instance.getExistingTransport(id)).toBe(connection)
+ } finally {
+ clockWhileRunning.mockRestore()
+ }
+ finish.resolve(undefined)
+ const response = await pending
+ expect(response.status).toBe(202)
+ expect(await response.text()).toBe('')
+ const ping = await connection.handleRequest(
+ request({ jsonrpc: '2.0', id: 3, method: 'ping' }, id)
+ )
+ expect(ping.status).toBe(200)
+ const clock = spyOn(Date, 'now').mockReturnValue(Date.now() + 1001)
+ try {
+ expect(instance.getExistingTransport(id)).toEqual({ error: 'not_found' })
+ } finally {
+ clock.mockRestore()
+ }
+ } finally {
+ finish.resolve(undefined)
+ await instance.clear()
+ await pending
+ }
+ })
+
+ test.each(['DELETE', 'shutdown'])(
+ '%s closes pending HTTP requests and aborts SDK handlers',
+ async (action) => {
+ const started = deferred<AbortSignal>()
+ const finish = deferred<undefined>()
+ const instance = manager({
+ registerTools: (server) => {
+ server.registerTool('wait', {}, async (context) => {
+ started.resolve(context.mcpReq.signal)
+ await finish.promise
+ return { content: [] }
+ })
+ }
+ })
+ const { connection, id } = await initialized(instance)
+ const pending = connection.handleRequest(
+ request(
+ {
+ jsonrpc: '2.0',
+ id: 2,
+ method: 'tools/call',
+ params: { name: 'wait', arguments: {} }
+ },
+ id
+ )
+ )
+ const signal = await started.promise
+ try {
+ if (action === 'DELETE') {
+ const response = await connection.handleRequest(
+ new Request('http://localhost/mcp', {
+ method: 'DELETE',
+ headers: { 'mcp-session-id': id }
+ })
+ )
+ expect(response.status).toBe(200)
+ await instance.deleteSession(id)
+ } else {
+ await instance.clear()
+ }
+ expect(signal.aborted).toBe(true)
+ expect((await pending).status).toBe(404)
+ } finally {
+ finish.resolve(undefined)
+ }
+ }
+ )
+
+ test('reclaims abandoned sessions in the background without another allocation', async () => {
+ const ended = deferred<string>()
+ const instance = manager({ sessionIdleTimeoutMs: 20, onSessionClosed: ended.resolve })
+ const { id } = await initialized(instance)
+ const clock = spyOn(Date, 'now').mockReturnValue(Date.now() + 100)
+ try {
+ expect(await ended.promise).toBe(id)
+ expect(instance.getExistingTransport(id)).toEqual({ error: 'not_found' })
+ await initialized(instance)
+ } finally {
+ clock.mockRestore()
+ }
+ })
+
+ test('expires an existing ID before touching it, and permits disabling expiration', async () => {
+ const instance = manager({ sessionIdleTimeoutMs: 20 })
+ const persistent = manager({ sessionIdleTimeoutMs: 0 })
+ const expired = await initialized(instance)
+ const retained = await initialized(persistent)
+ const clock = spyOn(Date, 'now').mockReturnValue(Date.now() + 1_000_000)
+ try {
+ expect(instance.getExistingTransport(expired.id)).toEqual({ error: 'not_found' })
+ expect(persistent.getExistingTransport(retained.id)).toBe(retained.connection)
+ } finally {
+ clock.mockRestore()
+ }
+ })
+
+ test('protects a pending tool call and starts its idle lifetime at completion', async () => {
+ const started = deferred<undefined>()
+ const finish = deferred<undefined>()
+ const instance = manager({
+ sessionIdleTimeoutMs: 1000,
+ registerTools: (server) => {
+ server.registerTool('wait', {}, async () => {
+ started.resolve(undefined)
+ await finish.promise
+ return { content: [] }
+ })
+ }
+ })
+ const { connection, id } = await initialized(instance)
+ const disconnect = new AbortController()
+ const response = connection.handleRequest(
+ new Request(
+ request(
+ {
+ jsonrpc: '2.0',
+ id: 2,
+ method: 'tools/call',
+ params: { name: 'wait', arguments: {} }
+ },
+ id
+ ),
+ { signal: disconnect.signal }
+ )
+ )
+ await started.promise
+ disconnect.abort()
+ const future = Date.now() + 10_000
+ const clock = spyOn(Date, 'now').mockReturnValue(future)
+ try {
+ expect(instance.getExistingTransport(id)).toBe(connection)
+ finish.resolve(undefined)
+ expect((await response).status).toBe(200)
+ clock.mockReturnValue(future + 999)
+ expect(instance.getExistingTransport(id)).toBe(connection)
+ clock.mockReturnValue(future + 1000)
+ expect(instance.getExistingTransport(id)).toEqual({ error: 'not_found' })
+ } finally {
+ finish.resolve(undefined)
+ clock.mockRestore()
+ }
+ })
+
+ test('SSE disconnection preserves the session, while idle expiration closes its stream', async () => {
+ const instance = manager({ sessionIdleTimeoutMs: 1000 })
+ const { connection, id } = await initialized(instance)
+ const get = () =>
+ connection.handleRequest(
+ new Request('http://localhost/mcp', {
+ headers: { accept: 'text/event-stream', 'mcp-session-id': id }
+ })
+ )
+ const first = await get()
+ await first.body?.cancel()
+ expect(instance.getExistingTransport(id)).toBe(connection)
+ const ping = await connection.handleRequest(
+ request({ jsonrpc: '2.0', id: 2, method: 'ping' }, id)
+ )
+ expect(ping.status).toBe(200)
+ const second = await get()
+ const reader = second.body?.getReader()
+ if (!reader) throw new Error('Missing SSE stream')
+ const clock = spyOn(Date, 'now').mockReturnValue(Date.now() + 1000)
+ try {
+ expect(instance.getExistingTransport(id)).toEqual({ error: 'not_found' })
+ expect((await reader.read()).done).toBe(true)
+ } finally {
+ clock.mockRestore()
+ await reader.cancel()
+ }
+ })
+
+ test('DELETE closes SSE and notifies once before capacity is reused', async () => {
+ const closed: string[] = []
+ const instance = manager({
+ onSessionClosed: (id) => {
+ closed.push(id)
+ }
+ })
+ const { connection, id } = await initialized(instance)
+ const sse = await connection.handleRequest(
+ new Request('http://localhost/mcp', {
+ headers: { accept: 'text/event-stream', 'mcp-session-id': id }
+ })
+ )
+ const response = await connection.handleRequest(
+ new Request('http://localhost/mcp', {
+ method: 'DELETE',
+ headers: { 'mcp-session-id': id }
+ })
+ )
+ await instance.deleteSession(id)
+ expect(response.status).toBe(200)
+ expect(closed).toEqual([id])
+ expect(instance.getExistingTransport(id)).toEqual({ error: 'not_found' })
+ expect((await sse.body?.getReader().read())?.done).toBe(true)
+ await initialized(instance)
+ await instance.clear()
+ expect(closed.filter((value) => value === id)).toHaveLength(1)
+ })
+})
diff --git a/tests/engine/mcp/server/index.test.ts b/tests/engine/mcp/server/index.test.ts
index 5c9fab48a..a85fc2c15 100644
--- a/tests/engine/mcp/server/index.test.ts
+++ b/tests/engine/mcp/server/index.test.ts
@@ -144,6 +144,12 @@ describe('startServer option validation', () => {
'appWaitTimeoutMs must be a safe integer'
)
})
+
+ test('rejects an invalid session idle timeout', async () => {
+ for (const sessionIdleTimeoutMs of [-1, Number.NaN, Infinity, 1.5, 2_147_483_648]) {
+ await expect(startServer({ sessionIdleTimeoutMs })).rejects.toThrow(RangeError)
+ }
+ })
})
describe('MCP server', () => {
diff --git a/tests/engine/mcp/server/transport.test.ts b/tests/engine/mcp/server/transport.test.ts
index f4ed0b55f..fafee0499 100644
--- a/tests/engine/mcp/server/transport.test.ts
+++ b/tests/engine/mcp/server/transport.test.ts
@@ -158,6 +158,83 @@ describe('MCP server unified transport', () => {
// ---------------------------------------------------------------------------
describe('MCP Streamable HTTP transport', () => {
+ test('failed requests cannot exhaust sessions, while valid concurrent sessions retain the cap', async () => {
+ const handle = await startServer({
+ httpPort: 0,
+ withTcp: true,
+ socketPath: testSocketPath(),
+ authToken: TEST_AUTH_TOKEN,
+ mcpRoot: null
+ })
+ const url = `http://127.0.0.1:${handle.httpPort}/mcp`
+ const headers = {
+ Authorization: `Bearer ${TEST_AUTH_TOKEN}`,
+ accept: 'application/json, text/event-stream',
+ 'content-type': 'application/json'
+ }
+ const init = {
+ jsonrpc: '2.0',
+ id: 1,
+ method: 'initialize',
+ params: {
+ protocolVersion: '2025-06-18',
+ capabilities: {},
+ clientInfo: { name: 'session-regression', version: '1' }
+ }
+ }
+ try {
+ for (let i = 0; i < 12; i++) {
+ for (const method of ['PUT', 'PATCH', 'HEAD']) {
+ const response = await fetch(url, { method, headers })
+ expect(response.status).toBe(405)
+ expect(response.headers.get('allow')).toBe('GET, POST, DELETE')
+ await response.text()
+ }
+ expect((await fetch(url, { headers })).status).toBe(400)
+ for (const body of [
+ '{invalid',
+ JSON.stringify({ jsonrpc: '2.0', id: 1, method: 'ping' }),
+ JSON.stringify({ ...init, params: { protocolVersion: 42 } })
+ ]) {
+ const response = await fetch(url, { method: 'POST', headers, body })
+ expect([200, 400]).toContain(response.status)
+ await response.text()
+ }
+ }
+ const responses = await Promise.all(
+ Array.from({ length: 12 }, () =>
+ fetch(url, {
+ method: 'POST',
+ headers,
+ body: JSON.stringify(init)
+ })
+ )
+ )
+ expect(responses.filter((response) => response.status === 200)).toHaveLength(10)
+ const rejected = responses.filter((response) => response.status === 503)
+ expect(rejected).toHaveLength(2)
+ expect(rejected[0]?.headers.get('retry-after')).toBe('5')
+ // A probe without an ID still cannot allocate, even at capacity.
+ expect((await fetch(url, { headers })).status).toBe(400)
+ expect((await fetch(url, { method: 'PUT', headers })).status).toBe(405)
+ for (const response of responses) {
+ const sessionId = response.headers.get('mcp-session-id')
+ await response.text()
+ if (!sessionId) continue
+ const deleted = await fetch(url, {
+ method: 'DELETE',
+ headers: { ...headers, 'Mcp-Session-Id': sessionId }
+ })
+ expect(deleted.status).toBe(200)
+ }
+ const reconnected = await fetch(url, { method: 'POST', headers, body: JSON.stringify(init) })
+ expect(reconnected.status).toBe(200)
+ await reconnected.text()
+ } finally {
+ await handle.close()
+ }
+ })
+
test('returns JSON responses for request/response calls', async () => {
if (isUnix) await mkdir(SOCKET_DIR, { recursive: true })
const handle = await startServer({
diff --git a/tools/checks/architecture/src/steiger-rules/support.ts b/tools/checks/architecture/src/steiger-rules/support.ts
index 2435d0afa..84c4adf6e 100644
--- a/tools/checks/architecture/src/steiger-rules/support.ts
+++ b/tools/checks/architecture/src/steiger-rules/support.ts
@@ -66,7 +66,7 @@ export const PACKAGE_ALIAS_OWNERS: Record<string, string> = {
'#dom-css-tests/': 'packages/dom-css/tests/',
'#vue/': 'packages/vue/',
'#cli/': 'packages/cli/',
- '#mcp/': 'packages/mcp/src/',
+ '#mcp/': 'packages/mcp/',
'#feedback/': 'packages/feedback/',
'#feedback-tests/': 'packages/feedback/tests/',
'#cloud/': 'packages/cloud/',