lael-labs/executor

bun.lock+12−0

         "@effect/platform-node": "catalog:",
         "@executor-js/config": "workspace:*",
         "@executor-js/sdk": "workspace:*",
+        "@modelcontextprotocol/client": "2.0.0",
+        "@modelcontextprotocol/core": "2.0.0",
         "@modelcontextprotocol/sdk": "^1.29.0",
         "zod": "4.3.6",
       },
     "@mishieck/ink-titled-box": ["@mishieck/ink-titled-box@0.3.0", "", { "peerDependencies": { "ink": "^6.0.0", "react": "^19.1.0", "typescript": "^5" } }, "sha512-ugzVH9hixp3hwKfQ8On/qnsrdAxS3y9rTu/aGOFed4zVUvtZyGZNIR4rxAwXult8HKI4vJEh0OM8wib9NPrwUg=="],
+    "@modelcontextprotocol/client": ["@modelcontextprotocol/client@2.0.0", "", { "dependencies": { "@modelcontextprotocol/core": "2.0.0", "cross-spawn": "^7.0.5", "eventsource": "^3.0.2", "eventsource-parser": "^3.0.0", "jose": "^6.1.3", "pkce-challenge": "^5.0.0", "zod": "^4.2.0" } }, "sha512-8f1OghQ2rjzIOfqgUCP+8GiUWqRs89njoWLNqAe8kWmDePv3s1fZXseej+QXemssEuuOvLLmLO/kqM3IQHtISw=="],
+    "@modelcontextprotocol/core": ["@modelcontextprotocol/core@2.0.0", "", { "dependencies": { "zod": "^4.2.0" } }, "sha512-pJCEwGG7Lfr/+PQp9ZTwKXNeO5wzbfKL7H3MYpCorM4oFBoQrdjnBgEoqG+RjhsvS1FKrDbKux+M1HhlnGWqcA=="],
     "@modelcontextprotocol/ext-apps": ["@modelcontextprotocol/ext-apps@1.7.5", "", { "dependencies": { "@standard-schema/spec": "^1.1.0" }, "peerDependencies": { "@modelcontextprotocol/sdk": "^1.29.0", "react": "^17.0.0 || ^18.0.0 || ^19.0.0", "react-dom": "^17.0.0 || ^18.0.0 || ^19.0.0", "zod": "^3.25.0 || ^4.0.0" }, "optionalPeers": ["react", "react-dom"] }, "sha512-TjPH2S2y5UEGKhmI6+XGFuqfqOV4ppe1x6DA3txnUaEWkgtA4G5vo14jGKFZmegdkZ1H4QMLyujLvoU1BEdnAg=="],
     "@modelcontextprotocol/sdk": ["@modelcontextprotocol/sdk@1.29.0", "", { "dependencies": { "@hono/node-server": "^1.19.9", "ajv": "^8.17.1", "ajv-formats": "^3.0.1", "content-type": "^1.0.5", "cors": "^2.8.5", "cross-spawn": "^7.0.5", "eventsource": "^3.0.2", "eventsource-parser": "^3.0.0", "express": "^5.2.1", "express-rate-limit": "^8.2.1", "hono": "^4.11.4", "jose": "^6.1.3", "json-schema-typed": "^8.0.2", "pkce-challenge": "^5.0.0", "raw-body": "^3.0.0", "zod": "^3.25 || ^4.0", "zod-to-json-schema": "^3.25.1" }, "peerDependencies": { "@cfworker/json-schema": "^4.1.1" }, "optionalPeers": ["@cfworker/json-schema"] }, "sha512-zo37mZA9hJWpULgkRpowewez1y6ML5GsXJPY8FI0tBBCd77HEvza4jDqRKOXgHNn867PVGCyTdzqpz0izu5ZjQ=="],
     "@manypkg/get-packages/fs-extra": ["fs-extra@8.1.0", "", { "dependencies": { "graceful-fs": "^4.2.0", "jsonfile": "^4.0.0", "universalify": "^0.1.0" } }, "sha512-yhlQgA6mnOJUKOsRUFsgJdQCvkKhcz8tlZG5HBQfReYZy46OwLcY+Zia0mtdHsOo9y/hP+CxMN0TU9QxoOtG4g=="],
+    "@modelcontextprotocol/client/jose": ["jose@6.2.2", "", {}, "sha512-d7kPDd34KO/YnzaDOlikGpOurfF0ByC2sEV4cANCtdqLlTfBlw2p14O/5d/zv40gJPbIQxfES3nSx1/oYNyuZQ=="],
+    "@modelcontextprotocol/client/zod": ["zod@4.4.3", "", {}, "sha512-ytENFjIJFl2UwYglde2jchW2Hwm4GJFLDiSXWdTrJQBIN9Fcyp7n4DhxJEiWNAJMV1/BqWfW/kkg71UDcHJyTQ=="],
+    "@modelcontextprotocol/core/zod": ["zod@4.4.3", "", {}, "sha512-ytENFjIJFl2UwYglde2jchW2Hwm4GJFLDiSXWdTrJQBIN9Fcyp7n4DhxJEiWNAJMV1/BqWfW/kkg71UDcHJyTQ=="],
     "@modelcontextprotocol/sdk/jose": ["jose@6.2.2", "", {}, "sha512-d7kPDd34KO/YnzaDOlikGpOurfF0ByC2sEV4cANCtdqLlTfBlw2p14O/5d/zv40gJPbIQxfES3nSx1/oYNyuZQ=="],
     "@octokit/request/content-type": ["content-type@2.0.0", "", {}, "sha512-j/O/d7GcZCyNl7/hwZAb606rzqkyvaDctLmckbxLzHvFBzTJHuGEdodATcP3yIRoDrLHkIATJuvzbFlp/ki2cQ=="],

