effect 4.0.0-beta.99 → 4.0.0-rc.108

package/dist/unstable/ai/McpServer.js

@@ -13,11 +13,14 @@
 import * as Arr from "../../Array.js";
 import * as Cause from "../../Cause.js";
 import * as Context from "../../Context.js";
+import * as Data from "../../Data.js";
 import * as Effect from "../../Effect.js";
 import * as Exit from "../../Exit.js";
 import * as Fiber from "../../Fiber.js";
 import * as Layer from "../../Layer.js";
+import * as LogLevel from "../../LogLevel.js";
 import * as Option from "../../Option.js";
+import * as Predicate from "../../Predicate.js";
 import * as Queue from "../../Queue.js";
 import * as RcMap from "../../RcMap.js";
 import { CurrentLogLevel } from "../../References.js";
@@ -36,7 +39,9 @@ import * as RpcClient from "../rpc/RpcClient.js";
 import * as RpcMessage from "../rpc/RpcMessage.js";
 import * as RpcSerialization from "../rpc/RpcSerialization.js";
 import * as RpcServer from "../rpc/RpcServer.js";
-import { CallToolResult, ClientNotificationRpcs, ClientRpcs, CompleteResult, Elicit, ElicitationDeclined, EnabledWhen, GetPromptResult, InternalError, InvalidParams, isParam, ListPromptsResult, ListResourcesResult, ListResourceTemplatesResult, ListToolsResult, McpServerClient, McpServerClientMiddleware, Prompt, Resource, ResourceTemplate, ServerNotificationRpcs, ServerRequestRpcs, TextContent, Tool as McpTool } from "./McpSchema.js";
+import * as AiError from "./AiError.js";
+import * as McpProtocolRegistry from "./internal/mcpProtocolRegistry.js";
+import { CallToolResult, CancelledNotification, ClientRpcs, Elicit, ElicitationDeclined, EnabledWhen, GetPromptResult, InternalError, INVALID_REQUEST_ERROR_CODE, InvalidParams, InvalidRequest, isParam, ListPromptsResult, ListResourcesResult, ListResourceTemplatesResult, ListToolsResult, LoggingMessageNotification, McpErrorBase, McpServerClient, McpServerClientMiddleware, MethodNotFound, ParseError, Prompt, Resource, ResourceTemplate, ResourceUpdatedNotification, ServerNotificationRpcs, TextContent, Tool as McpTool } from "./McpSchema.js";
 import * as Tool from "./Tool.js";
 /**
  * Service that stores and serves an MCP server's registered tools, resources,
@@ -47,7 +52,7 @@ import * as Tool from "./Tool.js";
  * Handlers use this service to register capabilities and resolve incoming MCP
  * requests.
  *
- * @category server
+ * @category services
  * @since 4.0.0
  */
 export class McpServer extends /*#__PURE__*/Context.Service()("effect/ai/McpServer") {
@@ -111,7 +116,9 @@ export class McpServer extends /*#__PURE__*/Context.Service()("effect/ai/McpServ
             message: `Tool '${request.name}' not found`
           }));
         }
-        return handle(request.arguments);
+        return handle(request.arguments).pipe(Effect.catchDefect(() => Effect.fail(new InternalError({
+          message: "Internal error"
+        }))));
       }),
       get resources() {
         return resources;
@@ -150,9 +157,10 @@ export class McpServer extends /*#__PURE__*/Context.Service()("effect/ai/McpServ
       findResource: uri => Effect.suspend(() => {
         const match = matcher.find(uri);
         if (!match) {
-          return Effect.succeed({
-            contents: []
-          });
+          return Effect.fail(new McpErrorBase({
+            code: -32002,
+            message: `Resource '${uri}' not found`
+          }));
         } else if (match.handler._tag === "Resource") {
           return match.handler.effect;
         }
@@ -189,7 +197,20 @@ export class McpServer extends /*#__PURE__*/Context.Service()("effect/ai/McpServ
         const ref = complete.ref;
         const key = ref.type === "ref/resource" ? `ref/resource/${ref.uri}/${complete.argument.name}` : `ref/prompt/${ref.name}/${complete.argument.name}`;
         const handler = completionsMap.get(key);
-        return handler ? yield* handler(complete.argument.value) : CompleteResult.empty;
+        if (!handler) {
+          return yield* new InvalidParams({
+            message: "Unknown completion reference or argument"
+          });
+        }
+        const result = yield* handler(complete.argument.value, complete.context);
+        const values = Arr.take(result.completion.values, 100);
+        return {
+          completion: {
+            ...result.completion,
+            values,
+            hasMore: result.completion.hasMore === true || values.length < result.completion.values.length
+          }
+        };
       })
     });
   });
@@ -200,10 +221,23 @@ export class McpServer extends /*#__PURE__*/Context.Service()("effect/ai/McpServ
    */
   static layer = /*#__PURE__*/Layer.effect(McpServer)(McpServer.make);
 }
