ruby-mcp-client 0.9.1 → 1.0.0

data/lib/mcp_client/elicitation_validator.rb

@@ -0,0 +1,262 @@
+# frozen_string_literal: true
+
+module MCPClient
+  # Validates elicitation schemas and content per MCP 2025-11-25 spec.
+  # Schemas are restricted to flat objects with primitive property types:
+  #   string (with optional enum, pattern, format, minLength, maxLength)
+  #   number / integer (with optional minimum, maximum)
+  #   boolean
+  #   array (multi-select enum only, with items containing enum or anyOf)
+  module ElicitationValidator
+    # Allowed primitive types for schema properties
+    PRIMITIVE_TYPES = %w[string number integer boolean].freeze
+
+    # Allowed string formats per MCP spec
+    STRING_FORMATS = %w[email uri date date-time].freeze
+
+    # Validate that a requestedSchema conforms to MCP elicitation constraints.
+    # Returns an array of error messages (empty if valid).
+    # @param schema [Hash] the requestedSchema
+    # @return [Array<String>] validation errors
+    def self.validate_schema(schema)
+      errors = []
+      return errors unless schema.is_a?(Hash)
+
+      unless schema['type'] == 'object'
+        errors << "Schema type must be 'object', got '#{schema['type']}'"
+        return errors
+      end
+
+      properties = schema['properties']
+      return errors unless properties.is_a?(Hash)
+
+      properties.each do |name, prop|
+        errors.concat(validate_property(name, prop))
+      end
+
+      errors
+    end
+
+    # Validate a single property definition.
+    # @param name [String] property name
+    # @param prop [Hash] property schema
+    # @return [Array<String>] validation errors
+    def self.validate_property(name, prop)
+      errors = []
+      return errors unless prop.is_a?(Hash)
+
+      type = prop['type']
+
+      if type == 'array'
+        errors.concat(validate_array_property(name, prop))
+      elsif PRIMITIVE_TYPES.include?(type)
+        errors.concat(validate_primitive_property(name, prop))
+      else
+        errors << "Property '#{name}' has unsupported type '#{type}'"
+      end
+
+      errors
+    end
+
+    # Validate a primitive property (string, number, integer, boolean).
+    # @param name [String] property name
+    # @param prop [Hash] property schema
+    # @return [Array<String>] validation errors
+    def self.validate_primitive_property(name, prop)
+      errors = []
+      type = prop['type']
+
+      case type
+      when 'string'
+        if prop['format'] && !STRING_FORMATS.include?(prop['format'])
+          errors << "Property '#{name}' has unsupported format '#{prop['format']}'"
+        end
+        errors << "Property '#{name}' enum must be an array" if prop['enum'] && !prop['enum'].is_a?(Array)
+      when 'number', 'integer'
+        if prop.key?('minimum') && !prop['minimum'].is_a?(Numeric)
+          errors << "Property '#{name}' minimum must be numeric"
+        end
+        if prop.key?('maximum') && !prop['maximum'].is_a?(Numeric)
+          errors << "Property '#{name}' maximum must be numeric"
+        end
+      end
+
+      errors
+    end
+
+    # Validate an array property (multi-select enum only).
+    # @param name [String] property name
+    # @param prop [Hash] property schema
+    # @return [Array<String>] validation errors
+    def self.validate_array_property(name, prop)
+      errors = []
+      items = prop['items']
+
+      unless items.is_a?(Hash)
+        errors << "Property '#{name}' array type requires 'items' definition"
+        return errors
+      end
+
+      has_enum = items['enum'].is_a?(Array)
+      has_any_of = items['anyOf'].is_a?(Array)
+
+      errors << "Property '#{name}' array items must have 'enum' or 'anyOf'" unless has_enum || has_any_of
+
+      errors
+    end
+
+    # Validate content against a requestedSchema.
+    # Returns an array of error messages (empty if valid).
+    # @param content [Hash] the response content
+    # @param schema [Hash] the requestedSchema
+    # @return [Array<String>] validation errors
+    def self.validate_content(content, schema)
+      errors = []
+      return errors unless content.is_a?(Hash) && schema.is_a?(Hash)
+
+      properties = schema['properties'] || {}
+      required = Array(schema['required'])
+
+      # Check required fields
+      required.each do |field|
+        field_s = field.to_s
+        errors << "Missing required field '#{field_s}'" unless content.key?(field_s) || content.key?(field_s.to_sym)
+      end
+
+      # Validate each provided field
+      content.each do |field, value|
+        prop = properties[field.to_s]
+        next unless prop.is_a?(Hash)
+
+        errors.concat(validate_value(field.to_s, value, prop))
+      end
+
+      errors
+    end
+
+    # Validate a single value against its property schema.
+    # @param field [String] field name
+    # @param value [Object] the value to validate
+    # @param prop [Hash] property schema
+    # @return [Array<String>] validation errors
+    def self.validate_value(field, value, prop)
+      errors = []
+      type = prop['type']
+
+      case type
+      when 'string'
+        errors.concat(validate_string_value(field, value, prop))
+      when 'number', 'integer'
+        errors.concat(validate_number_value(field, value, prop))
+      when 'boolean'
+        errors << "Field '#{field}' must be a boolean" unless [true, false].include?(value)
+      when 'array'
+        errors.concat(validate_array_value(field, value, prop))
+      end
+
+      errors
+    end
+
+    # Validate a string value against its property schema.
+    # @param field [String] field name
+    # @param value [Object] the value
+    # @param prop [Hash] property schema
+    # @return [Array<String>] validation errors
+    def self.validate_string_value(field, value, prop)
+      errors = []
+
+      unless value.is_a?(String)
+        errors << "Field '#{field}' must be a string"
+        return errors
+      end
+
+      if prop['enum'].is_a?(Array) && !prop['enum'].include?(value)
+        errors << "Field '#{field}' must be one of: #{prop['enum'].join(', ')}"
+      end
+
+      if prop['oneOf'].is_a?(Array)
+        allowed = prop['oneOf'].map { |o| o['const'] }
+        errors << "Field '#{field}' must be one of: #{allowed.join(', ')}" unless allowed.include?(value)
+      end
+
+      if prop['pattern']
+        begin
+          unless value.match?(Regexp.new(prop['pattern']))
+            errors << "Field '#{field}' must match pattern '#{prop['pattern']}'"
+          end
+        rescue RegexpError
+          # Skip pattern validation if the pattern is invalid
+        end
+      end
+
+      if prop['minLength'] && value.length < prop['minLength']
+        errors << "Field '#{field}' must be at least #{prop['minLength']} characters"
+      end
+
+      if prop['maxLength'] && value.length > prop['maxLength']
+        errors << "Field '#{field}' must be at most #{prop['maxLength']} characters"
+      end
+
+      errors
+    end
+
+    # Validate a number value against its property schema.
+    # @param field [String] field name
+    # @param value [Object] the value
+    # @param prop [Hash] property schema
+    # @return [Array<String>] validation errors
+    def self.validate_number_value(field, value, prop)
+      errors = []
+
+      unless value.is_a?(Numeric)
+        errors << "Field '#{field}' must be a number"
+        return errors
+      end
+
+      errors << "Field '#{field}' must be an integer" if prop['type'] == 'integer' && !value.is_a?(Integer)
+
+      errors << "Field '#{field}' must be >= #{prop['minimum']}" if prop['minimum'] && value < prop['minimum']
+
+      errors << "Field '#{field}' must be <= #{prop['maximum']}" if prop['maximum'] && value > prop['maximum']
+
+      errors
+    end
+
+    # Validate an array value against its property schema (multi-select enum).
+    # @param field [String] field name
+    # @param value [Object] the value
+    # @param prop [Hash] property schema
+    # @return [Array<String>] validation errors
+    def self.validate_array_value(field, value, prop)
+      errors = []
+
+      unless value.is_a?(Array)
+        errors << "Field '#{field}' must be an array"
+        return errors
+      end
+
+      items = prop['items'] || {}
+      allowed = if items['enum'].is_a?(Array)
+                  items['enum']
+                elsif items['anyOf'].is_a?(Array)
+                  items['anyOf'].map { |o| o['const'] }
+                end
+
+      if allowed
+        value.each do |v|
+          errors << "Field '#{field}' contains invalid value '#{v}'" unless allowed.include?(v)
+        end
+      end
+
+      if prop['minItems'] && value.length < prop['minItems']
+        errors << "Field '#{field}' must have at least #{prop['minItems']} items"
+      end
+
+      if prop['maxItems'] && value.length > prop['maxItems']
+        errors << "Field '#{field}' must have at most #{prop['maxItems']} items"
+      end
+
+      errors
+    end
+  end
+end

