mcp 0.6.0 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5d62d265efd62b4c882022028118d6e1c354c39145e70e78df6ad8edcc451f57
-  data.tar.gz: b977e4f7bde58f33df37ac3c7829ef4c8ff62317a575c0721fe122939fd2c5ce
+  metadata.gz: de660064625f4c983293603731aad08da2dc60fe6efdc92a79c11501182610e4
+  data.tar.gz: 663b210aee91776875b90c06457651ff33fe2c125826ee188a8143bf5569e5e9
 SHA512:
-  metadata.gz: a627464fd003e28f9c88638fcfaa0cf1149ee50a9416eb43a820757792446d9a74c74761294d468ae90102c5ef75884cf5ba8b34c42929d078e555315c2d0e99
-  data.tar.gz: c531410bfcb5004751bcf1eaa610ff4c1cdb6e6d8eefe58a80888efdb951f5cbdc23e532b31cd623619b8aba63ac0764db981b17e14f3b55a2f70c11f3ee93db
+  metadata.gz: 77e28efcff07e26bf49e1509b988f137008ae19391dd86e4ebb31be7d63fdfdcb740a4d49840b4b28b319f3ccd757e8034207eedfed72e2b33b3b464ebd4ff2a
+  data.tar.gz: 3d83677fe719a766f73b2e91fe6e8c5109bbbb7143ef5c674a154226d0f517fb28ed3b8cce6bbac37136770892258bde3267963000f8aa43d77faaa2a83a1083

data/.github/workflows/ci.yml

@@ -4,6 +4,8 @@ on: [push, pull_request]
 jobs:
   test:
     runs-on: ubuntu-latest
+    permissions:
+      contents: read
     strategy:
       matrix:
         entry:
@@ -27,6 +29,8 @@ jobs:
 
   rubocop:
     runs-on: ubuntu-latest
+    permissions:
+      contents: read
     name: RuboCop
     steps:
       - uses: actions/checkout@v6
@@ -38,6 +42,8 @@ jobs:
 
   yard:
     runs-on: ubuntu-latest
+    permissions:
+      contents: read
     name: YARD Documentation
     steps:
       - uses: actions/checkout@v6

data/CHANGELOG.md