packages/plugins/mcp/package.json+2−0

     "@effect/platform-node": "catalog:",
     "@executor-js/config": "workspace:*",
     "@executor-js/sdk": "workspace:*",
+    "@modelcontextprotocol/client": "2.0.0",
+    "@modelcontextprotocol/core": "2.0.0",
     "@modelcontextprotocol/sdk": "^1.29.0",
     "zod": "4.3.6"
   },

packages/plugins/mcp/src/sdk/catalog-sync.test.ts+8−0

 const jsonRpcResult = (request: JsonRpcRequest, result: unknown) =>
   HttpServerResponse.jsonUnsafe({ jsonrpc: "2.0", id: request.id ?? null, result });
+const jsonRpcMethodNotFound = (request: JsonRpcRequest) =>
+  HttpServerResponse.jsonUnsafe({
+    jsonrpc: "2.0",
+    id: request.id ?? null,
+    error: { code: -32601, message: "Method not found" },
+  });
 const pageTool = (name: string) => ({
   name,
   description: `Tool ${name}`,
       return Option.match(decodeJsonRpcRequest(body), {
         onNone: () => HttpServerResponse.text("Invalid JSON-RPC fixture request", { status: 400 }),
         onSome: (rpc) => {
+          if (rpc.method === "server/discover") return jsonRpcMethodNotFound(rpc);
           if (rpc.method === "initialize") {
             return jsonRpcResult(rpc, {
               protocolVersion: "2025-06-18",

packages/plugins/mcp/src/sdk/connection-pool.test.ts+10−6

 import { invokeMcpTool } from "./invoke";
 import { makeEchoMcpServer, serveMcpServer } from "../testing";
+// The public v1 fixture creates one throwaway transport for v2's rejected
+// server/discover probe, then one initialized legacy session per real dial.
+const V1_FIXTURE_TRANSPORTS_PER_DIAL = 2;
 const acceptAll: Elicit = () =>
   Effect.succeed(ElicitationResponse.make({ action: "accept", content: { approved: true } }));
         expect(first).toMatchObject({ content: [{ type: "text", text: "first" }] });
         expect(second).toMatchObject({ content: [{ type: "text", text: "second" }] });
-        expect(server.sessionCount()).toBe(1);
+        expect(server.sessionCount()).toBe(V1_FIXTURE_TRANSPORTS_PER_DIAL);
         yield* pool.close();
       }),
     ),
           expect.objectContaining({ content: [{ type: "text", text: "left" }] }),
           expect.objectContaining({ content: [{ type: "text", text: "right" }] }),
         ]);
-        expect(server.sessionCount()).toBe(2);
+        expect(server.sessionCount()).toBe(2 * V1_FIXTURE_TRANSPORTS_PER_DIAL);
         yield* pool.close();
       }),
     ),
         });
         expect(after).toMatchObject({ content: [{ type: "text", text: "after" }] });
-        expect(server.sessionCount()).toBe(2);
+        expect(server.sessionCount()).toBe(2 * V1_FIXTURE_TRANSPORTS_PER_DIAL);
         yield* pool.close();
       }),
     ),
         });
         expect(after).toMatchObject({ content: [{ type: "text", text: "after" }] });
-        expect(server.sessionCount()).toBe(2);
+        expect(server.sessionCount()).toBe(2 * V1_FIXTURE_TRANSPORTS_PER_DIAL);
         yield* pool.close();
       }),
     ),
         });
         expect(after).toMatchObject({ content: [{ type: "text", text: "after" }] });
-        // A second session was dialled rather than the dead one being reused.
+        // A second connection was dialled rather than the dead one being reused.
-        expect(server.sessionCount()).toBe(2);
+        expect(server.sessionCount()).toBe(2 * V1_FIXTURE_TRANSPORTS_PER_DIAL);
         yield* pool.close();
       }),
     ),

packages/plugins/mcp/src/sdk/connection-pool.ts+4−0

@@ -3,6 +3,10 @@ import { Cause, Effect, Exit, Predicate } from "effect"; · 2 unmodified lines
3	import type { McpConnection, McpConnector } from "./connection";	3	import type { McpConnection, McpConnector } from "./connection";
4	import type { McpInvocationError } from "./errors";	4	import type { McpInvocationError } from "./errors";
5		5
		6	// The pool preserves sessions for sessionful legacy servers. Stateless
		7	// 2026-07-28 servers do not need it, but retaining a cheap idle client is
		8	// harmless and keeps one lifecycle for both protocol eras.
		9