data/lib/mcp_client/errors.rb

@@ -50,5 +50,11 @@ module MCPClient
 
     # Raised when transport type cannot be determined from target URL/command
     class TransportDetectionError < MCPError; end
+
+    # Raised when a task is not found
+    class TaskNotFound < MCPError; end
+
+    # Raised when there's an error creating or managing a task
+    class TaskError < MCPError; end
   end
 end

data/lib/mcp_client/http_transport_base.rb

@@ -58,6 +58,7 @@ module MCPClient
           # Apply base headers but prioritize session termination headers
           @headers.each { |k, v| req.headers[k] = v }
           req.headers['Mcp-Session-Id'] = @session_id
+          req.headers['Mcp-Protocol-Version'] = @protocol_version if @protocol_version
         end
 
         if response.success?
@@ -138,6 +139,7 @@ module MCPClient
 
       @server_info = result['serverInfo']
       @capabilities = result['capabilities']
+      @protocol_version = result['protocolVersion']
     end
 
     # Send a JSON-RPC request to the server and wait for result

data/lib/mcp_client/json_rpc_common.rb

@@ -63,9 +63,9 @@ module MCPClient
     # @return [Hash] the initialization parameters
     def initialization_params
       capabilities = {
-        'elicitation' => {}, # MCP 2025-06-18: Support for server-initiated user interactions
-        'roots' => { 'listChanged' => true }, # MCP 2025-06-18: Support for roots
-        'sampling' => {} # MCP 2025-06-18: Support for server-initiated LLM sampling
+        'elicitation' => {}, # MCP 2025-11-25: Support for server-initiated user interactions
+        'roots' => { 'listChanged' => true }, # MCP 2025-11-25: Support for roots
+        'sampling' => {} # MCP 2025-11-25: Support for server-initiated LLM sampling
       }
 
       {

data/lib/mcp_client/resource.rb

@@ -41,6 +41,14 @@ module MCPClient
       @server = server
     end
 
+    # Return the lastModified annotation value (ISO 8601 timestamp string)
+    # @return [String, nil] the lastModified timestamp, or nil if not set
+    def last_modified
+      return nil unless @annotations.is_a?(Hash)
+
+      @annotations['lastModified'] || @annotations[:lastModified]
+    end
+
     # Create a Resource instance from JSON data
     # @param data [Hash] JSON data from MCP server
     # @param server [MCPClient::ServerBase, nil] the server this resource belongs to

data/lib/mcp_client/resource_link.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module MCPClient
+  # Representation of an MCP resource link in tool result content
+  # A resource link references a server resource that can be read separately.
+  # Used in tool results to point clients to available resources (MCP 2025-11-25).
+  class ResourceLink
+    # @!attribute [r] uri
+    #   @return [String] URI of the linked resource
+    # @!attribute [r] name
+    #   @return [String] the name of the linked resource
+    # @!attribute [r] description
+    #   @return [String, nil] optional human-readable description
+    # @!attribute [r] mime_type
+    #   @return [String, nil] optional MIME type of the resource
+    # @!attribute [r] annotations
+    #   @return [Hash, nil] optional annotations that provide hints to clients
+    # @!attribute [r] title
+    #   @return [String, nil] optional display title for the resource
+    # @!attribute [r] size
+    #   @return [Integer, nil] optional size of the resource in bytes
+    attr_reader :uri, :name, :description, :mime_type, :annotations, :title, :size
+
+    # Initialize a resource link
+    # @param uri [String] URI of the linked resource
+    # @param name [String] the name of the linked resource
+    # @param description [String, nil] optional human-readable description
+    # @param mime_type [String, nil] optional MIME type of the resource
+    # @param annotations [Hash, nil] optional annotations that provide hints to clients
+    # @param title [String, nil] optional display title for the resource
+    # @param size [Integer, nil] optional size of the resource in bytes
+    def initialize(uri:, name:, description: nil, mime_type: nil, annotations: nil, title: nil, size: nil)
+      @uri = uri
+      @name = name
+      @description = description
+      @mime_type = mime_type
+      @annotations = annotations
+      @title = title
+      @size = size
+    end
+
+    # Create a ResourceLink instance from JSON data
+    # @param data [Hash] JSON data from MCP server (content item with type 'resource_link')
+    # @return [MCPClient::ResourceLink] resource link instance
+    def self.from_json(data)
+      new(
+        uri: data['uri'],
+        name: data['name'],
+        description: data['description'],
+        mime_type: data['mimeType'],
+        annotations: data['annotations'],
+        title: data['title'],
+        size: data['size']
+      )
+    end
+
+    # The content type identifier for this content type
+    # @return [String] 'resource_link'
+    def type
+      'resource_link'
+    end
+  end
+end

data/lib/mcp_client/server_http.rb

@@ -195,15 +195,22 @@ module MCPClient
       raise MCPClient::Errors::ToolCallError, "Error calling tool '#{tool_name}': #{e.message}"
     end
 
-    # Override apply_request_headers to add session headers for MCP protocol
+    # Override apply_request_headers to add session and protocol version headers
     def apply_request_headers(req, request)
       super
 
-      # Add session header if we have one (for non-initialize requests)
-      return unless @session_id && request['method'] != 'initialize'
+      # Add session and protocol version headers for non-initialize requests
+      return unless request['method'] != 'initialize'
 
-      req.headers['Mcp-Session-Id'] = @session_id
-      @logger.debug("Adding session header: Mcp-Session-Id: #{@session_id}")
+      if @session_id
+        req.headers['Mcp-Session-Id'] = @session_id
+        @logger.debug("Adding session header: Mcp-Session-Id: #{@session_id}")
+      end
+
+      return unless @protocol_version
+
+      req.headers['Mcp-Protocol-Version'] = @protocol_version
+      @logger.debug("Adding protocol version header: Mcp-Protocol-Version: #{@protocol_version}")
     end
 
     # Override handle_successful_response to capture session ID
@@ -325,10 +332,13 @@ module MCPClient
     # Request completion suggestions from the server (MCP 2025-06-18)
     # @param ref [Hash] reference to complete (prompt or resource)
     # @param argument [Hash] the argument being completed (e.g., { 'name' => 'arg_name', 'value' => 'partial' })
+    # @param context [Hash, nil] optional context for the completion (MCP 2025-11-25)
     # @return [Hash] completion result with 'values', optional 'total', and 'hasMore' fields
     # @raise [MCPClient::Errors::ServerError] if server returns an error
-    def complete(ref:, argument:)
-      result = rpc_request('completion/complete', { ref: ref, argument: argument })
+    def complete(ref:, argument:, context: nil)
+      params = { ref: ref, argument: argument }
+      params[:context] = context if context
+      result = rpc_request('completion/complete', params)
       result['completion'] || { 'values' => [] }
     rescue MCPClient::Errors::ConnectionError, MCPClient::Errors::TransportError
       raise

data/lib/mcp_client/server_sse.rb

@@ -106,7 +106,7 @@ module MCPClient
       @activity_timer_thread = nil
       @elicitation_request_callback = nil # MCP 2025-06-18
       @roots_list_request_callback = nil # MCP 2025-06-18
-      @sampling_request_callback = nil # MCP 2025-06-18
+      @sampling_request_callback = nil # MCP 2025-11-25
     end
 
     # Stream tool call fallback for SSE transport (yields single result)
@@ -330,10 +330,13 @@ module MCPClient
     # Request completion suggestions from the server (MCP 2025-06-18)
     # @param ref [Hash] reference object (e.g., { 'type' => 'ref/prompt', 'name' => 'prompt_name' })
     # @param argument [Hash] the argument being completed (e.g., { 'name' => 'arg_name', 'value' => 'partial' })
+    # @param context [Hash, nil] optional context for the completion (MCP 2025-11-25)
     # @return [Hash] completion result with 'values', optional 'total', and 'hasMore' fields
     # @raise [MCPClient::Errors::ServerError] if server returns an error
-    def complete(ref:, argument:)
-      result = rpc_request('completion/complete', { ref: ref, argument: argument })
+    def complete(ref:, argument:, context: nil)
+      params = { ref: ref, argument: argument }
+      params[:context] = context if context
+      result = rpc_request('completion/complete', params)
       result['completion'] || { 'values' => [] }
     rescue MCPClient::Errors::ConnectionError, MCPClient::Errors::TransportError
       raise
@@ -455,7 +458,7 @@ module MCPClient
       @roots_list_request_callback = block
     end
 
-    # Register a callback for sampling requests (MCP 2025-06-18)
+    # Register a callback for sampling requests (MCP 2025-11-25)
     # @param block [Proc] callback that receives (request_id, params) and returns response hash
     # @return [void]
     def on_sampling_request(&block)
@@ -545,7 +548,7 @@ module MCPClient
       @logger.error("Error sending roots/list response: #{e.message}")
     end
 
-    # Handle sampling/createMessage request from server (MCP 2025-06-18)
+    # Handle sampling/createMessage request from server (MCP 2025-11-25)
     # @param request_id [String, Integer] the JSON-RPC request ID
     # @param params [Hash] the sampling parameters
     # @return [void]
@@ -564,7 +567,7 @@ module MCPClient
       send_sampling_response(request_id, result)
     end
 
-    # Send sampling response back to server via HTTP POST (MCP 2025-06-18)
+    # Send sampling response back to server via HTTP POST (MCP 2025-11-25)
     # @param request_id [String, Integer] the JSON-RPC request ID
     # @param result [Hash] the sampling result (role, content, model, stopReason)
     # @return [void]

data/lib/mcp_client/server_stdio.rb

@@ -48,7 +48,7 @@ module MCPClient
       @env           = env || {}
       @elicitation_request_callback = nil # MCP 2025-06-18
       @roots_list_request_callback = nil # MCP 2025-06-18
-      @sampling_request_callback = nil # MCP 2025-06-18
+      @sampling_request_callback = nil # MCP 2025-11-25
     end
 
     # Server info from the initialize response
@@ -345,16 +345,19 @@ module MCPClient
     # Request completion suggestions from the server (MCP 2025-06-18)
     # @param ref [Hash] reference object (e.g., { 'type' => 'ref/prompt', 'name' => 'prompt_name' })
     # @param argument [Hash] the argument being completed (e.g., { 'name' => 'arg_name', 'value' => 'partial' })
+    # @param context [Hash, nil] optional context for the completion (MCP 2025-11-25)
     # @return [Hash] completion result with 'values', optional 'total', and 'hasMore' fields
     # @raise [MCPClient::Errors::ServerError] if server returns an error
-    def complete(ref:, argument:)
+    def complete(ref:, argument:, context: nil)
       ensure_initialized
       req_id = next_id
+      params = { 'ref' => ref, 'argument' => argument }
+      params['context'] = context if context
       req = {
         'jsonrpc' => '2.0',
         'id' => req_id,
         'method' => 'completion/complete',
-        'params' => { 'ref' => ref, 'argument' => argument }
+        'params' => params
       }
       send_request(req)
       res = wait_response(req_id)
@@ -406,7 +409,7 @@ module MCPClient
       @roots_list_request_callback = block
     end
 
-    # Register a callback for sampling requests (MCP 2025-06-18)
+    # Register a callback for sampling requests (MCP 2025-11-25)
     # @param block [Proc] callback that receives (request_id, params) and returns response hash
     # @return [void]
     def on_sampling_request(&block)
@@ -477,7 +480,7 @@ module MCPClient
       send_roots_list_response(request_id, result)
     end
 
-    # Handle sampling/createMessage request from server (MCP 2025-06-18)
+    # Handle sampling/createMessage request from server (MCP 2025-11-25)
     # @param request_id [String, Integer] the JSON-RPC request ID
     # @param params [Hash] the sampling parameters
     # @return [void]
@@ -509,7 +512,7 @@ module MCPClient
       send_message(response)
     end
 
-    # Send sampling response back to server (MCP 2025-06-18)
+    # Send sampling response back to server (MCP 2025-11-25)
     # @param request_id [String, Integer] the JSON-RPC request ID
     # @param result [Hash] the sampling result (role, content, model, stopReason)
     # @return [void]

data/lib/mcp_client/server_streamable_http.rb

@@ -119,7 +119,7 @@ module MCPClient
       @buffer = '' # Buffer for partial SSE event data
       @elicitation_request_callback = nil # MCP 2025-06-18
       @roots_list_request_callback = nil # MCP 2025-06-18
-      @sampling_request_callback = nil # MCP 2025-06-18
+      @sampling_request_callback = nil # MCP 2025-11-25
     end
 
     # Connect to the MCP server over Streamable HTTP
@@ -222,10 +222,13 @@ module MCPClient
     # Request completion suggestions from the server (MCP 2025-06-18)
     # @param ref [Hash] reference object (e.g., { 'type' => 'ref/prompt', 'name' => 'prompt_name' })
     # @param argument [Hash] the argument being completed (e.g., { 'name' => 'arg_name', 'value' => 'partial' })
+    # @param context [Hash, nil] optional context for the completion (MCP 2025-11-25)
     # @return [Hash] completion result with 'values', optional 'total', and 'hasMore' fields
     # @raise [MCPClient::Errors::ServerError] if server returns an error
-    def complete(ref:, argument:)
-      result = rpc_request('completion/complete', { ref: ref, argument: argument })
+    def complete(ref:, argument:, context: nil)
+      params = { ref: ref, argument: argument }
+      params[:context] = context if context
+      result = rpc_request('completion/complete', params)
       result['completion'] || { 'values' => [] }
     rescue MCPClient::Errors::ConnectionError, MCPClient::Errors::TransportError
       raise
@@ -393,10 +396,17 @@ module MCPClient
     def apply_request_headers(req, request)
       super
 
-      # Add session header if we have one (for non-initialize requests)
-      if @session_id && request['method'] != 'initialize'
-        req.headers['Mcp-Session-Id'] = @session_id
-        @logger.debug("Adding session header: Mcp-Session-Id: #{@session_id}")
+      # Add session and protocol version headers for non-initialize requests
+      if request['method'] != 'initialize'
+        if @session_id
+          req.headers['Mcp-Session-Id'] = @session_id
+          @logger.debug("Adding session header: Mcp-Session-Id: #{@session_id}")
+        end
+
+        if @protocol_version
+          req.headers['Mcp-Protocol-Version'] = @protocol_version
+          @logger.debug("Adding protocol version header: Mcp-Protocol-Version: #{@protocol_version}")
+        end
       end
 
       # Add Last-Event-ID header for resumability (if available)
@@ -496,7 +506,7 @@ module MCPClient
       @roots_list_request_callback = block
     end
 
-    # Register a callback for sampling requests (MCP 2025-06-18)
+    # Register a callback for sampling requests (MCP 2025-11-25)
     # @param block [Proc] callback that receives (request_id, params) and returns response hash
     # @return [void]
     def on_sampling_request(&block)
@@ -730,6 +740,7 @@ module MCPClient
     def apply_events_headers(req)
       @headers.each { |k, v| req.headers[k] = v }
       req.headers['Mcp-Session-Id'] = @session_id if @session_id
+      req.headers['Mcp-Protocol-Version'] = @protocol_version if @protocol_version
     end
 
     # Process event chunks from the server
@@ -840,6 +851,7 @@ module MCPClient
         response = conn.post(@endpoint) do |req|
           @headers.each { |k, v| req.headers[k] = v }
           req.headers['Mcp-Session-Id'] = @session_id if @session_id
+          req.headers['Mcp-Protocol-Version'] = @protocol_version if @protocol_version
           req.body = pong_response.to_json
         end
 
@@ -920,7 +932,7 @@ module MCPClient
       send_roots_list_response(request_id, result)
     end
 
-    # Handle sampling/createMessage request from server (MCP 2025-06-18)
+    # Handle sampling/createMessage request from server (MCP 2025-11-25)
     # @param request_id [String, Integer] the JSON-RPC request ID
     # @param params [Hash] the sampling parameters
     # @return [void]
@@ -956,7 +968,7 @@ module MCPClient
       @logger.error("Error sending roots/list response: #{e.message}")
     end
 
-    # Send sampling response back to server via HTTP POST (MCP 2025-06-18)
+    # Send sampling response back to server via HTTP POST (MCP 2025-11-25)
     # @param request_id [String, Integer] the JSON-RPC request ID
     # @param result [Hash] the sampling result (role, content, model, stopReason)
     # @return [void]
@@ -1040,6 +1052,7 @@ module MCPClient
         resp = conn.post(@endpoint) do |req|
           @headers.each { |k, v| req.headers[k] = v }
           req.headers['Mcp-Session-Id'] = @session_id if @session_id
+          req.headers['Mcp-Protocol-Version'] = @protocol_version if @protocol_version
           req.body = json_body
         end