Classify dispatched messages with a shared JsonRpc2Object

Author: Yusufihsangorgel

pkgs/dart_mcp/lib/src/server/request_scoped.dart

@@ -71,26 +71,27 @@ Future<Map<String, Object?>?> handleRequestScopedMessage(
   MCPServerFactory serverFactory, {
   void Function(Map<String, Object?> notification)? onNotification,
 }) async {
-  final method = message[Keys.method];
-  if (method is! String) {
+  final object = JsonRpc2Object.fromMap(message);
+  if (object.kind == JsonRpc2Kind.response) {
     throw ArgumentError.value(
       message,
       'message',
-      'A dispatched message must have a string method',
+      'A request or notification must not carry a result or error',
     );
   }
-  if (message.containsKey(Keys.id) && message[Keys.id] == null) {
+  final method = object.method;
+  if (method is! String) {
     throw ArgumentError.value(
       message,
       'message',
-      'A request id must not be null',
+      'A dispatched message must have a string method',
     );
   }
-  if (message.containsKey(Keys.result) || message.containsKey(Keys.error)) {
+  if (object.kind == JsonRpc2Kind.request && object.id == null) {
     throw ArgumentError.value(
       message,
       'message',
-      'A request or notification must not carry a result or error',
+      'A request id must not be null',
     );
   }
   if (method == InitializeRequest.methodName ||
@@ -112,14 +113,14 @@ Future<Map<String, Object?>?> handleRequestScopedMessage(
     StreamChannel.withCloseGuarantee(inbound.stream, outbound.sink),
   );
 
-  final isRequest = message.containsKey(Keys.id);
+  final isRequest = object.kind == JsonRpc2Kind.request;
   final response = Completer<Map<String, Object?>?>();
   final subscription = outbound.stream.listen(
     (encoded) {
       try {
         final decoded = (jsonDecode(encoded) as Map).cast<String, Object?>();
-        if (decoded.containsKey(Keys.method)) {
-          if (decoded.containsKey(Keys.id)) {
+        switch (JsonRpc2Object.fromMap(decoded).kind) {
+          case JsonRpc2Kind.request:
             // A request from the server to the client. Nothing can answer it
             // in a single-message exchange, so fail it back to the server
             // instead of leaving its handler waiting forever. Late requests
@@ -129,24 +130,27 @@ Future<Map<String, Object?>?> handleRequestScopedMessage(
               inbound.add(
                 jsonEncode(
                   _errorResponse(
-                    decoded[Keys.id],
+                    JsonRpc2Request.fromMap(decoded).id,
                     'Server to client requests are not supported on a '
                     'request-scoped transport',
                   ),
                 ),
               );
             }
-          } else {
+          case JsonRpc2Kind.notification:
             try {
               onNotification?.call(decoded);
             } catch (error, stackTrace) {
               // A misbehaving callback must not fail the request being
               // handled, but it should still be visible.
               Zone.current.handleUncaughtError(error, stackTrace);
             }
-          }
-        } else if (!response.isCompleted) {
-          response.complete(_withServerInfo(decoded, server.implementation));
+          case JsonRpc2Kind.response:
+            if (!response.isCompleted) {
+              response.complete(
+                _withServerInfo(decoded, server.implementation),
+              );
+            }
         }
       } catch (error, stackTrace) {
         // The server sent a frame we could not process. Never let it wedge or
@@ -205,11 +209,11 @@ Map<String, Object?> _withServerInfo(
   Map<String, Object?> response,
   Implementation implementation,
 ) {
-  final result = response[Keys.result];
+  final result = JsonRpc2Response.fromMap(response).result;
   if (result is! Map) return response;
-  final existingMeta = result[Keys.meta];
-  if (existingMeta is! Map?) return response;
   final resultMap = result.cast<String, Object?>();
+  final existingMeta = resultMap[Keys.meta];
+  if (existingMeta is! Map?) return response;
   final meta = existingMeta?.cast<String, Object?>() ?? <String, Object?>{};
   // Copy so the returned response does not alias the shared server info map.
   meta.putIfAbsent(

pkgs/dart_mcp/lib/src/server/server.dart

@@ -14,6 +14,7 @@ import 'package:stream_transform/stream_transform.dart';
 import '../api/api.dart';
 import '../shared.dart';
 import '../utils/constants.dart';
+import '../utils/json_rpc_2_object.dart';
 
 part 'completions_support.dart';
 part 'elicitation_request_support.dart';

pkgs/dart_mcp/lib/src/utils/constants.dart

@@ -84,6 +84,7 @@ extension Keys on Never {
   static const oneOf = 'oneOf';
   static const openWorldHint = 'openWorldHint';
   static const outputSchema = 'outputSchema';
+  static const params = 'params';
   static const path = 'path';
   static const pattern = 'pattern';
   static const patternProperties = 'patternProperties';

pkgs/dart_mcp/lib/src/utils/json_rpc_2_object.dart

@@ -0,0 +1,40 @@
+// Copyright (c) 2026, the Dart project authors.  Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+import 'constants.dart';
+
+/// The kind of a decoded JSON-RPC 2.0 message.
+enum JsonRpc2Kind { request, notification, response }
+
+/// A decoded JSON-RPC 2.0 message.
+extension type JsonRpc2Object.fromMap(Map<String, Object?> _value) {
+  /// The kind of this message.
+  ///
+  /// A message with a `result` or `error` member is a response, any other
+  /// message with an `id` member is a request, and the rest are
+  /// notifications.
+  JsonRpc2Kind get kind =>
+      _value.containsKey(Keys.result) || _value.containsKey(Keys.error)
+          ? JsonRpc2Kind.response
+          : _value.containsKey(Keys.id)
+          ? JsonRpc2Kind.request
+          : JsonRpc2Kind.notification;
+
+  /// The method of this message, if it is a request or notification.
+  Object? get method => _value[Keys.method];
+
+  /// The id of this message, if it is a request or response.
+  Object? get id => _value[Keys.id];
+}
+
+/// A decoded JSON-RPC 2.0 request.
+extension type JsonRpc2Request.fromMap(Map<String, Object?> _value)
+    implements JsonRpc2Object {}
+
+/// A decoded JSON-RPC 2.0 response.
+extension type JsonRpc2Response.fromMap(Map<String, Object?> _value)
+    implements JsonRpc2Object {
+  /// The result of this response, if it is a success response.
+  Object? get result => _value[Keys.result];
+}