mcp 0.3.0 → 0.5.0

data/lib/mcp/methods.rb

@@ -21,6 +21,7 @@ module MCP
 
     ROOTS_LIST = "roots/list"
     SAMPLING_CREATE_MESSAGE = "sampling/createMessage"
+    ELICITATION_CREATE = "elicitation/create"
 
     # Notification methods
     NOTIFICATIONS_INITIALIZED = "notifications/initialized"
@@ -76,6 +77,8 @@ module MCP
           require_capability!(method, capabilities, :roots, :listChanged)
         when SAMPLING_CREATE_MESSAGE
           require_capability!(method, capabilities, :sampling)
+        when ELICITATION_CREATE
+          require_capability!(method, capabilities, :elicitation)
         when INITIALIZE, PING, NOTIFICATIONS_INITIALIZED, NOTIFICATIONS_PROGRESS, NOTIFICATIONS_CANCELLED
           # No specific capability required for initialize, ping, progress or cancelled
         end

data/lib/mcp/prompt/argument.rb

@@ -1,20 +1,24 @@
-# typed: strict
 # frozen_string_literal: true
 
 module MCP
   class Prompt
     class Argument
-      attr_reader :name, :description, :required, :arguments
+      attr_reader :name, :title, :description, :required
 
-      def initialize(name:, description: nil, required: false)
+      def initialize(name:, title: nil, description: nil, required: false)
         @name = name
+        @title = title
         @description = description
         @required = required
-        @arguments = arguments
       end
 
       def to_h
-        { name:, description:, required: }.compact
+        {
+          name: name,
+          title: title,
+          description: description,
+          required: required,
+        }.compact
       end
     end
   end

data/lib/mcp/prompt/message.rb

@@ -1,4 +1,3 @@
-# typed: strict
 # frozen_string_literal: true
 
 module MCP
@@ -12,7 +11,7 @@ module MCP
       end
 
       def to_h
-        { role:, content: content.to_h }.compact
+        { role: role, content: content.to_h }.compact
       end
     end
   end

data/lib/mcp/prompt/result.rb

@@ -1,4 +1,3 @@
-# typed: strict
 # frozen_string_literal: true
 
 module MCP
@@ -12,7 +11,7 @@ module MCP
       end
 
       def to_h
-        { description:, messages: messages.map(&:to_h) }.compact
+        { description: description, messages: messages.map(&:to_h) }.compact
       end
     end
   end

data/lib/mcp/prompt.rb

@@ -1,4 +1,3 @@
-# typed: strict
 # frozen_string_literal: true
 
 module MCP
@@ -8,14 +7,23 @@ module MCP
 
       attr_reader :title_value
       attr_reader :description_value
+      attr_reader :icons_value
       attr_reader :arguments_value
+      attr_reader :meta_value
 
       def template(args, server_context: nil)
         raise NotImplementedError, "Subclasses must implement template"
       end
 
       def to_h
-        { name: name_value, title: title_value, description: description_value, arguments: arguments_value.map(&:to_h) }.compact
+        {
+          name: name_value,
+          title: title_value,
+          description: description_value,
+          icons: icons&.map(&:to_h),
+          arguments: arguments_value&.map(&:to_h),
+          _meta: meta_value,
+        }.compact
       end
 
       def inherited(subclass)
@@ -23,7 +31,9 @@ module MCP
         subclass.instance_variable_set(:@name_value, nil)
         subclass.instance_variable_set(:@title_value, nil)
         subclass.instance_variable_set(:@description_value, nil)
+        subclass.instance_variable_set(:@icons_value, nil)
         subclass.instance_variable_set(:@arguments_value, nil)
+        subclass.instance_variable_set(:@meta_value, nil)
       end
 
       def prompt_name(value = NOT_SET)
@@ -54,6 +64,14 @@ module MCP
         end
       end
 
+      def icons(value = NOT_SET)
+        if value == NOT_SET
+          @icons_value
+        else
+          @icons_value = value
+        end
+      end
+
       def arguments(value = NOT_SET)
         if value == NOT_SET
           @arguments_value
@@ -62,15 +80,25 @@ module MCP
         end
       end
 
-      def define(name: nil, title: nil, description: nil, arguments: [], &block)
+      def meta(value = NOT_SET)
+        if value == NOT_SET
+          @meta_value
+        else
+          @meta_value = value
+        end
+      end
+
+      def define(name: nil, title: nil, description: nil, icons: [], arguments: [], meta: nil, &block)
         Class.new(self) do
           prompt_name name
           title title
           description description
+          icons icons
           arguments arguments
           define_singleton_method(:template) do |args, server_context: nil|
-            instance_exec(args, server_context:, &block)
+            instance_exec(args, server_context: server_context, &block)
           end