@@ -7,6 +7,24 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.7.0] - 2026-02-14
+
+### Added
+
+- `logging` support (#103)
+- Protocol version negotiation to server initialization (#223)
+- Tool arguments to instrumentation data (#218)
+- Client info to instrumentation callback (#221)
+- `resource_templates` to `MCP::Client` (#225)
+
+### Changed
+
+- Extract `MCP::Annotations` into a dedicated file (#224)
+
+### Fixed
+
+- `Resource::Embedded` not setting `@resource` in `initialize` (#220)
+
 ## [0.6.0] - 2026-01-16
 
 ### Changed

data/README.md

@@ -113,6 +113,7 @@ The server provides three notification methods:
 - `notify_tools_list_changed` - Send a notification when the tools list changes
 - `notify_prompts_list_changed` - Send a notification when the prompts list changes
 - `notify_resources_list_changed` - Send a notification when the resources list changes
+- `notify_log_message` - Send a structured logging notification message
 
 #### Notification Format
 
@@ -121,6 +122,82 @@ Notifications follow the JSON-RPC 2.0 specification and use these method names:
 - `notifications/tools/list_changed`
 - `notifications/prompts/list_changed`
 - `notifications/resources/list_changed`
+- `notifications/message`
+
+### Logging
+
+The MCP Ruby SDK supports structured logging through the `notify_log_message` method, following the [MCP Logging specification](https://modelcontextprotocol.io/specification/latest/server/utilities/logging).
+
+The `notifications/message` notification is used for structured logging between client and server.
+
+#### Log Levels
+
+The SDK supports 8 log levels with increasing severity:
+
+- `debug` - Detailed debugging information
+- `info` - General informational messages
+- `notice` - Normal but significant events
+- `warning` - Warning conditions
+- `error` - Error conditions
+- `critical` - Critical conditions
+- `alert` - Action must be taken immediately
+- `emergency` - System is unusable
+
+#### How Logging Works
+
+1. **Client Configuration**: The client sends a `logging/setLevel` request to configure the minimum log level
+2. **Server Filtering**: The server only sends log messages at the configured level or higher severity
+3. **Notification Delivery**: Log messages are sent as `notifications/message` to the client
+
+For example, if the client sets the level to `"error"` (severity 4), the server will send messages with levels: `error`, `critical`, `alert`, and `emergency`.
+
+For more details, see the [MCP Logging specification](https://modelcontextprotocol.io/specification/latest/server/utilities/logging).
+
+**Usage Example:**
+
+```ruby
+server = MCP::Server.new(name: "my_server")
+transport = MCP::Server::Transports::StdioTransport.new(server)
+server.transport = transport
+
+# The client first configures the logging level (on the client side):
+transport.send_request(
+  request: {
+    jsonrpc: "2.0",
+    method: "logging/setLevel",
+    params: { level: "info" },
+    id: session_id # Unique request ID within the session
+  }
+)
+
+# Send log messages at different severity levels
+server.notify_log_message(
+  data: { message: "Application started successfully" },
+  level: "info"
+)
+
+server.notify_log_message(
+  data: { message: "Configuration file not found, using defaults" },
+  level: "warning"
+)
+
+server.notify_log_message(
+  data: {
+    error: "Database connection failed",
+    details: { host: "localhost", port: 5432 }
+  },
+  level: "error",
+  logger: "DatabaseLogger" # Optional logger name
+)
+```
+
+**Key Features:**
+
+- Supports 8 log levels (debug, info, notice, warning, error, critical, alert, emergency) based on https://modelcontextprotocol.io/specification/2025-06-18/server/utilities/logging#log-levels
+- Server has capability `logging` to send log messages
+- Messages are only sent if a transport is configured
+- Messages are filtered based on the client's configured log level
+- If the log level hasn't been set by the client, no messages will be sent
 
 #### Transport Support
 
@@ -153,7 +230,6 @@ transport = MCP::Server::Transports::StreamableHTTPTransport.new(server, statele
 
 ### Unsupported Features (to be implemented in future versions)
 
-- Log Level
 - Resource subscriptions
 - Completions
 - Elicitation
@@ -320,10 +396,16 @@ The instrumentation callback receives a hash with the following possible keys:
 
 - `method`: (String) The protocol method called (e.g., "ping", "tools/list")
 - `tool_name`: (String, optional) The name of the tool called
+- `tool_arguments`: (Hash, optional) The arguments passed to the tool
 - `prompt_name`: (String, optional) The name of the prompt called
 - `resource_uri`: (String, optional) The URI of the resource called
 - `error`: (String, optional) Error code if a lookup failed
 - `duration`: (Float) Duration of the call in seconds
+- `client`: (Hash, optional) Client information with `name` and `version` keys, from the initialize request
+
+> [!NOTE]
+> `tool_name`, `prompt_name` and `resource_uri` are only populated if a matching handler is registered.
+> This is to avoid potential issues with metric cardinality.
 
 **Type:**
 
@@ -335,9 +417,11 @@ instrumentation_callback = ->(data) { ... }
 **Example:**
 
 ```ruby
-config.instrumentation_callback = ->(data) {
-  puts "Instrumentation: #{data.inspect}"
-}
+MCP.configure do |config|
+  config.instrumentation_callback = ->(data) {
+    puts "Instrumentation: #{data.inspect}"
+  }
+end
 ```
 
 ### Server Protocol Version
@@ -787,31 +871,6 @@ The server will handle prompt listing and execution through the MCP protocol met
 - `prompts/list` - Lists all registered prompts and their schemas
 - `prompts/get` - Retrieves and executes a specific prompt with arguments
 
-### Instrumentation
-
-The server allows registering a callback to receive information about instrumentation.
-To register a handler pass a proc/lambda to as `instrumentation_callback` into the server constructor.
-
-```ruby
-MCP.configure do |config|
-  config.instrumentation_callback = ->(data) {
-    puts "Got instrumentation data #{data.inspect}"
-  }
-end
-```
-
-The data contains the following keys:
-
-- `method`: the method called, e.g. `ping`, `tools/list`, `tools/call` etc
-- `tool_name`: the name of the tool called
-- `prompt_name`: the name of the prompt called
-- `resource_uri`: the uri of the resource called
-- `error`: if looking up tools/prompts etc failed, e.g. `tool_not_found`
-- `duration`: the duration of the call in seconds
-
-`tool_name`, `prompt_name` and `resource_uri` are only populated if a matching handler is registered.
-This is to avoid potential issues with metric cardinality
-
 ### Resources
 
 MCP spec includes [Resources](https://modelcontextprotocol.io/specification/latest/server/resources).
@@ -877,6 +936,7 @@ This class supports:
 - Tool listing via the `tools/list` method (`MCP::Client#tools`)
 - Tool invocation via the `tools/call` method (`MCP::Client#call_tools`)
 - Resource listing via the `resources/list` method (`MCP::Client#resources`)
+- Resource template listing via the `resources/templates/list` method (`MCP::Client#resource_templates`)
 - Resource reading via the `resources/read` method (`MCP::Client#read_resources`)
 - Prompt listing via the `prompts/list` method (`MCP::Client#prompts`)
 - Prompt retrieval via the `prompts/get` method (`MCP::Client#get_prompt`)

data/examples/streamable_http_client.rb

@@ -122,6 +122,10 @@ def main
     exit(1)
   end
 
+  if init_response[:body].dig("result", "capabilities", "logging")
+    make_request(session_id, "logging/setLevel", { level: "info" })
+  end
+
   logger.info("Session initialized: #{session_id}")
   logger.info("Server info: #{init_response[:body]["result"]["serverInfo"]}")
 

data/examples/streamable_http_server.rb

@@ -107,6 +107,7 @@ app = proc do |env|
         mcp_logger.error("Response error: #{parsed_response["error"]["message"]}")
       elsif parsed_response["accepted"]
         # Response was sent via SSE
+        server.notify_log_message(data: { details: "Response accepted and sent via SSE" }, level: "info")
         sse_logger.info("Response sent via SSE stream")
       else
         mcp_logger.info("Response: success (id: #{parsed_response["id"]})")

data/lib/json_rpc_handler.rb

@@ -105,6 +105,8 @@ module JsonRpcHandler
       result = method.call(params)
 
       success_response(id: id, result: result)
+    rescue MCP::Server::RequestHandlerError => e
+      handle_request_error(e, id, id_validation_pattern)
     rescue StandardError => e
       error_response(id: id, id_validation_pattern: id_validation_pattern, error: {
         code: ErrorCode::INTERNAL_ERROR,
@@ -114,6 +116,24 @@ module JsonRpcHandler
     end
   end
 
+  def handle_request_error(error, id, id_validation_pattern)
+    error_type = error.respond_to?(:error_type) ? error.error_type : nil
+
+    code, message = case error_type
+    when :invalid_request then [ErrorCode::INVALID_REQUEST, "Invalid Request"]
+    when :invalid_params then [ErrorCode::INVALID_PARAMS, "Invalid params"]
+    when :parse_error then [ErrorCode::PARSE_ERROR, "Parse error"]
+    when :internal_error then [ErrorCode::INTERNAL_ERROR, "Internal error"]
+    else [ErrorCode::INTERNAL_ERROR, "Internal error"]
+    end
+
+    error_response(id: id, id_validation_pattern: id_validation_pattern, error: {
+      code: code,
+      message: message,
+      data: error.message,
+    })
+  end
+
   def valid_version?(version)
     version == Version::V2_0
   end

data/lib/mcp/annotations.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module MCP
+  class Annotations
+    attr_reader :audience, :priority, :last_modified
+
+    def initialize(audience: nil, priority: nil, last_modified: nil)
+      @audience = audience
+      @priority = priority
+      @last_modified = last_modified
+    end
+
+    def to_h
+      {
+        audience: audience,
+        priority: priority,
+        lastModified: last_modified,
+      }.compact
+    end
+  end
+end

data/lib/mcp/client.rb

@@ -58,6 +58,20 @@ module MCP
       response.dig("result", "resources") || []
     end
 
+    # Returns the list of resource templates available from the server.
+    # Each call will make a new request – the result is not cached.
+    #
+    # @return [Array<Hash>] An array of available resource templates.
+    def resource_templates
+      response = transport.send_request(request: {
+        jsonrpc: JsonRpcHandler::Version::V2_0,
+        id: request_id,
+        method: "resources/templates/list",
+      })
+
+      response.dig("result", "resourceTemplates") || []
+    end
+
     # Returns the list of prompts available from the server.
     # Each call will make a new request – the result is not cached.
     #

data/lib/mcp/logging_message_notification.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module MCP
+  class LoggingMessageNotification
+    LOG_LEVEL_SEVERITY = {
+      "debug" => 0,
+      "info" => 1,
+      "notice" => 2,
+      "warning" => 3,
+      "error" => 4,
+      "critical" => 5,
+      "alert" => 6,
+      "emergency" => 7,
+    }.freeze
+
+    def initialize(level:)
+      @level = level
+    end
+
+    def valid_level?
+      LOG_LEVEL_SEVERITY.keys.include?(@level)
+    end
+
+    def should_notify?(log_level)
+      return false unless LOG_LEVEL_SEVERITY.key?(log_level)
+
+      LOG_LEVEL_SEVERITY[log_level] >= LOG_LEVEL_SEVERITY[@level]
+    end
+  end
+end

data/lib/mcp/resource/embedded.rb

@@ -6,6 +6,7 @@ module MCP
       attr_reader :resource, :annotations
 
       def initialize(resource:, annotations: nil)
+        @resource = resource
         @annotations = annotations
       end
 

data/lib/mcp/server.rb

@@ -3,6 +3,7 @@
 require_relative "../json_rpc_handler"
 require_relative "instrumentation"
 require_relative "methods"
+require_relative "logging_message_notification"
 
 module MCP
   class ToolNotUnique < StandardError
@@ -17,6 +18,9 @@ module MCP
   class Server
     DEFAULT_VERSION = "0.1.0"
 
+    UNSUPPORTED_PROPERTIES_UNTIL_2025_06_18 = [:description, :icons].freeze
+    UNSUPPORTED_PROPERTIES_UNTIL_2025_03_26 = [:title, :websiteUrl].freeze
+
     class RequestHandlerError < StandardError
       attr_reader :error_type
       attr_reader :original_error
@@ -40,7 +44,7 @@ module MCP
 
     include Instrumentation
 
-    attr_accessor :description, :icons, :name, :title, :version, :website_url, :instructions, :tools, :prompts, :resources, :server_context, :configuration, :capabilities, :transport
+    attr_accessor :description, :icons, :name, :title, :version, :website_url, :instructions, :tools, :prompts, :resources, :server_context, :configuration, :capabilities, :transport, :logging_message_notification
 
     def initialize(
       description: nil,
@@ -74,10 +78,12 @@ module MCP
       @resource_index = index_resources_by_uri(resources)
       @server_context = server_context
       @configuration = MCP.configuration.merge(configuration)
+      @client = nil
 
       validate!
 
       @capabilities = capabilities || default_capabilities
+      @logging_message_notification = nil
 
       @handlers = {
         Methods::RESOURCES_LIST => method(:list_resources),
@@ -90,12 +96,12 @@ module MCP
         Methods::INITIALIZE => method(:init),
         Methods::PING => ->(_) { {} },
         Methods::NOTIFICATIONS_INITIALIZED => ->(_) {},
+        Methods::LOGGING_SET_LEVEL => method(:configure_logging_level),
 
         # No op handlers for currently unsupported methods
         Methods::RESOURCES_SUBSCRIBE => ->(_) {},
         Methods::RESOURCES_UNSUBSCRIBE => ->(_) {},
         Methods::COMPLETION_COMPLETE => ->(_) {},
-        Methods::LOGGING_SET_LEVEL => ->(_) {},
         Methods::ELICITATION_CREATE => ->(_) {},
       }
       @transport = transport
@@ -162,6 +168,18 @@ module MCP
       report_exception(e, { notification: "resources_list_changed" })
     end
 
+    def notify_log_message(data:, level:, logger: nil)
+      return unless @transport
+      return unless logging_message_notification&.should_notify?(level)
+
+      params = { "data" => data, "level" => level }
+      params["logger"] = logger if logger
+
+      @transport.send_notification(Methods::NOTIFICATIONS_MESSAGE, params)
+    rescue => e
+      report_exception(e, { notification: "log_message" })
+    end
+
     def resources_list_handler(&block)
       @handlers[Methods::RESOURCES_LIST] = block
     end
@@ -244,7 +262,9 @@ module MCP
     def handle_request(request, method)
       handler = @handlers[method]
       unless handler
-        instrument_call("unsupported_method") {}
+        instrument_call("unsupported_method") do
+          add_instrumentation_data(client: @client) if @client
+        end
         return
       end
 
@@ -252,7 +272,7 @@ module MCP
 
       ->(params) {
         instrument_call(method) do
-          case method
+          result = case method
           when Methods::TOOLS_LIST
             { tools: @handlers[Methods::TOOLS_LIST].call(params) }
           when Methods::PROMPTS_LIST
@@ -266,6 +286,9 @@ module MCP
           else
             @handlers[method].call(params)
           end
+          add_instrumentation_data(client: @client) if @client
+
+          result
         rescue => e
           report_exception(e, { request: request })
           if e.is_a?(RequestHandlerError)
@@ -284,6 +307,7 @@ module MCP
         tools: { listChanged: true },
         prompts: { listChanged: true },
         resources: { listChanged: true },
+        logging: {},
       }
     end
 
@@ -298,15 +322,48 @@ module MCP
       }.compact
     end
 
-    def init(request)
+    def init(params)
+      @client = params[:clientInfo] if params
+
+      protocol_version = params[:protocolVersion] if params
+      negotiated_version = if Configuration::SUPPORTED_STABLE_PROTOCOL_VERSIONS.include?(protocol_version)
+        protocol_version
+      else
+        configuration.protocol_version
+      end
+
+      info = server_info.reject do |property|
+        negotiated_version <= "2025-06-18" && UNSUPPORTED_PROPERTIES_UNTIL_2025_06_18.include?(property) ||
+          negotiated_version <= "2025-03-26" && UNSUPPORTED_PROPERTIES_UNTIL_2025_03_26.include?(property)
+      end
+
+      response_instructions = instructions
+
+      if negotiated_version == "2024-11-05"
+        response_instructions = nil
+      end
+
       {
-        protocolVersion: configuration.protocol_version,
+        protocolVersion: negotiated_version,
         capabilities: capabilities,
-        serverInfo: server_info,
-        instructions: instructions,
+        serverInfo: info,
+        instructions: response_instructions,
       }.compact
     end
 
+    def configure_logging_level(request)
+      if capabilities[:logging].nil?
+        raise RequestHandlerError.new("Server does not support logging", request, error_type: :internal_error)
+      end
+
+      logging_message_notification = LoggingMessageNotification.new(level: request[:level])
+      unless logging_message_notification.valid_level?
+        raise RequestHandlerError.new("Invalid log level #{request[:level]}", request, error_type: :invalid_params)
+      end
+
+      @logging_message_notification = logging_message_notification
+    end
+
     def list_tools(request)
       @tools.values.map(&:to_h)
     end
@@ -322,7 +379,7 @@ module MCP
       end
 
       arguments = request[:arguments] || {}
-      add_instrumentation_data(tool_name: tool_name)
+      add_instrumentation_data(tool_name: tool_name, tool_arguments: arguments)
 
       if tool.input_schema&.missing_required_arguments?(arguments)
         add_instrumentation_data(error: :missing_required_arguments)

data/lib/mcp/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module MCP
-  VERSION = "0.6.0"
+  VERSION = "0.7.0"
 end

data/lib/mcp.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "json_rpc_handler"
+require_relative "mcp/annotations"
 require_relative "mcp/configuration"
 require_relative "mcp/content"
 require_relative "mcp/icon"
@@ -39,13 +40,4 @@ module MCP
       @configuration ||= Configuration.new
     end
   end
-
-  class Annotations
-    attr_reader :audience, :priority
-
-    def initialize(audience: nil, priority: nil)
-      @audience = audience
-      @priority = priority
-    end
-  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: mcp
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 0.7.0
 platform: ruby
 authors:
 - Model Context Protocol
@@ -60,6 +60,7 @@ files:
 - examples/streamable_http_server.rb
 - lib/json_rpc_handler.rb
 - lib/mcp.rb
+- lib/mcp/annotations.rb
 - lib/mcp/client.rb
 - lib/mcp/client/http.rb
 - lib/mcp/client/tool.rb
@@ -67,6 +68,7 @@ files:
 - lib/mcp/content.rb
 - lib/mcp/icon.rb
 - lib/mcp/instrumentation.rb
+- lib/mcp/logging_message_notification.rb
 - lib/mcp/methods.rb
 - lib/mcp/prompt.rb
 - lib/mcp/prompt/argument.rb
@@ -96,7 +98,7 @@ licenses:
 - Apache-2.0
 metadata:
   allowed_push_host: https://rubygems.org
-  changelog_uri: https://github.com/modelcontextprotocol/ruby-sdk/releases/tag/v0.6.0
+  changelog_uri: https://github.com/modelcontextprotocol/ruby-sdk/releases/tag/v0.7.0
   homepage_uri: https://github.com/modelcontextprotocol/ruby-sdk
   source_code_uri: https://github.com/modelcontextprotocol/ruby-sdk
   bug_tracker_uri: https://github.com/modelcontextprotocol/ruby-sdk/issues