From 88cc1e71af6f294f8f9b7ecce77730a5b58c060b Mon Sep 17 00:00:00 2001 From: Filip <34747899+neriousy@users.noreply.github.com> Date: Wed, 4 Nov 2026 23:09:45 +0100 Subject: [PATCH] fix(core): finish MCP connect and disconnect when the caller is interrupted (#61806) --- packages/core/src/mcp/index.ts | 48 ++++++++++++++++++------ packages/core/test/mcp.test.ts | 68 ++++++++++++++++++++++++++++++++++ 2 files changed, 104 insertions(+), 12 deletions(-) diff --git a/packages/core/src/mcp/index.ts b/packages/core/src/mcp/index.ts index 8be4f0e8e69..fff6b726f40 100644 --- a/packages/core/src/mcp/index.ts +++ b/packages/core/src/mcp/index.ts @@ -7,7 +7,21 @@ import type { Session } from "@opencode/schema/session" import type { Transport } from "@modelcontextprotocol/client" import { createHash } from "node:crypto" import { isDeepStrictEqual } from "node:util" -import { Clock, Context, Effect, Exit, FiberSet, Latch, Layer, Schema, Scope, Semaphore, Stream, Types } from "effect" +import { + Clock, + Context, + Effect, + Exit, + Fiber, + FiberSet, + Latch, + Layer, + Schema, + Scope, + Semaphore, + Stream, + Types, +} from "effect" import { FetchHttpClient } from "effect/http" import { makeLocationNode } from "@opencode/util/effect/app-node" import { httpFetch } from "@opencode/util/effect/app-node-platform" @@ -208,6 +222,12 @@ export const layer = (options?: Options) => // Serializes lifecycle operations per server. Anything taking this lock from a connection // callback must stay forked: lifecycle operations close scopes while holding it, firing onClose. const locks = KeyedMutex.makeUnsafe() + // Runs a requested lifecycle operation to the end even if its caller is interrupted, such as by a + // client dropping the HTTP request. Stopped halfway, a server stays "pending" after a cancelled + // connect, or "connected" with no connection after a cancelled disconnect. Location shutdown + // still interrupts it. + const transition = (effect: Effect.Effect) => + Effect.forkIn(effect, root, { startImmediately: true }).pipe(Effect.flatMap(Fiber.join)) // Attached connections lock separately so a configured server of the same name never contends. const attachedLocks = KeyedMutex.makeUnsafe() // Legacy era only: pending URL-mode elicitation forms, settled by notifications/elicitation/complete. @@ -701,20 +721,24 @@ export const layer = (options?: Options) => }), connect: Effect.fn("MCP.connect")(function* (server) { const name = ServerName.make(server) - yield* Effect.gen(function* () { - const entry = yield* requireServer(name) - yield* entry.connection.stop - yield* entry.connection.start - }).pipe(locks.withLock(name)) + yield* transition( + Effect.gen(function* () { + const entry = yield* requireServer(name) + yield* entry.connection.stop + yield* entry.connection.start + }).pipe(locks.withLock(name)), + ) }), disconnect: Effect.fn("MCP.disconnect")(function* (server) { const name = ServerName.make(server) - yield* Effect.gen(function* () { - const entry = yield* requireServer(name) - yield* entry.connection.stop - entry.status = { status: "disabled" } - yield* bus.publish(McpEvent.StatusChanged, { server: name }) - }).pipe(locks.withLock(name)) + yield* transition( + Effect.gen(function* () { + const entry = yield* requireServer(name) + yield* entry.connection.stop + entry.status = { status: "disabled" } + yield* bus.publish(McpEvent.StatusChanged, { server: name }) + }).pipe(locks.withLock(name)), + ) }), remove: Effect.fn("MCP.remove")(function* (server) { const name = ServerName.make(server) diff --git a/packages/core/test/mcp.test.ts b/packages/core/test/mcp.test.ts index bc9a74d6f69..2d6044a7f0c 100644 --- a/packages/core/test/mcp.test.ts +++ b/packages/core/test/mcp.test.ts @@ -2406,6 +2406,74 @@ test("serializes concurrent MCP lifecycle operations", async () => { ) }) +const awaitStatus = (service: Mcp.Interface, status: Mcp.Status["status"]) => + service.servers().pipe( + Effect.map((servers) => servers.find((server) => server.name === "resources")?.status), + Effect.filterOrFail( + (current) => current?.status === status, + (current) => new Error(`MCP server status is ${JSON.stringify(current)}, expected ${status}`), + ), + Effect.retry({ schedule: Schedule.spaced("10 millis") }), + Effect.timeout("5 seconds"), + ) + +testEffect(Layer.empty).live("finishes an MCP connect whose caller is interrupted during the handshake", () => + Effect.gen(function* () { + const started = yield* Deferred.make() + const release = yield* Deferred.make() + const server = yield* resourceServer({ + respond: async (request) => { + if (request.method !== "POST") return undefined + const body: unknown = await request.clone().json() + if (typeof body !== "object" || body === null || !("method" in body) || body.method !== "initialize") + return undefined + await Effect.runPromise(Deferred.succeed(started, undefined).pipe(Effect.andThen(Deferred.await(release)))) + return undefined + }, + }) + yield* Effect.gen(function* () { + const service = yield* Mcp.Service + const connecting = yield* service.connect("resources").pipe(Effect.forkChild({ startImmediately: true })) + yield* Deferred.await(started) + yield* Fiber.interrupt(connecting) + yield* Deferred.succeed(release, undefined) + + yield* awaitStatus(service, "connected") + expect((yield* service.tools()).length).toBeGreaterThan(0) + }).pipe( + Effect.ensuring(Deferred.succeed(release, undefined)), + Effect.provide( + resourceMcpLayer(new ConfigMCP.Remote({ type: "remote", url: server.url, oauth: false, disabled: true })), + ), + ) + }), +) + +testEffect(Layer.empty).live("finishes an MCP disconnect whose caller is interrupted while the session ends", () => + Effect.gen(function* () { + const started = yield* Deferred.make() + const release = yield* Deferred.make() + const server = yield* resourceServer({ + respond: async (request) => { + if (request.method !== "DELETE") return undefined + await Effect.runPromise(Deferred.succeed(started, undefined).pipe(Effect.andThen(Deferred.await(release)))) + return undefined + }, + }) + yield* Effect.gen(function* () { + const service = yield* Mcp.Service + expect(yield* settled(service)).toEqual({ status: "connected" }) + const disconnecting = yield* service.disconnect("resources").pipe(Effect.forkChild({ startImmediately: true })) + yield* Deferred.await(started) + yield* Fiber.interrupt(disconnecting) + yield* Deferred.succeed(release, undefined) + + yield* awaitStatus(service, "disabled") + expect(yield* service.tools()).toEqual([]) + }).pipe(Effect.ensuring(Deferred.succeed(release, undefined)), Effect.provide(resourceMcpLayer(server.url))) + }), +) + testEffect(Layer.empty).live("preserves plugin transforms through MCP catalog updates", () => Effect.gen(function* () { const tool = (server: string, name: string, description = name) =>