+          meta meta
         end
       end
 

data/lib/mcp/resource/contents.rb

@@ -1,4 +1,3 @@
-# typed: strict
 # frozen_string_literal: true
 
 module MCP
@@ -12,7 +11,7 @@ module MCP
       end
 
       def to_h
-        { uri:, mime_type: }.compact
+        { uri: uri, mime_type: mime_type }.compact
       end
     end
 

data/lib/mcp/resource/embedded.rb

@@ -1,4 +1,3 @@
-# typed: strict
 # frozen_string_literal: true
 
 module MCP
@@ -11,7 +10,7 @@ module MCP
       end
 
       def to_h
-        { resource: resource.to_h, annotations: }.compact
+        { resource: resource.to_h, annotations: annotations }.compact
       end
     end
   end

data/lib/mcp/resource.rb

@@ -1,15 +1,15 @@
-# typed: strict
 # frozen_string_literal: true
 
 module MCP
   class Resource
-    attr_reader :uri, :name, :title, :description, :mime_type
+    attr_reader :uri, :name, :title, :description, :icons, :mime_type
 
-    def initialize(uri:, name:, title: nil, description: nil, mime_type: nil)
+    def initialize(uri:, name:, title: nil, description: nil, icons: [], mime_type: nil)
       @uri = uri
       @name = name
       @title = title
       @description = description
+      @icons = icons
       @mime_type = mime_type
     end
 
@@ -19,6 +19,7 @@ module MCP
         name: name,
         title: title,
         description: description,
+        icons: icons.map(&:to_h),
         mimeType: mime_type,
       }.compact
     end

data/lib/mcp/resource_template.rb

@@ -1,15 +1,15 @@
-# typed: strict
 # frozen_string_literal: true
 
 module MCP
   class ResourceTemplate
-    attr_reader :uri_template, :name, :title, :description, :mime_type
+    attr_reader :uri_template, :name, :title, :description, :icons, :mime_type
 
-    def initialize(uri_template:, name:, title: nil, description: nil, mime_type: nil)
+    def initialize(uri_template:, name:, title: nil, description: nil, icons: [], mime_type: nil)
       @uri_template = uri_template
       @name = name
       @title = title
       @description = description
+      @icons = icons
       @mime_type = mime_type
     end
 
@@ -19,6 +19,7 @@ module MCP
         name: name,
         title: title,
         description: description,
+        icons: icons.map(&:to_h),
         mimeType: mime_type,
       }.compact
     end

data/lib/mcp/server/transports/streamable_http_transport.rb

@@ -8,13 +8,18 @@ module MCP
   class Server
     module Transports
       class StreamableHTTPTransport < Transport
-        def initialize(server)
-          super
+        def initialize(server, stateless: false)
+          super(server)
           # { session_id => { stream: stream_object }
           @sessions = {}
           @mutex = Mutex.new
+
+          @stateless = stateless
         end
 
+        REQUIRED_POST_ACCEPT_TYPES = ["application/json", "text/event-stream"].freeze
+        REQUIRED_GET_ACCEPT_TYPES = ["text/event-stream"].freeze
+
         def handle_request(request)
           case request.env["REQUEST_METHOD"]
           when "POST"
@@ -24,7 +29,7 @@ module MCP
           when "DELETE"
             handle_delete(request)
           else
-            [405, { "Content-Type" => "application/json" }, [{ error: "Method not allowed" }.to_json]]
+            method_not_allowed_response
           end
         end
 
@@ -35,9 +40,12 @@ module MCP
         end
 
         def send_notification(method, params = nil, session_id: nil)
+          # Stateless mode doesn't support notifications
+          raise "Stateless mode does not support notifications" if @stateless
+
           notification = {
             jsonrpc: "2.0",
-            method:,
+            method: method,
           }
           notification[:params] = params if params
 
@@ -100,6 +108,9 @@ module MCP
         end
 
         def handle_post(request)
+          accept_error = validate_accept_header(request, REQUIRED_POST_ACCEPT_TYPES)
+          return accept_error if accept_error
+
           body_string = request.body.read
           session_id = extract_session_id(request)
 
@@ -108,8 +119,8 @@ module MCP
 
           if body["method"] == "initialize"
             handle_initialization(body_string, body)
-          elsif body["method"] == MCP::Methods::NOTIFICATIONS_INITIALIZED
-            handle_notification_initialized
+          elsif notification?(body) || response?(body)
+            handle_accepted
           else
             handle_regular_request(body_string, session_id)
           end
@@ -119,6 +130,13 @@ module MCP
         end
 
         def handle_get(request)
