mcp 0.5.0 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fa42259e96ff9b07eb17a7e65ec9ca1324a1cce6f969295a4cb452872302aee9
-  data.tar.gz: f353de6d9331617ae6bf14f559b6de94e45885ce16feabbb23f65996dc8a850f
+  metadata.gz: de660064625f4c983293603731aad08da2dc60fe6efdc92a79c11501182610e4
+  data.tar.gz: 663b210aee91776875b90c06457651ff33fe2c125826ee188a8143bf5569e5e9
 SHA512:
-  metadata.gz: 7b19b451b27926590498eb8320088cf8737c8b20e1897088f7a033e33fa8fec976c88c89e80d9e78d96202ae142e02c1698cc6ece52e9240085ad25b7fd5d4ac
-  data.tar.gz: 88f67864aecba8e4b475a53ba49a8651a10f8909c3c7e07138603ce4ea2c489580856494519a7cc6e7e6803e47bb99c38ae32a7802cb11fa268b5c18f9c40cb3
+  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,34 @@ 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
+
+- Update licensing to Apache 2.0 for new contributions (#213)
+
+### Fixed
+
+- Omit `icons` from responses when empty or nil to reduce context window usage (#212)
+
 ## [0.5.0] - 2026-01-11
 
 ### Added

data/LICENSE

@@ -0,0 +1,216 @@
+The MCP project is undergoing a licensing transition from the MIT License to the Apache License, Version 2.0 ("Apache-2.0"). All new code and specification contributions to the project are licensed under Apache-2.0. Documentation contributions (excluding specifications) are licensed under CC-BY-4.0.
+
+Contributions for which relicensing consent has been obtained are licensed under Apache-2.0. Contributions made by authors who originally licensed their work under the MIT License and who have not yet granted explicit permission to relicense remain licensed under the MIT License.
+
+No rights beyond those granted by the applicable original license are conveyed for such contributions.
+
+---
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to the Licensor for inclusion in the Work by the copyright
+      owner or by an individual or Legal Entity authorized to submit on behalf
+      of the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+---
+
+MIT License
+
+Copyright (c) 2024-2025 Model Context Protocol a Series of LF Projects, LLC.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+---
+
+Creative Commons Attribution 4.0 International (CC-BY-4.0)
+
+Documentation in this project (excluding specifications) is licensed under
+CC-BY-4.0. See https://creativecommons.org/licenses/by/4.0/legalcode for
+the full license text.

data/README.md

@@ -1,4 +1,4 @@
-# MCP Ruby SDK [![Gem Version](https://img.shields.io/gem/v/mcp)](https://rubygems.org/gems/mcp) [![MIT licensed](https://img.shields.io/badge/license-MIT-green)](https://github.com/modelcontextprotocol/ruby-sdk/blob/main/LICENSE.txt) [![CI](https://github.com/modelcontextprotocol/ruby-sdk/actions/workflows/ci.yml/badge.svg)](https://github.com/modelcontextprotocol/ruby-sdk/actions/workflows/ci.yml)
+# MCP Ruby SDK [![Gem Version](https://img.shields.io/gem/v/mcp)](https://rubygems.org/gems/mcp) [![Apache 2.0 licensed](https://img.shields.io/badge/license-Apache%202.0-blue)](https://github.com/modelcontextprotocol/ruby-sdk/blob/main/LICENSE) [![CI](https://github.com/modelcontextprotocol/ruby-sdk/actions/workflows/ci.yml/badge.svg)](https://github.com/modelcontextprotocol/ruby-sdk/actions/workflows/ci.yml)
 
 The official Ruby SDK for Model Context Protocol servers and clients.
 
@@ -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/prompt.rb

@@ -20,7 +20,7 @@ module MCP
           name: name_value,
           title: title_value,
           description: description_value,
-          icons: icons&.map(&:to_h),
+          icons: icons_value&.then { |icons| icons.empty? ? nil : icons.map(&:to_h) },
           arguments: arguments_value&.map(&:to_h),
           _meta: meta_value,
         }.compact

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/resource.rb

@@ -19,7 +19,7 @@ module MCP
         name: name,
         title: title,
         description: description,
-        icons: icons.map(&:to_h),
+        icons: icons&.then { |icons| icons.empty? ? nil : icons.map(&:to_h) },
         mimeType: mime_type,
       }.compact
     end

data/lib/mcp/resource_template.rb

@@ -19,7 +19,7 @@ module MCP
         name: name,
         title: title,
         description: description,
-        icons: icons.map(&:to_h),
+        icons: icons&.then { |icons| icons.empty? ? nil : icons.map(&:to_h) },
         mimeType: mime_type,
       }.compact
     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,13 +307,14 @@ module MCP
         tools: { listChanged: true },
         prompts: { listChanged: true },
         resources: { listChanged: true },
+        logging: {},
       }
     end
 
     def server_info
       @server_info ||= {
         description: description,
-        icons: icons,
+        icons: icons&.then { |icons| icons.empty? ? nil : icons.map(&:to_h) },
         name: name,
         title: title,
         version: version,
@@ -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/tool.rb

@@ -21,7 +21,7 @@ module MCP
           name: name_value,
           title: title_value,
           description: description_value,
-          icons: icons&.map(&:to_h),
+          icons: icons_value&.then { |icons| icons.empty? ? nil : icons.map(&:to_h) },
           inputSchema: input_schema_value.to_h,
           outputSchema: @output_schema_value&.to_h,
           annotations: annotations_value&.to_h,

data/lib/mcp/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module MCP
-  VERSION = "0.5.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

data/mcp.gemspec

@@ -11,7 +11,7 @@ Gem::Specification.new do |spec|
   spec.summary       = "The official Ruby SDK for Model Context Protocol servers and clients"
   spec.description   = spec.summary
   spec.homepage      = "https://github.com/modelcontextprotocol/ruby-sdk"
-  spec.license       = "MIT"
+  spec.license       = "Apache-2.0"
 
   # Since this library is used by a broad range of users, it does not align its support policy with Ruby's EOL.
   spec.required_ruby_version = ">= 2.7.0"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: mcp
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.7.0
 platform: ruby
 authors:
 - Model Context Protocol
@@ -40,7 +40,7 @@ files:
 - CHANGELOG.md
 - CODE_OF_CONDUCT.md
 - Gemfile
-- LICENSE.txt
+- LICENSE
 - README.md
 - RELEASE.md
 - Rakefile
@@ -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
@@ -93,10 +95,10 @@ files:
 - mcp.gemspec
 homepage: https://github.com/modelcontextprotocol/ruby-sdk
 licenses:
-- MIT
+- Apache-2.0
 metadata:
   allowed_push_host: https://rubygems.org
-  changelog_uri: https://github.com/modelcontextprotocol/ruby-sdk/releases/tag/v0.5.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

data/LICENSE.txt

@@ -1,21 +0,0 @@
-The MIT License (MIT)
-
-Copyright (c) 2025 TODO: Write your name
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.