6	const IDLE_TTL_MS = 5 * 60 * 1_000;	10	const IDLE_TTL_MS = 5 * 60 * 1_000;
7		11
8	type IdleConnection = {	12	type IdleConnection = {

packages/plugins/mcp/src/sdk/connection.ts+19−11

-import type { OAuthClientProvider } from "@modelcontextprotocol/sdk/client/auth.js";
+import {
-import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+  Client,
-import { SSEClientTransport } from "@modelcontextprotocol/sdk/client/sse.js";
+  SSEClientTransport,
-import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+  StreamableHTTPClientTransport,
-import type { FetchLike } from "@modelcontextprotocol/sdk/shared/transport.js";
+  type FetchLike,
-import { CfWorkerJsonSchemaValidator } from "@modelcontextprotocol/sdk/validation/cfworker";
+  type OAuthClientProvider,
+} from "@modelcontextprotocol/client";
+import { CfWorkerJsonSchemaValidator } from "@modelcontextprotocol/client/validators/cf-worker";
 import { Effect, Layer, Predicate, Stream } from "effect";
 import { HttpClient, HttpClientRequest } from "effect/unstable/http";
 // NOTE: `StdioClientTransport` is NOT imported eagerly. The upstream module
-// (`@modelcontextprotocol/sdk/client/stdio.js`) touches `node:child_process`
+// (`@modelcontextprotocol/client/stdio`) still imports Node process/stream and
-// at evaluation time, which crashes workerd (incl. vitest-pool-workers) at
+// `cross-spawn` eagerly at evaluation time, which crashes workerd (including
-// SIGSEGV on module instantiation. Cloud callers set
+// vitest-pool-workers) with SIGSEGV on module instantiation. Cloud callers set
 // `dangerouslyAllowStdioMCP: false` and never reach the stdio branch below;
 // prod bundles that DO use stdio load it via a dynamic import inside the
 // stdio branch of `createMcpConnector`.
 // MCP plugin runs inside a Cloudflare Worker (executor.sh). The
 // cfworker validator does not use code generation and works in every
 // runtime we ship to.
-const createClient = (): Client =>
+const createClient = (versionNegotiation?: { readonly mode: "auto" }): Client =>
   new Client(
     { name: "executor-mcp", version: "0.1.0" },
     {
       capabilities: { elicitation: { form: {}, url: {} } },
       jsonSchemaValidator: new CfWorkerJsonSchemaValidator(),
+      ...(versionNegotiation === undefined ? {} : { versionNegotiation }),
     },
   );
 const connectClient = (input: {
   transport: string;
   createTransport: () => Parameters<Client["connect"]>[0];
+  versionNegotiation?: { readonly mode: "auto" };
 }): Effect.Effect<McpConnection, McpConnectionError | McpOAuthReauthorizationRequired> =>
   Effect.gen(function* () {
-    const client = createClient();
+    const client = createClient(input.versionNegotiation);
     const transportInstance = input.createTransport();
     yield* Effect.tryPromise({
   const endpoint = buildEndpointUrl(input.endpoint, input.queryParams ?? {});
+  // Auto-negotiate the 2026-07-28 era only on Streamable HTTP. SSE is a
+  // legacy-only transport, and stdio servers are spawned per call where the
+  // SDK recommends retaining its legacy-default handshake.
   const connectStreamableHttp = connectClient({
     transport: "streamable-http",
+    versionNegotiation: { mode: "auto" },
     createTransport: () =>
       new StreamableHTTPClientTransport(endpoint, {
         requestInit,

packages/plugins/mcp/src/sdk/elicitation.test.ts+3−3

@@ -1,7 +1,7 @@
1	import { describe, expect, it } from "@effect/vitest";	1	import { describe, expect, it } from "@effect/vitest";
2	import { Effect, Predicate, Schema, Semaphore } from "effect";	2	import { Effect, Predicate, Schema, Semaphore } from "effect";
3	import { CfWorkerJsonSchemaValidator } from "@modelcontextprotocol/sdk/validation/cfworker";	3	import type { JsonSchemaType } from "@modelcontextprotocol/client";
4	import type { JsonSchemaType } from "@modelcontextprotocol/sdk/validation/types";	4	import { CfWorkerJsonSchemaValidator } from "@modelcontextprotocol/client/validators/cf-worker";
5		5
6	import {	6	import {
7	AuthTemplateSlug,	7	AuthTemplateSlug,
@@ -226,7 +226,7 @@ describe("MCP elicitation (end-to-end)", () => { · 218 unmodified lines
226	]),	226	]),
227	);	227	);
228	expect(schema?.outputTypeScript).toContain('type: "text"');	228	expect(schema?.outputTypeScript).toContain('type: "text"');
229	expect(schema?.outputTypeScript).toContain("structuredContent?: { [k: string]: unknown; }");	229	expect(schema?.outputTypeScript).toContain("structuredContent?: unknown;");
230		230
231	const result = yield* executor.execute(	231	const result = yield* executor.execute(
232	simpleEcho.address,	232	simpleEcho.address,

packages/plugins/mcp/src/sdk/http-status.test.ts+17−3

 import { describe, expect, it } from "@effect/vitest";
+import { InsufficientScopeError, SdkErrorCode, SdkHttpError } from "@modelcontextprotocol/client";
 // oxlint-disable executor/no-error-constructor -- boundary: these tests reproduce the MCP SDK's own transport rejections, which are built-in Errors
 import { insufficientScopeFromCause } from "./http-status";
 //   - with an authProvider (the production OAuth path): the StreamableHTTP
 //     transport consumes the insufficient_scope challenge itself, retries
 //     with the broader scope, and only when THAT fails throws the fixed
-//     "Server returned 403 after trying upscoping" message.
+//     typed `InsufficientScopeError`, or after retry exhaustion the fixed
+//     `SdkHttpError` step-up message.
 describe("insufficientScopeFromCause", () => {
   it("detects the OAuth error body embedded in a transport message", () => {
     expect(
     ).toBe(true);
   });
-  it("detects the SDK's exhausted-upscoping failure (the authProvider path)", () => {
+  it("detects the SDK's typed insufficient-scope failure", () => {
     expect(
-      insufficientScopeFromCause(new Error("Server returned 403 after trying upscoping")),
+      insufficientScopeFromCause(new InsufficientScopeError({ requiredScope: "files.read" })),
+    ).toBe(true);
+  });
+  it("detects the SDK's exhausted step-up failure (the authProvider path)", () => {
+    expect(
+      insufficientScopeFromCause(
+        new SdkHttpError(
+          SdkErrorCode.ClientHttpForbidden,
+          "Server returned 403 insufficient_scope after step-up re-authorization (retry limit 2 reached)",
+          { status: 403 },
+        ),
+      ),
     ).toBe(true);
   });

packages/plugins/mcp/src/sdk/http-status.ts+25−20

 // ---------------------------------------------------------------------------
 // Extract the HTTP status from an MCP SDK transport error. The SDK surfaces
-// transport failures two ways: a `StreamableHTTPError` subclass carrying a
+// transport failures two ways: an `SdkHttpError` carrying a numeric `status`,
-// numeric `code`, and an SSE POST failure whose message embeds `(HTTP nnn)`.
+// and an `SseError` carrying a numeric `code`. The SSE transport also retains
+// its historic POST-failure message for errors created below EventSource.
 // Shared by the invoke path (classifies tool-call failures) and the connect
 // path (so a 401/403 during the handshake reaches the liveness health check).
 // ---------------------------------------------------------------------------
 import { Option, Schema } from "effect";
 import { insufficientScopeFromEmbeddedJson } from "@executor-js/sdk/core";
-import { StreamableHTTPError } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+import { InsufficientScopeError, SdkHttpError, SseError } from "@modelcontextprotocol/client";
 const SsePostErrorCause = Schema.Struct({ message: Schema.String });
 const decodeSsePostErrorCause = Schema.decodeUnknownOption(SsePostErrorCause);
-// Matches the SDK's SSEClientTransport POST-failure message (sse.js); re-verify
+// V2 still constructs this exact message in SSEClientTransport._send. A format
-// on SDK bumps. A format drift just yields undefined (generic error, no crash).
+// drift just yields undefined (generic error, no crash).
 const statusFromSsePostError = (cause: unknown): number | undefined =>
   Option.match(decodeSsePostErrorCause(cause), {
     onNone: () => undefined,
     },
   });
-const statusFromStreamableHttpError = (cause: unknown): number | undefined => {
+const statusFromTypedTransportError = (cause: unknown): number | undefined => {
-  // oxlint-disable-next-line executor/no-instanceof-tagged-error -- boundary: MCP SDK exposes transport HTTP failures as this Error subclass; protocol errors can carry the same numeric code
+  if (SdkHttpError.isInstance(cause)) return cause.status;
-  if (!(cause instanceof StreamableHTTPError)) return undefined;
+  if (SseError.isInstance(cause)) {
-  const code = cause.code;
+    const code = cause.code;
-  return code !== undefined && code >= 100 && code <= 599 ? code : undefined;
+    return code !== undefined && code >= 100 && code <= 599 ? code : undefined;
+  }
+  return undefined;
 };
 export const httpStatusFromCause = (cause: unknown): number | undefined =>
-  statusFromStreamableHttpError(cause) ?? statusFromSsePostError(cause);
+  statusFromTypedTransportError(cause) ?? statusFromSsePostError(cause);
 // The SDK embeds the upstream response text in the transport error message
 // ("Error POSTing to endpoint: <body>"), which is the only place a 403's body
 // survives for connections without an authProvider. For OAuth connections the
-// StreamableHTTP transport consumes the insufficient_scope challenge ITSELF:
+// StreamableHTTP transport consumes the insufficient_scope challenge itself.
-// it re-runs auth requesting the broader scope, and only when that upscoped
+// V2 throws `InsufficientScopeError` when configured not to reauthorize; after
-// retry still 403s does it throw — with the fixed message matched below
+// exhausting its step-up retries it throws `SdkHttpError` with the exact fixed
-// (verified against @modelcontextprotocol/sdk streamableHttp.js; re-verify on
+// message matched below (verified against the installed v2 transport source).
-// SDK bumps). Both paths mean the same thing: the grant does not cover the
+// Both paths mean the same thing: the grant does not cover the operation, and
-// operation, and re-running the identical flow cannot help. Strict matching
+// re-running the identical flow cannot help. Strict matching
 // (exact serialized field forms via the shared core detector, or the SDK's
-// exact upscoping message) — a miss stays on the generic auth path.
+// exact step-up message) — a miss stays on the generic auth path.
-const SDK_UPSCOPING_EXHAUSTED_RE = /Server returned 403 after trying upscoping/;
+const SDK_STEP_UP_EXHAUSTED_RE =
+  /^Server returned 403 insufficient_scope after step-up re-authorization \(retry limit \d+ reached\)$/;
 export const insufficientScopeFromCause = (cause: unknown): boolean =>
+  InsufficientScopeError.isInstance(cause) ||
   Option.match(decodeSsePostErrorCause(cause), {
     onNone: () => false,
     onSome: ({ message }) =>
-      insufficientScopeFromEmbeddedJson(message) || SDK_UPSCOPING_EXHAUSTED_RE.test(message),
+      insufficientScopeFromEmbeddedJson(message) || SDK_STEP_UP_EXHAUSTED_RE.test(message),
   });

packages/plugins/mcp/src/sdk/invoke.test.ts+10−5

 import { Effect, Predicate } from "effect";
 import { HttpServerResponse } from "effect/unstable/http";
-import type { OAuthClientProvider } from "@modelcontextprotocol/sdk/client/auth.js";
+import {
-import { StreamableHTTPError } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+  ProtocolError,
-import { McpError } from "@modelcontextprotocol/sdk/types.js";
+  SdkErrorCode,
+  SdkHttpError,
+  type OAuthClientProvider,
+} from "@modelcontextprotocol/client";
 import { ElicitationResponse } from "@executor-js/sdk";
 import { serveTestHttpApp } from "@executor-js/sdk/testing";
     name: "wraps callTool rejection with a stable message and status",
     toolId: "blocked",
     transport: "streamable-http",
-    cause: new StreamableHTTPError(401, "token=do-not-leak"),
+    cause: new SdkHttpError(SdkErrorCode.ClientHttpAuthentication, "token=do-not-leak", {
+      status: 401,
+    }),
     expectedStatus: 401 as number | undefined,
   },
   {
     name: "does not treat MCP protocol error codes as HTTP statuses",
     toolId: "protocol_error",
     transport: "streamable-http",
-    cause: new McpError(401, "application-level do-not-leak"),
+    cause: new ProtocolError(401, "application-level do-not-leak"),
     expectedStatus: undefined,
   },
   {

packages/plugins/mcp/src/sdk/invoke.ts+24−15

 //      legitimately retain state in that session. The pool keeps one idle
 //      connection per resolved identity and leases it exclusively per invoke;
 //      stdio and callers without a pool remain strictly per-call.
-//   2. Installing a per-invocation `ElicitRequestSchema` handler that bridges
+//   2. Installing a per-invocation `elicitation/create` handler that bridges
 //      MCP's elicit capability into the host's elicit function threaded via
 //      `InvokeToolInput.elicit`.
 //   3. Calling `client.callTool({ name, arguments })`.
 import { Cause, Effect, Exit, Option, Predicate, Schema } from "effect";
-import {
+import { ProtocolError, ProtocolErrorCode } from "@modelcontextprotocol/client";
-  ElicitRequestSchema,
-  ErrorCode,
-  McpError,
-  ToolListChangedNotificationSchema,
-} from "@modelcontextprotocol/sdk/types.js";
 import {
   ElicitationId,
 const isUnknownToolCause = (cause: unknown, toolName: string): boolean =>
   // oxlint-disable-next-line executor/no-instanceof-tagged-error -- boundary: MCP SDK surfaces JSON-RPC protocol errors as this Error subclass
-  cause instanceof McpError &&
+  cause instanceof ProtocolError &&
-  (cause.code === ErrorCode.InvalidParams || cause.code === ErrorCode.MethodNotFound) &&
+  (cause.code === ProtocolErrorCode.InvalidParams ||
-  // oxlint-disable-next-line executor/no-unknown-error-message -- boundary: instanceof narrows to the SDK's McpError, whose message carries the only unknown-tool discriminator the protocol provides
+    cause.code === ProtocolErrorCode.MethodNotFound) &&
+  // oxlint-disable-next-line executor/no-unknown-error-message -- boundary: instanceof narrows to the SDK's ProtocolError, whose message carries the only unknown-tool discriminator the protocol provides
   isUnknownToolMessage(cause.message, toolName);
 // ---------------------------------------------------------------------------
 type McpElicitParams = typeof McpElicitParams.Type;
 const decodeElicitParams = Schema.decodeUnknownSync(McpElicitParams);
+const decodeElicitContent = Schema.decodeUnknownSync(
+  Schema.Record(
+    Schema.String,
+    Schema.Union([
+      Schema.String,
+      Schema.Number,
+      Schema.Boolean,
+      Schema.mutable(Schema.Array(Schema.String)),
+    ]),
+  ),
+);
 const toElicitationRequest = (params: McpElicitParams): ElicitationRequest =>
   params.mode === "url"
       });
 const installElicitationHandler = (client: McpConnection["client"], elicit: Elicit): void => {
-  client.setRequestHandler(ElicitRequestSchema, async (request: { params: unknown }) => {
+  client.setRequestHandler("elicitation/create", async (request: { params: unknown }) => {
     const params = decodeElicitParams(request.params);
     const req = toElicitationRequest(params);
     // Use runPromiseExit so we can inspect typed failures — `elicit`
       const response = exit.value;
       return {
         action: response.action,
-        ...(response.action === "accept" && response.content ? { content: response.content } : {}),
+        ...(response.action === "accept" && response.content
+          ? { content: decodeElicitContent(response.content) }
+          : {}),
       };
     }
     const failure = exit.cause.reasons.find(Cause.isFailReason);
   onToolListChanged: (() => void) | undefined,
 ): void => {
   if (!onToolListChanged) return;
-  client.setNotificationHandler(ToolListChangedNotificationSchema, () => {
+  client.setNotificationHandler("notifications/tools/list_changed", () => {
     onToolListChanged();
   });
 };
           });
         }
         const status = httpStatusFromCause(cause);
-        // oxlint-disable-next-line executor/no-instanceof-tagged-error -- boundary: MCP SDK protocol failures are its McpError subclass; transport failures use other error shapes
+        // oxlint-disable-next-line executor/no-instanceof-tagged-error -- boundary: MCP SDK protocol failures are its ProtocolError subclass; transport failures use other error shapes
-        const protocolFailure = cause instanceof McpError;
+        const protocolFailure = cause instanceof ProtocolError;
         return new McpInvocationError({
           toolName,
           message: `MCP tool call failed for ${toolName}`,

packages/plugins/mcp/src/sdk/plugin.test.ts+8−0

     result,
   });
+const jsonRpcMethodNotFound = (request: JsonRpcRequest) =>
+  HttpServerResponse.jsonUnsafe({
+    jsonrpc: "2.0",
+    id: request.id ?? null,
+    error: { code: -32601, message: "Method not found" },
+  });
 // The call-tool fixtures share one JSON-RPC scaffold (handshake, tool listing,
 // unknown-method rejection); only the `tools/call` response varies. Each
 // scenario supplies that branch via a `CallToolResponder`.
 type CallToolResponder = (rpc: JsonRpcRequest) => ReturnType<typeof HttpServerResponse.text>;
 const callToolFixtureResponse = (rpc: JsonRpcRequest, callTool: CallToolResponder) => {
+  if (rpc.method === "server/discover") return jsonRpcMethodNotFound(rpc);
   if (rpc.method === "initialize") {
     return jsonRpcResult(rpc, {
       protocolVersion: "2025-06-18",

packages/plugins/mcp/src/sdk/plugin.ts+6−5

 import { Effect, Layer, Option, Result, Schema } from "effect";
 import type { HttpClient } from "effect/unstable/http";
-import type { OAuthClientProvider } from "@modelcontextprotocol/sdk/client/auth.js";
+import type { OAuthClientProvider } from "@modelcontextprotocol/client";
-import { CallToolResultSchema } from "@modelcontextprotocol/sdk/types.js";
+import { CallToolResultSchema } from "@modelcontextprotocol/core";
-import * as z from "zod/v4";
 import {
   authToolFailure,
   readonly properties?: Record<string, unknown>;
 };
-const McpCallToolResultJsonSchema = z.toJSONSchema(CallToolResultSchema) as JsonSchemaObject;
+const McpCallToolResultJsonSchema: JsonSchemaObject = CallToolResultSchema.toJSONSchema();
 const mcpCallToolResultOutputSchema = (structuredContentSchema?: unknown): JsonSchemaObject => {
   const defaultStructuredContentSchema =
 // MCP-SDK OAuth provider adapter — wraps a pre-resolved access token so the
 // transport sends it as a Bearer header. Refresh is core's responsibility
 // (the connection row carries the OAuth grant); this adapter never initiates
-// a new flow and fails loudly if the SDK tries to.
+// a new flow and fails loudly if the SDK tries to. V2 stamps stored credentials
+// with the authorization-server issuer and offers scoped invalidation; this
+// single-token boundary intentionally persists neither.
 // ---------------------------------------------------------------------------
 const makeOAuthProvider = (accessToken: string): OAuthClientProvider => ({

packages/plugins/mcp/src/sdk/probe-shape.test.ts+93−2

@@ -1,6 +1,12 @@
1	import { describe, expect, it } from "@effect/vitest";	1	import { describe, expect, it } from "@effect/vitest";
2	import { Effect, Ref } from "effect";	2	import { Effect, Layer, Predicate, Ref } from "effect";
3	import { HttpServerResponse } from "effect/unstable/http";	3	import {
		4	HttpClient,
		5	HttpClientError,
		6	HttpClientRequest,
		7	HttpClientResponse,
		8	HttpServerResponse,
		9	} from "effect/unstable/http";
4	import { serveTestHttpApp } from "@executor-js/sdk/testing";	10	import { serveTestHttpApp } from "@executor-js/sdk/testing";
5		11
6	import { probeMcpEndpointShape } from "./probe-shape";	12	import { probeMcpEndpointShape } from "./probe-shape";
@@ -320,6 +326,91 @@ describe("probeMcpEndpointShape", () => { · 313 unmodified lines
320	),	326	),
321	);	327	);
322		328
		329	it.effect("falls through a wrong-shape legacy GET retry to modern server discovery", () =>
		330	Effect.scoped(
		331	Effect.gen(function* () {
		332	const server = yield* serveProbeEndpoint((request) => {
		333	if (request.body.includes('"method":"server/discover"')) {
		334	return HttpServerResponse.jsonUnsafe({
		335	jsonrpc: "2.0",
		336	id: 2,
		337	error: { code: -32601, message: "Method not found" },
		338	});
		339	}
		340	if (request.method === "GET") {
		341	return HttpServerResponse.jsonUnsafe({ error: "legacy SSE is unsupported" });
		342	}
		343	return HttpServerResponse.empty({ status: 405 });
		344	});
		345
		346	const result = yield* probeMcpEndpointShape(server.endpoint);
		347	expect(result).toEqual({ kind: "mcp", requiresAuth: false });
		348
		349	const requests = yield* server.requests;
		350	expect(requests).toHaveLength(3);
		351	expect(requests[0]?.body).toContain('"protocolVersion":"2025-11-25"');
		352	expect(requests[1]?.method).toBe("GET");
		353	expect(requests[2]?.body).toBe(
		354	JSON.stringify({
		355	jsonrpc: "2.0",
		356	id: 2,
		357	method: "server/discover",
		358	params: {
		359	_meta: { "io.modelcontextprotocol/protocolVersion": "2026-07-28" },
		360	},
		361	}),
		362	);
		363	expect(requests[2]?.headers["mcp-protocol-version"]).toBe("2026-07-28");
		364	}),
		365	),
		366	);
		367
		368	it.effect("keeps the initialize verdict when the discover fallback fails at the transport", () =>
		369	Effect.gen(function* () {
		370	const bodyText = (request: HttpClientRequest.HttpClientRequest): string =>
		371	Predicate.isTagged(request.body, "Uint8Array")
		372	? new TextDecoder().decode(request.body.body)
		373	: "";
		374	const httpClientLayer = Layer.succeed(HttpClient.HttpClient)(
		375	HttpClient.make(
		376	(
		377	request: HttpClientRequest.HttpClientRequest,
		378	): Effect.Effect<
		379	HttpClientResponse.HttpClientResponse,
		380	HttpClientError.HttpClientError
		381	> =>
		382	bodyText(request).includes('"method":"server/discover"')
		383	? Effect.fail(
		384	new HttpClientError.HttpClientError({
		385	reason: new HttpClientError.TransportError({
		386	request,
		387	description: "connection reset by peer",
		388	}),
		389	}),
		390	)
		391	: Effect.succeed(
		392	HttpClientResponse.fromWeb(
		393	request,
		394	new Response("<html>not mcp</html>", {
		395	status: 200,
		396	headers: { "content-type": "text/html" },
		397	}),
		398	),
		399	),
		400	),
		401	);
		402
		403	const result = yield* probeMcpEndpointShape("https://internal.example/mcp", {
		404	httpClientLayer,
		405	});
		406	expect(result).toEqual({
		407	kind: "not-mcp",
		408	category: "wrong-shape",
		409	reason: "2xx POST body is not a JSON-RPC envelope",
		410	});
		411	}),
		412	);
		413
323	it.effect("rejects 2xx with HTML body as wrong-shape", () =>	414	it.effect("rejects 2xx with HTML body as wrong-shape", () =>
324	withServer(	415	withServer(
325	() =>	416	() =>

packages/plugins/mcp/src/sdk/probe-shape.ts+51−10

 //   and (b) plenty of real MCP servers authenticate with static API
 //   keys and publish no OAuth metadata at all (e.g. cubic.dev).
 //
-// The probe issues an unauth JSON-RPC `initialize` POST and accepts
+// The primary probe issues an unauth JSON-RPC `initialize` POST and accepts
 // only the wire shapes a real MCP server can return:
 //
 //   - 2xx with `Content-Type: text/event-stream` — streamable HTTP
 // only accepts 2xx with `text/event-stream` or the same 401+Bearer
 // shape.
 //
-// One `fetch` (occasionally two), no MCP-SDK session state, no OAuth
+// If initialize ultimately has the wrong shape, a second JSON-RPC POST probes
-// round-trip, no DCR — every non-MCP endpoint exits here.
+// `server/discover` using the 2026-07-28 envelope and protocol header. This
+// catches modern-only servers that reject initialize with a non-JSON-RPC
+// response. Authentication outcomes remain terminal because they do not vary
+// by transport era.
+//
+// One primary request (occasionally plus legacy GET and modern discover), no
+// MCP-SDK session state, no OAuth round-trip, no DCR.
 // ---------------------------------------------------------------------------
 import { Data, Duration, Effect, Layer, Option, Schema } from "effect";
   id: 1,
   method: "initialize",
   params: {
-    protocolVersion: "2025-06-18",
+    protocolVersion: "2025-11-25",
     capabilities: {},
     clientInfo: { name: "executor-probe", version: "0" },
   },
 });
+const DISCOVER_BODY = JSON.stringify({
+  jsonrpc: "2.0",
+  id: 2,
+  method: "server/discover",
+  params: {
+    _meta: { "io.modelcontextprotocol/protocolVersion": "2026-07-28" },
+  },
+});
 /** Header-name lookup is case-insensitive per RFC 7230. `fetch`'s
  *  `Response.headers` already lower-cases, but we normalise explicitly
  *  to stay robust against test mocks that construct `Headers` loosely. */
         .execute(postRequest)
         .pipe(Effect.timeout(Duration.millis(timeoutMs)));
-      const postResult = yield* classify(postResponse, "POST");
+      let initializeResult = yield* classify(postResponse, "POST");
-      if (postResult) return postResult;
-      if ([404, 405, 406, 415].includes(postResponse.status)) {
+      if (initializeResult === null && [404, 405, 406, 415].includes(postResponse.status)) {
         let getRequest = HttpClientRequest.get(url.toString()).pipe(
           HttpClientRequest.setHeader("accept", "text/event-stream"),
         );
         const getResponse = yield* client
           .execute(getRequest)
           .pipe(Effect.timeout(Duration.millis(timeoutMs)));
-        const getResult = yield* classify(getResponse, "GET");
+        initializeResult = yield* classify(getResponse, "GET");
-        if (getResult) return getResult;
       }
-      return {
+      initializeResult ??= {
         kind: "not-mcp",
         category: "wrong-shape",
         reason: `unexpected status ${postResponse.status} for initialize`,
       } as const;
+      if (initializeResult.kind !== "not-mcp" || initializeResult.category !== "wrong-shape") {
+        return initializeResult;
+      }
+      let discoverRequest = HttpClientRequest.post(url.toString()).pipe(
+        HttpClientRequest.setHeader("content-type", "application/json"),
+        HttpClientRequest.setHeader("accept", "application/json, text/event-stream"),
+        HttpClientRequest.bodyText(DISCOVER_BODY, "application/json"),
+      );
+      for (const [name, value] of Object.entries(options.headers ?? {})) {
+        discoverRequest = HttpClientRequest.setHeader(discoverRequest, name, value);
+      }
+      discoverRequest = HttpClientRequest.setHeader(
+        discoverRequest,
+        "MCP-Protocol-Version",
+        "2026-07-28",
+      );
+      // The endpoint already answered the primary probe, so a transport
+      // failure on this secondary request must not overwrite that verdict
+      // with "unreachable" — keep the initialize classification instead.
+      const discoverResult = yield* client.execute(discoverRequest).pipe(
+        Effect.timeout(Duration.millis(timeoutMs)),
+        Effect.flatMap((discoverResponse) => classify(discoverResponse, "POST")),
+        Effect.catch(() => Effect.succeed(null)),
+      );
+      return discoverResult ?? initializeResult;
     }).pipe(
       Effect.provide(options.httpClientLayer ?? FetchHttpClient.layer),
       Effect.mapError(

packages/plugins/mcp/src/sdk/stdio-connector.ts+4−3

 // ---------------------------------------------------------------------------
 //
 // Kept in its own module so `connection.ts` never imports it eagerly at
-// module load. `@modelcontextprotocol/sdk/client/stdio.js` pulls in
+// module load. The v2 `@modelcontextprotocol/client/stdio` entry still eagerly
-// `node:child_process` at evaluation time; under `@cloudflare/vitest-pool-workers`
+// evaluates Node-only process/stream imports and `cross-spawn` (which loads
+// `node:child_process`); under `@cloudflare/vitest-pool-workers`
 // that crashes workerd at module instantiation with SIGSEGV (prod bundles
 // tree-shake it away when `dangerouslyAllowStdioMCP: false`, tests do not).
 //
 // the import and therefore never touch `node:child_process`.
 // ---------------------------------------------------------------------------
-import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
+import { StdioClientTransport } from "@modelcontextprotocol/client/stdio";
 export type StdioTransportConfig = {
   readonly command: string;

packages/plugins/mcp/src/sdk/testing-fixtures.test.ts+8−4

 import { expect, layer } from "@effect/vitest";
 import { Effect } from "effect";
-import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { Client, StreamableHTTPClientTransport } from "@modelcontextprotocol/client";
-import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
 import { OAuthTestServer } from "@executor-js/sdk/testing";
 import { makeEchoMcpServer, serveMcpServerWithOAuth } from "../testing";
   });
 const makeClient = (endpoint: string, accessToken: string) => {
-  const client = new Client({ name: "executor-test-client", version: "1.0.0" });
+  const client = new Client(
+    { name: "executor-test-client", version: "1.0.0" },
+    { versionNegotiation: { mode: "auto" } },
+  );
   const transport = new StreamableHTTPClientTransport(new URL(endpoint), {
     requestInit: {
       headers: { authorization: `Bearer ${accessToken}` },
       expect(result).toMatchObject({
         content: [{ type: "text", text: "Hello Ada" }],
       });
-      expect(server.sessionCount()).toBe(1);
+      // The v1 fixture creates a throwaway transport for the rejected modern
+      // discovery probe before the initialized legacy session.
+      expect(server.sessionCount()).toBe(2);
       const requests = yield* server.requests;
       expect(