+          if @stateless
+            return method_not_allowed_response
+          end
+
+          accept_error = validate_accept_header(request, REQUIRED_GET_ACCEPT_TYPES)
+          return accept_error if accept_error
+
           session_id = extract_session_id(request)
 
           return missing_session_id_response unless session_id
@@ -128,6 +146,13 @@ module MCP
         end
 
         def handle_delete(request)
+          success_response = [200, { "Content-Type" => "application/json" }, [{ success: true }.to_json]]
+
+          if @stateless
+            # Stateless mode doesn't support sessions, so we can just return a success response
+            return success_response
+          end
+
           session_id = request.env["HTTP_MCP_SESSION_ID"]
 
           return [
@@ -137,7 +162,7 @@ module MCP
           ] unless session_id
 
           cleanup_session(session_id)
-          [200, { "Content-Type" => "application/json" }, [{ success: true }.to_json]]
+          success_response
         end
 
         def cleanup_session(session_id)
@@ -162,51 +187,100 @@ module MCP
           request.env["HTTP_MCP_SESSION_ID"]
         end
 
+        def validate_accept_header(request, required_types)
+          accept_header = request.env["HTTP_ACCEPT"]
+          return not_acceptable_response(required_types) unless accept_header
+
+          accepted_types = parse_accept_header(accept_header)
+          missing_types = required_types - accepted_types
+          return not_acceptable_response(required_types) unless missing_types.empty?
+
+          nil
+        end
+
+        def parse_accept_header(header)
+          header.split(",").map do |part|
+            part.split(";").first.strip
+          end
+        end
+
+        def not_acceptable_response(required_types)
+          [
+            406,
+            { "Content-Type" => "application/json" },
+            [{ error: "Not Acceptable: Accept header must include #{required_types.join(" and ")}" }.to_json],
+          ]
+        end
+
         def parse_request_body(body_string)
           JSON.parse(body_string)
         rescue JSON::ParserError, TypeError
           [400, { "Content-Type" => "application/json" }, [{ error: "Invalid JSON" }.to_json]]
         end
 
+        def notification?(body)
+          !body["id"] && !!body["method"]
+        end
+
+        def response?(body)
+          !!body["id"] && !body["method"]
+        end
+
         def handle_initialization(body_string, body)
-          session_id = SecureRandom.uuid
+          session_id = nil
 
-          @mutex.synchronize do
-            @sessions[session_id] = {
-              stream: nil,
-            }
+          unless @stateless
+            session_id = SecureRandom.uuid
+
+            @mutex.synchronize do
+              @sessions[session_id] = {
+                stream: nil,
+              }
+            end
           end
 
           response = @server.handle_json(body_string)
 
           headers = {
             "Content-Type" => "application/json",
-            "Mcp-Session-Id" => session_id,
           }
 
+          headers["Mcp-Session-Id"] = session_id if session_id
+
           [200, headers, [response]]
         end
 
-        def handle_notification_initialized
+        def handle_accepted
           [202, {}, []]
         end
 
         def handle_regular_request(body_string, session_id)
-          # If session ID is provided, but not in the sessions hash, return an error
-          if session_id && !@sessions.key?(session_id)
-            return [400, { "Content-Type" => "application/json" }, [{ error: "Invalid session ID" }.to_json]]
+          unless @stateless
+            # If session ID is provided, but not in the sessions hash, return an error
+            if session_id && !@sessions.key?(session_id)
+              return [400, { "Content-Type" => "application/json" }, [{ error: "Invalid session ID" }.to_json]]
+            end
           end
 
-          response = @server.handle_json(body_string)
+          response = @server.handle_json(body_string) || ""
+
+          # Stream can be nil since stateless mode doesn't retain streams
           stream = get_session_stream(session_id) if session_id
 
           if stream
             send_response_to_stream(stream, response, session_id)
+          elsif response.nil? && notification_request?(body_string)
+            [202, { "Content-Type" => "application/json" }, [response]]
           else
             [200, { "Content-Type" => "application/json" }, [response]]
           end
         end
 
+        def notification_request?(body_string)
+          body = parse_request_body(body_string)
+          body.is_a?(Hash) && body["method"].start_with?("notifications/")
+        end
+
         def get_session_stream(session_id)
           @mutex.synchronize { @sessions[session_id]&.fetch(:stream, nil) }
         end
@@ -228,6 +302,10 @@ module MCP
           @mutex.synchronize { @sessions.key?(session_id) }
         end
 
+        def method_not_allowed_response
+          [405, { "Content-Type" => "application/json" }, [{ error: "Method not allowed" }.to_json]]
+        end
+
         def missing_session_id_response
           [400, { "Content-Type" => "application/json" }, [{ error: "Missing session ID" }.to_json]]
         end