-const LATEST_PROTOCOL_VERSION = "2025-06-18";
-const SUPPORTED_PROTOCOL_VERSIONS = [LATEST_PROTOCOL_VERSION, "2025-03-26", "2024-11-05", "2024-10-07"];
-const mcpSessionIdHeader = "mcp-session-id";
-const mcpProtocolVersionHeader = "mcp-protocol-version";
+const MCP_SESSION_ID_HEADER = "mcp-session-id";
+const MCP_PROTOCOL_VERSION_HEADER = "mcp-protocol-version";
+const MCP_INVALID_BATCH_METHOD = "invalid/json-rpc-batch";
+const decodeCancelledNotification = /*#__PURE__*/Schema.decodeUnknownEffect(/*#__PURE__*/Schema.toCodecJson(CancelledNotification.payloadSchema));
+const requestKey = requestId => `${typeof requestId}:${requestId}`;
+class McpClientKey extends Data.Class {}
+class McpProtocolState extends /*#__PURE__*/Context.Service()("effect/ai/McpServer/McpProtocolState") {}
+const makeMcpProtocolState = /*#__PURE__*/Effect.fnUntraced(function* (protocols) {
+  return McpProtocolState.of({
+    sessions: {
+      bySessionId: new Map(),
+      byClientId: new Map()
+    },
+    protocolRegistry: yield* McpProtocolRegistry.make(protocols)
+  });
+});
+const layerMcpProtocolState = protocols => Layer.effect(McpProtocolState)(makeMcpProtocolState(protocols));
 /**
  * Runs an MCP server over the current `RpcServer.Protocol`.
  *
@@ -213,21 +247,32 @@ const mcpProtocolVersionHeader = "mcp-protocol-version";
  * tools, resources, and prompts, and forwards queued server notifications to
  * initialized clients.
  *
- * @category constructors
+ * @category running
  * @since 4.0.0
  */
 export const run = /*#__PURE__*/Effect.fnUntraced(function* (options) {
+  const protocolStateOption = yield* Effect.serviceOption(McpProtocolState);
+  const protocolState = Option.isSome(protocolStateOption) ? protocolStateOption.value : yield* makeMcpProtocolState(options.protocols);
+  return yield* runWithProtocolState(options, protocolState);
+});
+const runWithProtocolState = /*#__PURE__*/Effect.fnUntraced(function* (options, protocolState) {
+  const serverScope = yield* Effect.scope;
+  const protocolRegistry = protocolState.protocolRegistry;
   const protocol = yield* RpcServer.Protocol;
   const server = yield* McpServer;
   const isHttp = Option.isSome(yield* Effect.serviceOption(HttpRouter.HttpRouter));
-  const clientSessions = new Map();
+  const sessions = protocolState.sessions;
+  const clientProtocols = new Map();
+  const activeRequests = new Map();
   const handlers = yield* Layer.build(layerHandlers(options, {
-    clientSessions
+    sessions,
+    protocolRegistry
   }));
   const clients = yield* RcMap.make({
-    lookup: Effect.fnUntraced(function* (clientId) {
+    lookup: Effect.fnUntraced(function* (key) {
+      const selectedProtocol = protocolRegistry.select(key.protocolVersion);
       let write;
-      const client = yield* RpcClient.make(ServerRequestRpcs, {
+      const client = yield* RpcClient.make(selectedProtocol.serverRequestRpcs, {
         spanPrefix: "McpServer/Client"
       }).pipe(Effect.provideServiceEffect(RpcClient.Protocol, RpcClient.Protocol.make(Effect.fnUntraced(function* (writeResponse) {
         let cid = 0;
@@ -235,7 +280,7 @@ export const run = /*#__PURE__*/Effect.fnUntraced(function* (options) {
         return {
           send(id, request, _transferables) {
             cid = id;
-            return protocol.send(clientId, {
+            return protocol.send(key.clientId, {
               ...request,
               headers: undefined,
               traceId: undefined,
@@ -258,95 +303,249 @@ export const run = /*#__PURE__*/Effect.fnUntraced(function* (options) {
   const clientMiddleware = McpServerClientMiddleware.of((effect, {
     client,
     headers,
+    payload,
     rpc
   }) => {
-    const initializePayload = getInitializedClient(clientSessions, client.id, headers);
-    const isInitialize = rpc._tag === "initialize";
-    if (!isInitialize && !initializePayload) {
+    const session = getClientSession(sessions, client.id, headers);
+    const isInitialize = rpc._tag.endsWith("/initialize");
+    if (!isInitialize && !session) {
       const fiber = Fiber.getCurrent();
       const httpRequest = Context.getOrUndefined(fiber.context, HttpServerRequest.HttpServerRequest);
       if (httpRequest) {
         appendPreResponseHandlerUnsafe(httpRequest, () => Effect.succeed(HttpServerResponse.empty({
-          status: 404
+          status: headers[MCP_SESSION_ID_HEADER] === undefined ? 400 : 404
         })));
       }
       return Effect.die(new Error(`Mcp-Session-Id does not exist`));
     }
-    return Effect.provideService(effect, McpServerClient, McpServerClient.of({
+    const selectedProtocol = session?.protocol ?? protocolForInternalTag(protocolRegistry, rpc._tag);
+    return effect.pipe(Effect.provideService(McpServerClient, McpServerClient.of({
       clientId: client.id,
-      initializePayload: initializePayload,
-      getClient: RcMap.get(clients, client.id).pipe(Effect.map(({
+      protocolVersion: selectedProtocol.protocolVersion,
+      initializePayload: session?.initializePayload ?? payload,
+      getClient: RcMap.get(clients, new McpClientKey({
+        clientId: client.id,
+        protocolVersion: selectedProtocol.protocolVersion
+      })).pipe(Effect.map(({
         client
       }) => client))
-    }));
+    })), Effect.provideService(CurrentLogLevel, effectLogLevel(session?.logLevel)));
   });
   const patchedProtocol = RpcServer.Protocol.of({
     ...protocol,
+    send: (clientId, response) => {
+      if (response._tag === "Exit") {
+        const requests = activeRequests.get(clientId);
+        const key = requestKey(response.requestId);
+        const cancelled = requests?.get(key);
+        if (requests !== undefined && requests.delete(key) && requests.size === 0) {
+          activeRequests.delete(clientId);
+        }
+        if (cancelled === true) {
+          return Effect.void;
+        }
+      }
+      return protocol.send(clientId, response);
+    },
     run: f => protocol.run((clientId, request_) => {
+      const fiber = Fiber.getCurrent();
       const request = request_;
+      const httpRequest = isHttp ? Context.getOrUndefined(fiber.context, HttpServerRequest.HttpServerRequest) : undefined;
+      if (httpRequest !== undefined && request._tag !== "Eof") {
+        appendPreResponseHandlerUnsafe(httpRequest, (_, response) => Effect.succeed(response.status === 200 && response.body._tag === "Uint8Array" && response.body.contentLength === 0 ? HttpServerResponse.empty({
+          headers: Headers.remove(response.headers, "content-type"),
+          status: 202
+        }) : response));
+      }
       switch (request._tag) {
         case "Request":
           {
+            const headers = isHttp ? Context.getUnsafe(Fiber.getCurrent().context, HttpServerRequest.HttpServerRequest).headers : Headers.fromInput(request.headers);
+            const session = getClientSession(sessions, clientId, headers);
+            const selectedProtocol = session?.protocol ?? (request.tag === "initialize" ? protocolRegistry.select(getOfferedProtocolVersion(request.payload)) : protocolRegistry.protocols[0]);
+            clientProtocols.set(clientId, selectedProtocol);
+            if (request.tag === MCP_INVALID_BATCH_METHOD) {
+              return protocol.send(clientId, {
+                _tag: "Exit",
+                requestId: request.id,
+                exit: {
+                  _tag: "Failure",
+                  cause: [{
+                    _tag: "Fail",
+                    error: new InvalidRequest({
+                      message: "JSON-RPC batches are not supported"
+                    })
+                  }]
+                }
+              });
+            }
             if (isHttp) {
               const fiber = Fiber.getCurrent();
               const httpRequest = Context.getUnsafe(fiber.context, HttpServerRequest.HttpServerRequest);
-              const client = getInitializedClient(clientSessions, clientId, httpRequest.headers);
-              if (client) {
-                appendPreResponseHandlerUnsafe(httpRequest, (_, res) => Effect.succeed(HttpServerResponse.setHeader(res, mcpProtocolVersionHeader, client.protocolVersion)));
+              if (session) {
+                appendPreResponseHandlerUnsafe(httpRequest, (_, res) => Effect.succeed(HttpServerResponse.setHeader(res, MCP_PROTOCOL_VERSION_HEADER, session.protocol.protocolVersion)));
               }
             }
-            const rpc = ClientNotificationRpcs.requests.get(request.tag);
-            if (rpc) {
+            const routedRequest = protocolRegistry.routeClientRequest(selectedProtocol, request);
+            const rpc = protocolRegistry.clientRpcs.requests.get(routedRequest.tag);
+            if (rpc && selectedProtocol.clientNotificationRpcs.requests.has(request.tag)) {
+              if (!session) {
+                if (httpRequest) {
+                  appendPreResponseHandlerUnsafe(httpRequest, () => Effect.succeed(HttpServerResponse.empty({
+                    status: headers[MCP_SESSION_ID_HEADER] === undefined ? 400 : 404
+                  })));
+                }
+                return Effect.void;
+              }
               if (request.tag === "notifications/cancelled") {
-                return f(clientId, {
-                  _tag: "Interrupt",
-                  requestId: String(request.payload.requestId)
-                });
+                return decodeCancelledNotification(request.payload).pipe(Effect.flatMap(({
+                  requestId
+                }) => {
+                  const key = requestKey(requestId);
+                  const requests = activeRequests.get(clientId);
+                  if (requests?.has(key) !== true) {
+                    return Effect.void;
+                  }
+                  requests.set(key, true);
+                  return f(clientId, {
+                    _tag: "Interrupt",
+                    requestId: RpcMessage.RequestId(requestId)
+                  });
+                }), Effect.catchCause(() => Effect.void));
+              }
+              return selectedProtocol.payloadCodecs(rpc).decode(request.payload).pipe(Effect.flatMap(payload => {
+                if (request.tag === "notifications/roots/list_changed" && session.initializePayload.capabilities.roots?.listChanged === true) {
+                  if (httpRequest !== undefined) {
+                    return Effect.void;
+                  }
+                  return RcMap.get(clients, new McpClientKey({
+                    clientId,
+                    protocolVersion: selectedProtocol.protocolVersion
+                  })).pipe(Effect.flatMap(({
+                    client
+                  }) => client["roots/list"](undefined)), Effect.scoped, Effect.ignoreCause, Effect.forkIn(serverScope), Effect.asVoid);
+                }
+                const handler = handlers.mapUnsafe.get(rpc.key);
+                return handler ? handler.handler(payload, {
+                  rpc,
+                  requestId: RpcMessage.RequestId(request.id),
+                  client: new Rpc.ServerClient(clientId),
+                  headers
+                }) : Effect.void;
+              }), Effect.catchCause(() => Effect.void));
+            }
+            if (!rpc) {
+              if (request.isNotification) {
+                return Effect.void;
               }
-              const handler = handlers.mapUnsafe.get(request.tag);
-              return handler ? handler.handler(request.payload, {
-                rpc,
-                requestId: RpcMessage.RequestId(request.id),
-                client: new Rpc.ServerClient(clientId),
-                headers: Headers.fromInput(request.headers)
-              }) : Effect.void;
+              return protocol.send(clientId, {
+                _tag: "Exit",
+                requestId: request.id,
+                exit: {
+                  _tag: "Failure",
+                  cause: [{
+                    _tag: "Fail",
+                    error: new MethodNotFound({
+                      message: `Method not found: ${request.tag}`
+                    })
+                  }]
+                }
+              });
             }
-            return f(clientId, request);
+            return selectedProtocol.payloadCodecs(rpc).decode(request.payload).pipe(Effect.matchEffect({
+              onSuccess: () => {
+                if (request.isNotification !== true) {
+                  const requests = activeRequests.get(clientId) ?? new Map();
+                  requests.set(requestKey(request.id), false);
+                  activeRequests.set(clientId, requests);
+                }
+                return f(clientId, routedRequest);
+              },
+              onFailure: () => request.isNotification ? Effect.void : protocol.send(clientId, {
+                _tag: "Exit",
+                requestId: request.id,
+                exit: {
+                  _tag: "Failure",
+                  cause: [{
+                    _tag: "Fail",
+                    error: new InvalidParams({
+                      message: "Invalid method parameters"
+                    })
+                  }]
+                }
+              })
+            }));
           }
         case "Ping":
         case "Ack":
         case "Interrupt":
+          return f(clientId, request);
         case "Eof":
+          activeRequests.delete(clientId);
           return f(clientId, request);
         case "Pong":
         case "Exit":
         case "Chunk":
         case "ClientProtocolError":
         case "Defect":
-          return RcMap.get(clients, clientId).pipe(Effect.flatMap(({
+          return RcMap.get(clients, new McpClientKey({
+            clientId,
+            protocolVersion: getProtocolForClient(clientProtocols, clientId, protocolRegistry).protocolVersion
+          })).pipe(Effect.flatMap(({
             write
           }) => write(request)), Effect.scoped);
       }
     })
   });
-  const encodeNotification = Schema.encodeUnknownEffect(Schema.Union(Array.from(ServerNotificationRpcs.requests.values(), rpc => rpc.payloadSchema)));
   yield* Queue.take(server.notificationsQueue).pipe(Effect.flatMap(Effect.fnUntraced(function* (request) {
-    const encoded = yield* encodeNotification(request.payload);
-    const message = {
-      _tag: "Request",
-      tag: request.tag,
-      payload: encoded
-    };
     const clientIds = yield* patchedProtocol.clientIds;
+    for (const clientId of clientProtocols.keys()) {
+      if (!clientIds.has(clientId)) {
+        clientProtocols.delete(clientId);
+        sessions.byClientId.delete(clientId);
+      }
+    }
     for (const clientId of server.initializedClients.keys()) {
       if (!clientIds.has(clientId)) {
         server.initializedClients.delete(clientId);
         continue;
       }
+      const selectedProtocol = clientProtocols.get(clientId);
+      if (!selectedProtocol) {
+        continue;
+      }
+      const rpc = selectedProtocol.serverNotificationRpcs.requests.get(request.tag);
+      if (!rpc) {
+        continue;
+      }
+      if (request.tag === "notifications/message") {
+        const {
+          level
+        } = yield* Schema.decodeUnknownEffect(LoggingMessageNotification.payloadSchema)(request.payload);
+        if (!isMcpLogLevelEnabled(level, sessions.byClientId.get(clientId)?.logLevel)) {
+          continue;
+        }
+      }
+      if (request.tag === "notifications/resources/updated") {
+        const {
+          uri
+        } = yield* Schema.decodeUnknownEffect(ResourceUpdatedNotification.payloadSchema)(request.payload);
+        if (sessions.byClientId.get(clientId)?.resourceSubscriptions?.has(uri) !== true) {
+          continue;
+        }
+      }
+      const encoded = yield* selectedProtocol.payloadCodecs(rpc).encode(request.payload);
+      // TODO: Extend RpcServer.Protocol's outbound message contract with server-originated
+      // notifications so MCP does not need to treat this notification as an RPC response.
+      const message = {
+        _tag: "Request",
+        tag: request.tag,
+        payload: encoded
+      };
       yield* patchedProtocol.send(clientId, message);
     }
   })), Effect.catchCause(() => Effect.void), Effect.forever, Effect.forkScoped);
-  return yield* RpcServer.make(ClientRpcs, {
+  return yield* RpcServer.make(protocolRegistry.clientRpcs, {
     spanPrefix: "McpServer",
     disableFatalDefects: true
   }).pipe(Effect.provideService(RpcServer.Protocol, patchedProtocol), Effect.provideService(McpServerClientMiddleware, clientMiddleware), Effect.provide(handlers));
@@ -380,69 +579,130 @@ export const run = /*#__PURE__*/Effect.fnUntraced(function* (options) {
  * @category layers
  * @since 4.0.0
  */
-export const layer = options => Layer.effectDiscard(Effect.forkScoped(run(options))).pipe(Layer.provideMerge(McpServer.layer));
+export const layer = options => layerWithProtocolState(options).pipe(Layer.provide(layerMcpProtocolState(options.protocols)));
+const layerWithProtocolState = options => Layer.effectDiscard(Effect.gen(function* () {
+  const protocolState = yield* McpProtocolState;
+  yield* Effect.forkScoped(runWithProtocolState(options, protocolState));
+})).pipe(Layer.provideMerge(McpServer.layer));
+const StdioInitializeRequest = /*#__PURE__*/Schema.Struct({
+  method: /*#__PURE__*/Schema.Literal("initialize"),
+  params: /*#__PURE__*/Schema.Struct({
+    protocolVersion: Schema.String
+  })
+});
+const StdioInvalidBatchExit = /*#__PURE__*/Schema.Struct({
+  _tag: /*#__PURE__*/Schema.Literal("Exit"),
+  requestId: Schema.Null,
+  exit: /*#__PURE__*/Schema.Struct({
+    cause: Schema.Unknown
+  })
+});
+const decodeStdioInitializeRequest = /*#__PURE__*/Schema.decodeUnknownOption(StdioInitializeRequest);
+const decodeStdioInvalidBatchExit = /*#__PURE__*/Schema.decodeUnknownOption(StdioInvalidBatchExit);
+const makeStdioSerialization = protocols => RpcSerialization.RpcSerialization.of({
+  contentType: "application/json-rpc",
+  includesFraming: true,
+  makeUnsafe: () => {
+    const framing = RpcSerialization.ndjson.makeUnsafe();
+    const jsonRpc = RpcSerialization.jsonRpc().makeUnsafe();
+    const protocolsByVersion = new Map(protocols.map(protocol => [protocol.protocolVersion, protocol]));
+    let selectedProtocol = protocols[0];
+    return {
+      decode: data => {
+        const frames = framing.decode(data);
+        const messages = [];
+        for (const frame of frames) {
+          const entries = Array.isArray(frame) ? frame : [frame];
+          const initialize = Arr.findFirst(entries, entry => decodeStdioInitializeRequest(entry));
+          selectedProtocol = Option.match(initialize, {
+            onNone: () => selectedProtocol,
+            onSome: ({
+              params
+            }) => protocolsByVersion.get(params.protocolVersion) ?? protocols[0]
+          });
+          if (Array.isArray(frame) && !selectedProtocol.transport.acceptsJsonRpcBatches) {
+            messages.push({
+              _tag: "Request",
+              id: null,
+              tag: MCP_INVALID_BATCH_METHOD,
+              payload: null,
+              headers: []
+            });
+          } else {
+            messages.push(...jsonRpc.decode(JSON.stringify(frame)));
+          }
+        }
+        return messages;
+      },
+      encode: response => {
+        const invalidBatchExit = decodeStdioInvalidBatchExit(response);
+        if (Option.isSome(invalidBatchExit)) {
+          return framing.encode({
+            jsonrpc: "2.0",
+            id: null,
+            error: {
+              _tag: "Cause",
+              code: INVALID_REQUEST_ERROR_CODE,
+              message: "JSON-RPC batches are not supported",
+              data: invalidBatchExit.value.exit.cause
+            }
+          });
+        }
+        const encoded = jsonRpc.encode(response);
+        return encoded === undefined ? undefined : `${encoded}\n`;
+      }
+    };
+  }
+});
 /**
  * Runs the McpServer, using stdio for input and output.
  *
- * **Example** (Running an MCP server over stdio)
+ * **Example** (Configuring an MCP server over stdio)
  *
- * ```ts
- * import { Effect, Layer, Logger, Schema } from "effect"
- * import { NodeRuntime, NodeStdio } from "@effect/platform-node"
- * import { McpSchema, McpServer } from "effect/unstable/ai"
+ * ```ts import.meta.vitest
+ * import { Effect, Layer, Schema } from "effect"
+ * import { McpProtocol, McpSchema, McpServer } from "effect/unstable/ai"
  *
  * const idParam = McpSchema.param("id", Schema.Number)
  *
- * // Define a resource template for a README file
  * const ReadmeTemplate = McpServer.resource`file://readme/${idParam}`({
  *   name: "README Template",
- *   // You can add auto-completion for the ID parameter
  *   completion: {
- *     id: (_) => Effect.succeed([1, 2, 3, 4, 5])
+ *     id: () => Effect.succeed([1, 2, 3])
  *   },
- *   content: Effect.fn(function*(_uri, id) {
- *     return `# MCP Server Demo - ID: ${id}`
- *   })
+ *   content: (_uri, id) => Effect.succeed(`# MCP Server Demo - ID: ${id}`)
  * })
  *
- * // Define a test prompt with parameters
  * const TestPrompt = McpServer.prompt({
  *   name: "Test Prompt",
- *   description: "A test prompt to demonstrate MCP server capabilities",
+ *   description: "Looks up flight booking details",
  *   parameters: {
  *     flightNumber: Schema.String
  *   },
  *   completion: {
- *     flightNumber: () => Effect.succeed(["FL123", "FL456", "FL789"])
+ *     flightNumber: () => Effect.succeed(["FL123", "FL456"])
  *   },
  *   content: ({ flightNumber }) =>
  *     Effect.succeed(`Get the booking details for flight number: ${flightNumber}`)
  * })
  *
- * // Merge all the resources and prompts into a single server layer
- * const ServerLayer = Layer.mergeAll(
- *   ReadmeTemplate,
- *   TestPrompt
- * ).pipe(
- *   // Provide the MCP server implementation
+ * const ServerLayer = Layer.mergeAll(ReadmeTemplate, TestPrompt).pipe(
  *   Layer.provide(McpServer.layerStdio({
  *     name: "Demo Server",
  *     version: "1.0.0",
- *   })),
- *   Layer.provide(NodeStdio.layer),
- *   Layer.provide(Layer.succeed(Logger.LogToStderr)(true))
+ *     protocols: [McpProtocol.v2025_06_18]
+ *   }))
  * )
  *
- * Layer.launch(ServerLayer).pipe(NodeRuntime.runMain)
+ * Layer.isLayer(ServerLayer) // => true
  * ```
  *
  * @category layers
  * @since 4.0.0
  */
-export const layerStdio = options => layer(options).pipe(Layer.provide(RpcServer.layerProtocolStdio), Layer.provide(RpcSerialization.layerNdJsonRpc()));
+export const layerStdio = options => layer(options).pipe(Layer.provide(RpcServer.layerProtocolStdio), Layer.provide(Layer.succeed(RpcSerialization.RpcSerialization)(makeStdioSerialization(options.protocols))));
 /**
- * Registers an HTTP POST JSON-RPC route at `options.path` on the current
- * `HttpRouter`.
+ * Registers a Streamable HTTP MCP endpoint at `options.path`.
  *
  * **When to use**
  *
@@ -450,8 +710,9 @@ export const layerStdio = options => layer(options).pipe(Layer.provide(RpcServer
  *
  * **Details**
  *
- * This layer composes `layer(options)`, `RpcServer.layerProtocolHttp(options)`,
- * and `RpcSerialization.layerJsonRpc()`.
+ * POST serves JSON-RPC and accepted notification-only requests return `202`.
+ * Unsupported protocol versions return `400`; methods without MCP handlers
+ * return `405`. Browser Origins are rejected unless listed in `allowedOrigins`.
  *
  * @see {@link layerStdio} for exposing the server over stdio
  * @see {@link layer} for the base MCP server layer without a transport protocol
@@ -459,11 +720,163 @@ export const layerStdio = options => layer(options).pipe(Layer.provide(RpcServer
  * @category layers
  * @since 4.0.0
  */
-export const layerHttp = options => layer(options).pipe(Layer.provide(RpcServer.layerProtocolHttp(options)), Layer.provide(RpcSerialization.layerJsonRpc()));
+export const layerHttp = options => {
+  const protocolState = layerMcpProtocolState(options.protocols);
+  const methodNotAllowedResponse = HttpServerResponse.empty({
+    status: 405,
+    headers: {
+      allow: "POST"
+    }
+  });
+  const methodNotAllowed = request => Effect.succeed(request.headers.origin !== undefined && !options.allowedOrigins?.includes(request.headers.origin) ? HttpServerResponse.empty({
+    status: 403
+  }) : methodNotAllowedResponse);
+  const routes = Layer.mergeAll(HttpRouter.add("GET", options.path, methodNotAllowed), HttpRouter.add("PUT", options.path, methodNotAllowed), HttpRouter.add("PATCH", options.path, methodNotAllowed), HttpRouter.add("DELETE", options.path, methodNotAllowed), HttpRouter.add("OPTIONS", options.path, methodNotAllowed));
+  return Layer.merge(layerWithProtocolState(options), routes).pipe(Layer.provide(layerMcpProtocolHttp(options)), Layer.provide(protocolState), Layer.provide(RpcSerialization.layerJsonRpc()));
+};
+const layerMcpProtocolHttp = options => Layer.effect(RpcServer.Protocol)(Effect.gen(function* () {
+  const state = yield* McpProtocolState;
+  const {
+    httpEffect,
+    protocol
+  } = yield* RpcServer.makeProtocolWithHttpEffect;
+  const router = yield* HttpRouter.HttpRouter;
+  yield* router.add("POST", options.path, request => {
+    if (request.headers.origin !== undefined && !options.allowedOrigins?.includes(request.headers.origin)) {
+      return Effect.succeed(HttpServerResponse.empty({
+        status: 403
+      }));
+    }
+    const contentType = request.headers["content-type"]?.split(";", 1)[0]?.trim().toLowerCase();
+    if (contentType !== "application/json") {
+      return Effect.succeed(HttpServerResponse.empty({
+        status: 415
+      }));
+    }
+    const accepted = new Set();
+    for (const entry of request.headers.accept?.split(",") ?? []) {
+      const [mediaType, ...parameters] = entry.split(";").map(part => part.trim().toLowerCase());
+      let quality = 1;
+      for (const parameter of parameters) {
+        const [name, value] = parameter.split("=", 2).map(part => part.trim());
+        if (name === "q") {
+          quality = value === undefined ? Number.NaN : Number(value);
+        }
+      }
+      if (mediaType !== undefined && quality > 0 && quality <= 1) {
+        accepted.add(mediaType);
+      }
+    }
+    if (!accepted.has("application/json") || !accepted.has("text/event-stream")) {
+      return Effect.succeed(HttpServerResponse.empty({
+        status: 406
+      }));
+    }
+    const protocolVersion = request.headers[MCP_PROTOCOL_VERSION_HEADER];
+    if (protocolVersion !== undefined && !state.protocolRegistry.protocols.some(protocol => protocol.protocolVersion === protocolVersion)) {
+      return Effect.succeed(HttpServerResponse.empty({
+        status: 400
+      }));
+    }
+    return request.text.pipe(Effect.matchEffect({
+      onFailure: () => Effect.succeed(HttpServerResponse.jsonUnsafe({
+        jsonrpc: "2.0",
+        id: null,
+        error: new ParseError({
+          message: "Parse error"
+        })
+      })),
+      onSuccess: body => {
+        return Effect.match(Schema.decodeUnknownEffect(Schema.UnknownFromJsonString)(body), {
+          onFailure: () => ({
+            _tag: "Error",
+            id: null,
+            error: new ParseError({
+              message: "Parse error"
+            })
+          }),
+          onSuccess: input => {
+            if (Array.isArray(input)) {
+              const sessionId = request.headers[MCP_SESSION_ID_HEADER];
+              const session = sessionId === undefined ? undefined : state.sessions.bySessionId.get(sessionId);
+              let selectedProtocol = session?.protocol ?? state.protocolRegistry.protocols[0];
+              for (const entry of input) {
+                if (Predicate.hasProperty(entry, "method") && entry.method === "initialize" && Predicate.hasProperty(entry, "params") && Predicate.hasProperty(entry.params, "protocolVersion") && typeof entry.params.protocolVersion === "string") {
+                  selectedProtocol = state.protocolRegistry.select(entry.params.protocolVersion);
+                  break;
+                }
+              }
+              if (!selectedProtocol.transport.acceptsJsonRpcBatches) {
+                return {
+                  _tag: "HttpError",
+                  status: 400
+                };
+              }
+            }
+            const hasId = Predicate.hasProperty(input, "id");
+            const id = hasId && (typeof input.id === "string" || typeof input.id === "number") ? input.id : null;
+            const isJsonRpc = Predicate.hasProperty(input, "jsonrpc") && input.jsonrpc === "2.0";
+            const hasValidRequestId = hasId === false || typeof input.id === "string" || typeof input.id === "number";
+            const isRequest = isJsonRpc && hasValidRequestId && Predicate.hasProperty(input, "method") && typeof input.method === "string";
+            const hasValidResponseId = hasId && (typeof input.id === "string" || typeof input.id === "number" || input.id === null);
+            const hasResult = Predicate.hasProperty(input, "result");
+            const hasError = Predicate.hasProperty(input, "error");
+            const isResponse = isJsonRpc && hasValidResponseId && hasResult !== hasError;
+            const isInitialize = isRequest && input.method === "initialize";
+            const sessionId = request.headers[MCP_SESSION_ID_HEADER];
+            const session = sessionId === undefined ? undefined : state.sessions.bySessionId.get(sessionId);
+            if (isInitialize && sessionId !== undefined) {
+              return {
+                _tag: "HttpError",
+                status: session === undefined ? 404 : 400
+              };
+            }
+            if (!isInitialize && isRequest && session === undefined) {
+              return {
+                _tag: "HttpError",
+                status: sessionId === undefined ? 400 : 404
+              };
+            }
+            if (session !== undefined && session.protocol.transport.requiresVersionHeader && protocolVersion !== session.protocol.protocolVersion) {
+              return {
+                _tag: "HttpError",
+                status: 400
+              };
+            }
+            return isRequest || isResponse ? {
+              _tag: "Success"
+            } : {
+              _tag: "Error",
+              id,
+              error: new InvalidRequest({
+                message: "Invalid Request"
+              })
+            };
+          }
+        }).pipe(Effect.flatMap(decoded => decoded._tag === "HttpError" ? Effect.succeed(HttpServerResponse.empty({
+          status: decoded.status
+        })) : decoded._tag === "Error" ? Effect.succeed(HttpServerResponse.jsonUnsafe({
+          jsonrpc: "2.0",
+          id: decoded.id,
+          error: decoded.error
+        })) : httpEffect));
+      }
+    }));
+  });
+  return protocol;
+}));
+const INTERNAL_TOOL_ERROR_MESSAGE = "Tool execution failed due to an internal server error.";
+const toolErrorResult = message => new CallToolResult({
+  isError: true,
+  content: [{
+    type: "text",
+    text: message
+  }]
+});
 /**
  * Registers a `Toolkit` with the `McpServer`.
  *
- * @category tools
+ * @category handlers
  * @since 4.0.0
  */
 export const registerToolkit = /*#__PURE__*/Effect.fnUntraced(function* (toolkit) {
@@ -473,10 +886,15 @@ export const registerToolkit = /*#__PURE__*/Effect.fnUntraced(function* (toolkit
   for (const tool of Object.values(built.tools)) {
     const annotations = tool.annotations;
     const toolMeta = Context.getOrUndefined(annotations, Tool.Meta);
+    const isDeclaredFailure = Schema.is(tool.failureSchema);
+    const outputSchema = Tool.getJsonSchemaFromSchema(tool.successSchema);
     const mcpTool = new McpTool({
       name: tool.name,
       description: Tool.getDescription(tool),
       inputSchema: Tool.getJsonSchema(tool),
+      ...(outputSchema.type === "object" ? {
+        outputSchema
+      } : {}),
       annotations: {
         ...Context.getOption(tool.annotations, Tool.Title).pipe(Option.map(title => ({
           title
@@ -492,23 +910,26 @@ export const registerToolkit = /*#__PURE__*/Effect.fnUntraced(function* (toolkit
       tool: mcpTool,
       annotations,
       handle(payload) {
-        return built.handle(tool.name, payload).pipe(Stream.unwrap, Stream.run(Sink.last()), Effect.flatMap(Effect.fromOption), Effect.provideContext(services), Effect.matchCause({
-          onFailure: cause => new CallToolResult({
-            isError: true,
-            content: [{
-              type: "text",
-              text: Cause.pretty(cause)
-            }]
-          }),
-          onSuccess: result => new CallToolResult({
-            isError: false,
-            structuredContent: typeof result.encodedResult === "object" ? result.encodedResult : undefined,
-            content: [{
-              type: "text",
-              text: JSON.stringify(result.encodedResult)
-            }]
-          })
-        }), Effect.tapCause(Effect.log));
+        return built.handle(tool.name, payload).pipe(Stream.unwrap, Stream.run(Sink.last()), Effect.flatMap(Effect.fromOption), Effect.provideContext(services), Effect.map(result => new CallToolResult({
+          isError: false,
+          structuredContent: typeof result.encodedResult === "object" ? result.encodedResult : undefined,
+          content: result.encodedResult === undefined ? [] : [{
+            type: "text",
+            text: JSON.stringify(result.encodedResult)
+          }]
+        })), Effect.tapCause(Effect.logError), Effect.catch(error => {
+          if (AiError.isAiError(error)) {
+            const reason = error.reason;
+            return reason._tag === "ToolParameterValidationError" ? Effect.fail(new InvalidParams({
+              message: reason.message
+            })) : Effect.succeed(toolErrorResult(INTERNAL_TOOL_ERROR_MESSAGE));
+          }
+          if (isDeclaredFailure(error)) {
+            const message = error instanceof Error ? error.message : INTERNAL_TOOL_ERROR_MESSAGE;
+            return Effect.succeed(toolErrorResult(message));
+          }
+          return Effect.succeed(toolErrorResult(INTERNAL_TOOL_ERROR_MESSAGE));
+        }), Effect.catchDefect(() => Effect.succeed(toolErrorResult(INTERNAL_TOOL_ERROR_MESSAGE))));
       }
     });
   }
@@ -516,7 +937,7 @@ export const registerToolkit = /*#__PURE__*/Effect.fnUntraced(function* (toolkit
 /**
  * Registers an `AiToolkit` with the `McpServer`.
  *
- * @category tools
+ * @category layers
  * @since 4.0.0
  */
 export const toolkit = toolkit => Layer.effectDiscard(registerToolkit(toolkit)).pipe(Layer.provide(McpServer.layer));
@@ -531,7 +952,7 @@ export const toolkit = toolkit => Layer.effectDiscard(registerToolkit(toolkit)).
  *
  * @see {@link resource} for the layer-based resource registration wrapper
  *
- * @category resources
+ * @category handlers
  * @since 4.0.0
  */
 export const registerResource = function () {
@@ -570,10 +991,10 @@ export const registerResource = function () {
       uriTemplate: uriPath,
       annotations: options
     });
-    const completions = {};
+    const completions = Object.create(null);
     for (const [param, handle] of Object.entries(options.completion ?? {})) {
       const encodeArray = Schema.encodeUnknownEffect(Schema.Array(params[param]));
-      const handler = input => handle(input).pipe(Effect.flatMap(encodeArray), Effect.map(values => ({
+      const handler = (input, context) => handle(input, context).pipe(Effect.flatMap(encodeArray), Effect.map(values => ({
         completion: {
           values: values,
           total: values.length,
@@ -612,7 +1033,7 @@ export const registerResource = function () {
  *
  * @see {@link registerResource} for the Effect-level resource registration API
  *
- * @category resources
+ * @category layers
  * @since 4.0.0
  */
 export const resource = function () {
@@ -638,7 +1059,7 @@ export const resource = function () {
  *
  * @see {@link prompt} for the layer-based prompt registration wrapper
  *
- * @category prompts
+ * @category handlers
  * @since 4.0.0
  */
 export const registerPrompt = options => {
@@ -661,10 +1082,10 @@ export const registerPrompt = options => {
   return Effect.gen(function* () {
     const registry = yield* McpServer;
     const services = yield* Effect.context();
-    const completions = {};
+    const completions = Object.create(null);
     for (const [param, handle] of Object.entries(completion)) {
       const encodeArray = Schema.encodeEffect(Schema.Array(props[param]));
-      const handler = input => handle(input).pipe(Effect.flatMap(encodeArray), Effect.map(values => ({
+      const handler = (input, context) => handle(input, context).pipe(Effect.flatMap(encodeArray), Effect.map(values => ({
         completion: {
           values: values,
           total: values.length,
@@ -684,7 +1105,7 @@ export const registerPrompt = options => {
       annotations: options.annotations ?? Context.empty(),
       handle: params => decode(params).pipe(Effect.mapError(error => new InvalidParams({
         message: error.message
-      })), Effect.flatMap(params => options.content(params)), Effect.map(messages => {
+      })), Effect.flatMap(params => options.content(params).pipe(Effect.map(messages => {
         messages = typeof messages === "string" ? [{
           role: "user",
           content: TextContent.make({
@@ -700,7 +1121,7 @@ export const registerPrompt = options => {
         return Effect.fail(new InternalError({
           message: prettyError.message
         }));
-      }), Effect.provideContext(services))
+      }))), Effect.provideContext(services))
     });
   });
 };
@@ -719,7 +1140,7 @@ export const registerPrompt = options => {
  *
  * @see {@link registerPrompt} for the Effect-level prompt registration API
  *
- * @category prompts
+ * @category layers
  * @since 4.0.0
  */
 export const prompt = options => Layer.effectDiscard(registerPrompt(options)).pipe(Layer.provide(McpServer.layer));
@@ -732,7 +1153,7 @@ export const prompt = options => Layer.effectDiscard(registerPrompt(options)).pi
  * Accepted content is decoded with the supplied schema, declined requests fail
  * with `ElicitationDeclined`, and canceled requests interrupt the effect.
  *
- * @category elicitation
+ * @category accessors
  * @since 4.0.0
  */
 export const elicit = /*#__PURE__*/Effect.fnUntraced(function* (options) {
@@ -763,7 +1184,7 @@ export const elicit = /*#__PURE__*/Effect.fnUntraced(function* (options) {
 /**
  * Accesses the current client's capabilities.
  *
- * @category capabilities
+ * @category accessors
  * @since 4.0.0
  */
 export const clientCapabilities = /*#__PURE__*/McpServerClient.useSync(_ => _.initializePayload.capabilities);
@@ -788,7 +1209,7 @@ const makeUriMatcher = () => {
 const compileUriTemplate = (segments, ...schemas) => {
   let routerPath = segments[0].replace(":", "::");
   let uriPath = segments[0];
-  const params = {};
+  const params = Object.create(null);
   let pathSchema = Schema.Tuple([]);
   if (schemas.length > 0) {
     const arr = [];
@@ -812,138 +1233,196 @@ const compileUriTemplate = (segments, ...schemas) => {
     params
   };
 };
-const layerHandlers = (serverInfo, options) => ClientRpcs.toLayer(Effect.gen(function* () {
+const layerHandlers = (serverInfo, options) => Layer.effectContext(Effect.gen(function* () {
   const server = yield* McpServer;
-  let currentLogLevel = yield* CurrentLogLevel;
-  return ClientRpcs.of({
-    // Requests
-    ping: () => Effect.succeed({}),
-    initialize(params, {
-      client
-    }) {
-      const requestedVersion = SUPPORTED_PROTOCOL_VERSIONS.includes(params.protocolVersion) ? params.protocolVersion : LATEST_PROTOCOL_VERSION;
-      if (requestedVersion !== params.protocolVersion) {
-        params = {
-          ...params,
-          protocolVersion: requestedVersion
-        };
-      }
-      const capabilities = {
-        completions: {}
-      };
-      if (server.tools.length > 0) {
-        capabilities.tools = {
-          listChanged: true
-        };
-      }
-      if (server.resources.length > 0 || server.resourceTemplates.length > 0) {
-        capabilities.resources = {
-          listChanged: true,
-          subscribe: false
-        };
-      }
-      if (server.prompts.length > 0) {
-        capabilities.prompts = {
-          listChanged: true
+  const currentLogLevel = yield* CurrentLogLevel;
+  const contextMap = new Map();
+  for (const protocol of options.protocolRegistry.protocols) {
+    const selectedProtocol = protocol;
+    const wireHandlers = ClientRpcs.of({
+      // Requests
+      ping: () => Effect.succeed({}),
+      initialize(params, {
+        client
+      }) {
+        const capabilities = {
+          completions: {},
+          logging: {}
         };
-      }
-      if (serverInfo.extensions) {
-        capabilities.extensions = serverInfo.extensions;
-      }
-      return Effect.withFiber(fiber => {
-        const httpRequest = Context.getOrUndefined(fiber.context, HttpServerRequest.HttpServerRequest);
-        if (httpRequest) {
-          const sessionId = crypto.randomUUID();
-          options.clientSessions.set(sessionId, params);
-          appendPreResponseHandlerUnsafe(httpRequest, (_req, res) => Effect.succeed(HttpServerResponse.setHeaders(res, {
-            [mcpSessionIdHeader]: sessionId,
-            [mcpProtocolVersionHeader]: requestedVersion
-          })));
-        } else {
-          options.clientSessions.set(String(client.id), params);
+        if (server.tools.length > 0) {
+          capabilities.tools = {
+            listChanged: true
+          };
+        }
+        if (server.resources.length > 0 || server.resourceTemplates.length > 0) {
+          capabilities.resources = {
+            listChanged: true,
+            subscribe: true
+          };
+        }
+        if (server.prompts.length > 0) {
+          capabilities.prompts = {
+            listChanged: true
+          };
         }
-        return Effect.succeed({
-          capabilities,
-          serverInfo,
-          protocolVersion: requestedVersion
+        if (serverInfo.extensions) {
+          capabilities.extensions = serverInfo.extensions;
+        }
+        return Effect.withFiber(fiber => {
+          const httpRequest = Context.getOrUndefined(fiber.context, HttpServerRequest.HttpServerRequest);
+          if (httpRequest !== undefined && capabilities.resources !== undefined) {
+            capabilities.resources.subscribe = false;
+          }
+          const session = {
+            initializePayload: params,
+            protocol: selectedProtocol,
+            resourceSubscriptions: capabilities.resources?.subscribe === true ? new Set() : undefined,
+            logLevel: {
+              _tag: "Effect",
+              level: currentLogLevel
+            }
+          };
+          if (httpRequest) {
+            const sessionId = crypto.randomUUID();
+            options.sessions.bySessionId.set(sessionId, session);
+            appendPreResponseHandlerUnsafe(httpRequest, (_req, res) => Effect.succeed(HttpServerResponse.setHeaders(res, {
+              [MCP_SESSION_ID_HEADER]: sessionId,
+              [MCP_PROTOCOL_VERSION_HEADER]: selectedProtocol.protocolVersion
+            })));
+          } else {
+            options.sessions.byClientId.set(client.id, session);
+          }
+          return Effect.succeed({
+            capabilities,
+            serverInfo,
+            protocolVersion: selectedProtocol.protocolVersion
+          });
         });
-      });
-    },
-    "completion/complete": r => server.completion(r).pipe(Effect.provideService(CurrentLogLevel, currentLogLevel)),
-    "logging/setLevel": ({
-      level
-    }) => Effect.sync(() => {
-      switch (level) {
-        case "notice":
-        case "info":
-          currentLogLevel = "Info";
-          break;
-        case "error":
-          currentLogLevel = "Error";
-          break;
-        case "debug":
-          currentLogLevel = "Debug";
-          break;
-        case "warning":
-          currentLogLevel = "Warn";
-          break;
-        case "critical":
-        case "alert":
-        case "emergency":
-          currentLogLevel = "Fatal";
-          break;
-      }
-    }),
-    "prompts/get": r => server.getPromptResult(r).pipe(Effect.provideService(CurrentLogLevel, currentLogLevel)),
-    "prompts/list": (_, {
-      client,
-      headers
-    }) => Effect.sync(() => {
-      const initialized = getInitializedClient(options.clientSessions, client.id, headers);
-      return new ListPromptsResult({
-        prompts: filterByClient(initialized, server.prompts, "prompt")
-      });
-    }),
-    "resources/list": (_, {
-      client,
-      headers
-    }) => Effect.sync(() => {
-      const initialized = getInitializedClient(options.clientSessions, client.id, headers);
-      return new ListResourcesResult({
-        resources: filterByClient(initialized, server.resources, "resource")
-      });
-    }),
-    "resources/read": ({
-      uri
-    }) => server.findResource(uri).pipe(Effect.provideService(CurrentLogLevel, currentLogLevel)),
-    "resources/subscribe": () => InternalError.notImplemented,
-    "resources/unsubscribe": () => InternalError.notImplemented,
-    "resources/templates/list": (_, {
-      client,
-      headers
-    }) => Effect.sync(() => {
-      const initialized = getInitializedClient(options.clientSessions, client.id, headers);
-      return new ListResourceTemplatesResult({
-        resourceTemplates: filterByClient(initialized, server.resourceTemplates, "template")
-      });
-    }),
-    "tools/call": r => server.callTool(r).pipe(Effect.provideService(CurrentLogLevel, currentLogLevel)),
-    "tools/list": (_, {
-      client,
-      headers
-    }) => Effect.sync(() => {
-      const initialized = getInitializedClient(options.clientSessions, client.id, headers);
-      return new ListToolsResult({
-        tools: filterByClient(initialized, server.tools, "tool")
-      });
-    }),
-    // Notifications
-    "notifications/cancelled": _ => Effect.void,
-    "notifications/initialized": _ => Effect.void,
-    "notifications/progress": _ => Effect.void,
-    "notifications/roots/list_changed": _ => Effect.void
-  });
+      },
+      "completion/complete": r => server.completion(r),
+      "logging/setLevel": ({
+        level
+      }, {
+        client,
+        headers
+      }) => Effect.sync(() => {
+        const session = getClientSession(options.sessions, client.id, headers);
+        if (session) {
+          session.logLevel = {
+            _tag: "Mcp",
+            level
+          };
+        }
+        return {};
+      }),
+      "prompts/get": r => server.getPromptResult(r),
+      "prompts/list": (_, {
+        client,
+        headers
+      }) => Effect.sync(() => {
+        const initialized = getClientSession(options.sessions, client.id, headers)?.initializePayload;
+        return new ListPromptsResult({
+          prompts: filterByClient(initialized, server.prompts, "prompt")
+        });
+      }),
+      "resources/list": (_, {
+        client,
+        headers
+      }) => Effect.sync(() => {
+        const initialized = getClientSession(options.sessions, client.id, headers)?.initializePayload;
+        return new ListResourcesResult({
+          resources: filterByClient(initialized, server.resources, "resource")
+        });
+      }),
+      "resources/read": ({
+        uri
+      }) => server.findResource(uri),
+      "resources/subscribe": ({
+        uri
+      }, {
+        client,
+        headers
+      }) => Effect.gen(function* () {
+        const subscriptions = getClientSession(options.sessions, client.id, headers)?.resourceSubscriptions;
+        if (subscriptions === undefined) {
+          return yield* new MethodNotFound({
+            message: "Resource subscriptions are not supported"
+          });
+        }
+        subscriptions.add(uri);
+        return {};
+      }),
+      "resources/unsubscribe": ({
+        uri
+      }, {
+        client,
+        headers
+      }) => Effect.gen(function* () {
+        const subscriptions = getClientSession(options.sessions, client.id, headers)?.resourceSubscriptions;
+        if (subscriptions === undefined) {
+          return yield* new MethodNotFound({
+            message: "Resource subscriptions are not supported"
+          });
+        }
+        subscriptions.delete(uri);
+        return {};
+      }),
+      "resources/templates/list": (_, {
+        client,
+        headers
+      }) => Effect.sync(() => {
+        const initialized = getClientSession(options.sessions, client.id, headers)?.initializePayload;
+        return new ListResourceTemplatesResult({
+          resourceTemplates: filterByClient(initialized, server.resourceTemplates, "template")
+        });
+      }),
+      "tools/call": r => server.callTool(r),
+      "tools/list": (_, {
+        client,
+        headers
+      }) => Effect.sync(() => {
+        const initialized = getClientSession(options.sessions, client.id, headers)?.initializePayload;
+        return new ListToolsResult({
+          tools: filterByClient(initialized, server.tools, "tool")
+        });
+      }),
+      // Notifications
+      "notifications/cancelled": _ => Effect.void,
+      "notifications/initialized": (_, {
+        client,
+        headers
+      }) => Effect.sync(() => {
+        server.initializedClients.add(client.id);
+        const session = getClientSession(options.sessions, client.id, headers);
+        if (session) {
+          options.sessions.byClientId.set(client.id, session);
+        }
+      }),
+      "notifications/progress": _ => Effect.void,
+      "notifications/roots/list_changed": _ => Effect.void
+    });
+    yield* addProtocolHandlers(options.protocolRegistry, selectedProtocol, selectedProtocol.clientRpcs, wireHandlers, contextMap);
+  }
+  return Context.makeUnsafe(contextMap);
 }));
+const addProtocolHandlers = /*#__PURE__*/Effect.fnUntraced(function* (registry, protocol, clientRpcs, handlers, contextMap) {
+  const handlerContext = yield* clientRpcs.toHandlers(handlers);
+  for (const rpcDefinition of clientRpcs.requests.values()) {
+    const routed = registry.routeClientRequest(protocol, {
+      _tag: "Request",
+      id: 0,
+      tag: rpcDefinition._tag,
+      payload: undefined,
+      headers: []
+    });
+    const namespacedRpc = registry.clientRpcs.requests.get(routed.tag);
+    const handler = handlerContext.mapUnsafe.get(rpcDefinition.key);
+    if (namespacedRpc === undefined || handler === undefined) {
+      return yield* Effect.die(`MCP handler registration invariant failed for ${routed.tag}`);
+    }
+    contextMap.set(namespacedRpc.key, handler);
+  }
+});
 const resolveResourceContent = (uri, content) => {
   if (typeof content === "string") {
     return {
@@ -976,11 +1455,64 @@ const filterByClient = (client, items, prop) => {
   }
   return out;
 };
-const getInitializedClient = (sessions, clientId, headers) => {
-  const sessionId = headers[mcpSessionIdHeader];
+const getClientSession = (sessions, clientId, headers) => {
+  const sessionId = headers[MCP_SESSION_ID_HEADER];
   if (sessionId === undefined) {
-    return sessions.get(String(clientId));
+    return sessions.byClientId.get(clientId);
+  }
+  return sessions.bySessionId.get(sessionId);
+};
+const mcpLogLevels = {
+  debug: {
+    effect: "Debug",
+    order: 0
+  },
+  info: {
+    effect: "Info",
+    order: 1
+  },
+  notice: {
+    effect: "Info",
+    order: 2
+  },
+  warning: {
+    effect: "Warn",
+    order: 3
+  },
+  error: {
+    effect: "Error",
+    order: 4
+  },
+  critical: {
+    effect: "Fatal",
+    order: 5
+  },
+  alert: {
+    effect: "Fatal",
+    order: 6
+  },
+  emergency: {
+    effect: "Fatal",
+    order: 7
+  }
+};
+const effectLogLevel = logLevel => logLevel?._tag === "Mcp" ? mcpLogLevels[logLevel.level].effect : logLevel?.level ?? "Info";
+const isMcpLogLevelEnabled = (level, minimum) => minimum?._tag === "Mcp" ? mcpLogLevels[level].order >= mcpLogLevels[minimum.level].order : LogLevel.isGreaterThanOrEqualTo(mcpLogLevels[level].effect, minimum?.level ?? "Info");
+const getOfferedProtocolVersion = payload => typeof payload === "object" && payload !== null && "protocolVersion" in payload && typeof payload.protocolVersion === "string" ? payload.protocolVersion : "";
+const protocolForInternalTag = (registry, tag) => {
+  for (const protocol of registry.protocols) {
+    const routed = registry.routeClientRequest(protocol, {
+      _tag: "Request",
+      id: 0,
+      tag: "",
+      payload: undefined,
+      headers: []
+    });
+    if (tag.startsWith(routed.tag)) {
+      return protocol;
+    }
   }
-  return sessions.get(sessionId);
+  return registry.protocols[0];
 };
+const getProtocolForClient = (clientProtocols, clientId, registry) => clientProtocols.get(clientId) ?? registry.protocols[0];
 //# sourceMappingURL=McpServer.js.map