actionmcp 0.31.0 → 0.32.1

data/lib/action_mcp/server/capabilities.rb

@@ -10,46 +10,52 @@ module ActionMCP
       # @param params [Hash] The JSON-RPC parameters.
       # @return [Hash] A hash representing the JSON-RPC response (success or error).
       def send_capabilities(request_id, params = {})
-        # 1. Validate Parameters
         client_protocol_version = params["protocolVersion"]
         client_info = params["clientInfo"]
         client_capabilities = params["capabilities"]
 
         unless client_protocol_version.is_a?(String) && client_protocol_version.present?
-          return send_jsonrpc_error(request_id, :invalid_params, "Missing or invalid 'protocolVersion'")
+          send_jsonrpc_error(request_id, :invalid_params, "Missing or invalid 'protocolVersion'")
+          return { type: :error, id: request_id, payload: { jsonrpc: "2.0", id: request_id, error: { code: -32602, message: "Missing or invalid 'protocolVersion'" } } }
         end
-        # Basic check, could be more specific based on spec requirements
+        # Check if the protocol version is supported
+        unless ActionMCP::SUPPORTED_VERSIONS.include?(client_protocol_version)
+          error_data = {
+            supported: ActionMCP::SUPPORTED_VERSIONS,
+            requested: client_protocol_version
+          }
+          send_jsonrpc_error(request_id, :invalid_params, "Unsupported protocol version", error_data)
+          return { type: :error, id: request_id, payload: { jsonrpc: "2.0", id: request_id, error: { code: -32602, message: "Unsupported protocol version", data: error_data } } }
+        end
+
         unless client_info.is_a?(Hash)
-          return send_jsonrpc_error(request_id, :invalid_params, "Missing or invalid 'clientInfo'")
+          send_jsonrpc_error(request_id, :invalid_params, "Missing or invalid 'clientInfo'")
+          return { type: :error, id: request_id, payload: { jsonrpc: "2.0", id: request_id, error: { code: -32602, message: "Missing or invalid 'clientInfo'" } } }
         end
         unless client_capabilities.is_a?(Hash)
-          return send_jsonrpc_error(request_id, :invalid_params, "Missing or invalid 'capabilities'")
+          send_jsonrpc_error(request_id, :invalid_params, "Missing or invalid 'capabilities'")
+          return { type: :error, id: request_id, payload: { jsonrpc: "2.0", id: request_id, error: { code: -32602, message: "Missing or invalid 'capabilities'" } } }
         end
 
-        # 2. Check Protocol Version
-        server_protocol_version = ActionMCP::PROTOCOL_VERSION
-        unless client_protocol_version == server_protocol_version
-          error_data = {
-            supported: [ server_protocol_version ],
-            requested: client_protocol_version
-          }
-          # Using -32602 Invalid Params code as per spec example for version mismatch
-          return send_jsonrpc_error(request_id, :invalid_params, "Unsupported protocol version", error_data)
-        end
 
-        # 3. Store Info and Initialize Session
+
+        # Store client information
         session.store_client_info(client_info)
         session.store_client_capabilities(client_capabilities)
-        session.set_protocol_version(client_protocol_version) # Store the agreed-upon version
+        session.set_protocol_version(client_protocol_version)
 
-        # Attempt to initialize (this saves the session if new)
+        # Initialize the session
         unless session.initialize!
-          # Handle potential initialization failure (e.g., validation error on save)
-          return send_jsonrpc_error(request_id, :internal_error, "Failed to initialize session")
+          send_jsonrpc_error(request_id, :internal_error, "Failed to initialize session")
+          return { type: :error, id: request_id, payload: { jsonrpc: "2.0", id: request_id, error: { code: -32603, message: "Failed to initialize session" } } }
         end
 
-        # 4. Return Success Response Payload
-        send_jsonrpc_response(request_id, result: session.server_capabilities_payload)
+        # Send the successful response with the protocol version the client requested
+        capabilities_payload = session.server_capabilities_payload
+        capabilities_payload[:protocolVersion] = client_protocol_version  # Use the client's requested version
+
+        send_jsonrpc_response(request_id, result: capabilities_payload)
+        { type: :responses, id: request_id, payload: { jsonrpc: "2.0", id: request_id, result: capabilities_payload } }
       end
     end
   end

data/lib/action_mcp/server/json_rpc_handler.rb

@@ -3,29 +3,55 @@
 module ActionMCP
   module Server
     class JsonRpcHandler < JsonRpcHandlerBase
-      protected
-
       # Handle server-specific methods
       # @param rpc_method [String]
       # @param id [String, Integer]
       # @param params [Hash]
+      def call(line)
+        request = if line.is_a?(String)
+                    line.strip!
+                    return if line.empty?
+
+                    begin
+                      MultiJson.load(line)
+                    rescue MultiJson::ParseError => e
+                      Rails.logger.error("Failed to parse JSON: #{e.message}")
+                      return
+                    end
+        else
+                    line
+        end
+
+        # Store the request ID for error responses
+        @current_request_id = request["id"] if request.is_a?(Hash)
+
+        process_request(request)
+      end
+
       def handle_method(rpc_method, id, params)
+        # Ensure we have the current request ID
+        @current_request_id = id
+
         case rpc_method
-        when "initialize" # [SERVER] Client initializing the connection
+        when "initialize"
           transport.send_capabilities(id, params)
-        when %r{^prompts/} # Prompt-related requests
+        when %r{^prompts/}
           process_prompts(rpc_method, id, params)
-        when %r{^resources/} # Resource-related requests
+        when %r{^resources/}
           process_resources(rpc_method, id, params)
-        when %r{^tools/} # Tool-related requests
+        when %r{^tools/}
           process_tools(rpc_method, id, params)
-        when "completion/complete" # Completion requests
+        when "completion/complete"
           process_completion_complete(id, params)
         else
-          transport.send_jsonrpc_error(id, :method_not_found, "Method not found")
+          transport.send_jsonrpc_error(id, :method_not_found, "Method not found #{rpc_method}")
         end
+      rescue StandardError => e
+        Rails.logger.error("Error handling method #{rpc_method}: #{e.message}")
+        transport.send_jsonrpc_error(id, :internal_error, "Internal error: #{e.message}")
       end
 
+
       # Server methods (client → server)
 
       # @param id [String]
@@ -79,7 +105,7 @@ module ActionMCP
       def process_tools(rpc_method, id, params)
         case rpc_method
         when "tools/list" # List available tools
-          transport.send_tools_list(id)
+          transport.send_tools_list(id, params)
         when "tools/call" # Call a tool
           transport.send_tools_call(id, params["name"], params["arguments"])
         else

data/lib/action_mcp/server/notifications.rb

@@ -34,15 +34,24 @@ module ActionMCP
         send_jsonrpc_notification("notifications/logging/message", params)
       end
 
-      # Send progress notification for an asynchronous operation
-      def send_progress_notification(token:, value:, message: nil)
+      # Updated to match MCP 2025-03-26 specification
+      def send_progress_notification(progressToken:, progress:, total: nil, message: nil, **options)
         params = {
-          token: token,
-          value: value
+          progressToken: progressToken,
+          progress: progress
         }
+        # Only include total and message if they are present (not nil)
+        params[:total] = total unless total.nil?
         params[:message] = message if message.present?
+        params.merge!(options) if options.any?
 
-        send_jsonrpc_notification("$/progress", params)
+        send_jsonrpc_notification("notifications/progress", params)
+      end
+
+      # Backward compatibility method for old API
+      def send_progress_notification_legacy(token:, value:, message: nil)
+        Rails.logger.warn("DEPRECATION: send_progress_notification with token/value is deprecated. Use progressToken/progress instead.")
+        send_progress_notification(progressToken: token, progress: value, message: message)
       end
     end
   end

data/lib/action_mcp/server/prompts.rb

@@ -4,16 +4,29 @@ module ActionMCP
   module Server
     module Prompts
       def send_prompts_list(request_id)
-        prompts = format_registry_items(PromptsRegistry.non_abstract)
+        # Use session's registered prompts
+        prompts = session.registered_prompts.map(&:to_h)
         send_jsonrpc_response(request_id, result: { prompts: prompts })
       end
 
       def send_prompts_get(request_id, prompt_name, params)
-        result = PromptsRegistry.prompt_call(prompt_name.to_s, params)
-        if result.is_error
-          send_jsonrpc_response(request_id, error: result)
+        # Find prompt in session's registry
+        prompt_class = session.registered_prompts.find { |p| p.prompt_name == prompt_name }
+
+        if prompt_class
+          # Create prompt and set execution context
+          prompt = prompt_class.new(params)
+          prompt.with_context({ session: session })
+
+          result = prompt.call
+
+          if result.is_error
+            send_jsonrpc_response(request_id, error: result)
+          else
+            send_jsonrpc_response(request_id, result: result)
+          end
         else
-          send_jsonrpc_response(request_id, result:)
+          send_jsonrpc_error(request_id, :method_not_found, "Prompt '#{prompt_name}' not available in this session")
         end
       end
     end

data/lib/action_mcp/server/registry_management.rb

@@ -0,0 +1,32 @@
+# lib/action_mcp/server/registry_management.rb
+module ActionMCP
+  module Server
+    module RegistryManagement
+      def send_registry_add_tool(request_id, tool_name)
+        tool_class = ActionMCP::ToolsRegistry.find(tool_name)
+
+        if tool_class
+          session.register_tool(tool_class)
+          send_jsonrpc_response(request_id, result: { success: true })
+        else
+          send_jsonrpc_error(request_id, :invalid_params, "Tool '#{tool_name}' not found")
+        end
+      rescue ActionMCP::RegistryBase::NotFound
+        send_jsonrpc_error(request_id, :invalid_params, "Tool '#{tool_name}' not found")
+      end
+
+      def send_registry_remove_tool(request_id, tool_name)
+        tool_class = session.available_tools.find { |t| t.tool_name == tool_name }
+
+        if tool_class
+          session.unregister_tool(tool_class)
+          send_jsonrpc_response(request_id, result: { success: true })
+        else
+          send_jsonrpc_error(request_id, :invalid_params, "Tool '#{tool_name}' not in session")
+        end
+      end
+
+      # Similar methods for prompts and resources
+    end
+  end
+end

data/lib/action_mcp/server/resources.rb

@@ -46,10 +46,11 @@ module ActionMCP
       #   # Sends: {"jsonrpc":"2.0","id":"req-789","result":{"contents":[{"uri":"file:///example.txt","text":"Example content"}]}}
       def send_resource_read(id, params)
         if (template = ResourceTemplatesRegistry.find_template_for_uri(params[:uri]))
+          # Create template instance and set execution context
           record = template.process(params[:uri])
+          record.with_context({ session: session })
+
           if (resource = record.call)
-            # if resource is a array or a collection, return each item then it ok
-            # else wrap it in a array
             resource = [ resource ] unless resource.respond_to?(:each)
             content = resource.map(&:to_h)
             send_jsonrpc_response(id, result: { contents: content })

data/lib/action_mcp/server/tools.rb

@@ -3,19 +3,63 @@
 module ActionMCP
   module Server
     module Tools
-      def send_tools_list(request_id)
-        tools = format_registry_items(ToolsRegistry.non_abstract)
+      def send_tools_list(request_id, params = {})
+        protocol_version = session.protocol_version
+        # Extract progress token from _meta if provided
+        progress_token = params.dig("_meta", "progressToken")
+
+        # Send initial progress notification if token is provided
+        if progress_token
+          session.send_progress_notification(
+            progressToken: progress_token,
+            progress: 0,
+            message: "Starting tools list retrieval"
+          )
+        end
+
+        # Use session's registered tools instead of global registry
+        tools = session.registered_tools.map { |tool_class|
+          tool_class.to_h(protocol_version: protocol_version)
+        }
+
+        # Send completion progress notification if token is provided
+        if progress_token
+          session.send_progress_notification(
+            progressToken: progress_token,
+            progress: 100,
+            message: "Tools list retrieval complete"
+          )
+        end
+
         send_jsonrpc_response(request_id, result: { tools: tools })
       end
 
       def send_tools_call(request_id, tool_name, arguments, _meta = {})
-        result = ToolsRegistry.tool_call(tool_name, arguments, _meta)
-        if result.is_error
-          send_jsonrpc_response(request_id, error: result)
+        # Find tool in session's registry
+        tool_class = session.registered_tools.find { |t| t.tool_name == tool_name }
+
+        if tool_class
+          # Create tool and set execution context
+          tool = tool_class.new(arguments)
+          tool.with_context({ session: session })
+
+          result = tool.call
+
+          if result.is_error
+            send_jsonrpc_response(request_id, error: result)
+          else
+            send_jsonrpc_response(request_id, result: result)
+          end
         else
-          send_jsonrpc_response(request_id, result:)
+          send_jsonrpc_error(request_id, :method_not_found, "Tool '#{tool_name}' not available in this session")
         end
       end
+
+      private
+
+      def format_registry_items(registry, protocol_version = nil)
+        registry.map { |item| item.klass.to_h(protocol_version: protocol_version) }
+      end
     end
   end
 end

data/lib/action_mcp/sse_listener.rb

@@ -21,12 +21,12 @@ module ActionMCP
     def start(&callback)
       Rails.logger.debug "SSEListener: Starting for channel: #{session_key}"
 
-      success_callback = -> {
+      success_callback = lambda {
         Rails.logger.info "SSEListener: Successfully subscribed to channel: #{session_key}"
         @subscription_active.make_true
       }
 
-      message_callback = ->(raw_message) {
+      message_callback = lambda { |raw_message|
         process_message(raw_message, callback)
       }
 
@@ -81,6 +81,7 @@ module ActionMCP
 
     def valid_json_format?(string)
       return false if string.blank?
+
       string = string.strip
       (string.start_with?("{") && string.end_with?("}")) ||
         (string.start_with?("[") && string.end_with?("]"))

data/lib/action_mcp/tagged_stream_logging.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+# frozen_string_literal: true
+
+# lib/action_mcp/tagged_io_logging.rb
+
+module ActionMCP
+  module TaggedStreamLogging
+    # ────────────  ANSI COLOURS  ────────────
+    CLR        = "\e[0m"
+    BLUE_TX    = "\e[34m"  # outgoing JSON‑RPC (TX)
+    GREEN_RX   = "\e[32m"  # incoming JSON‑RPC (RX)
+    YELLOW_ERR = "\e[33m"  # decode / validation warnings
+    RED_FATAL  = "\e[31m"  # unexpected exceptions
+
+    # ———  Outbound: any frame we ‘write’ to the wire  ———
+    def write_message(data)
+      pretty = json_normalise(data)
+      ActionMCP.logger.tagged("MCP", "TX") { ActionMCP.logger.debug("#{BLUE_TX}#{pretty}#{CLR}") }
+      super
+    rescue StandardError => e
+      ActionMCP.logger.tagged("MCP", "TX") { ActionMCP.logger.error("#{RED_FATAL}#{e.message}#{CLR}") }
+      raise
+    end
+
+    # ———  Inbound: every raw line handed to the JSON‑RPC handler  ———
+    def read(line)
+      pretty = json_normalise(line)
+      ActionMCP.logger.tagged("MCP", "RX") { ActionMCP.logger.debug("#{GREEN_RX}#{pretty}#{CLR}") }
+      super
+    rescue MultiJson::ParseError => e
+      ActionMCP.logger.tagged("MCP", "RX") { ActionMCP.logger.warn("#{YELLOW_ERR}Bad JSON → #{e.message}#{CLR}") }
+      raise
+    rescue StandardError => e
+      ActionMCP.logger.tagged("MCP", "RX") { ActionMCP.logger.error("#{RED_FATAL}#{e.message}#{CLR}") }
+      raise
+    end
+
+    private
+
+    # Accepts String, Hash, or any #to_json‑able object.
+    def json_normalise(obj)
+      str = obj.is_a?(String) ? obj.strip : MultiJson.dump(obj)
+      str.empty? ? "<empty frame>" : str
+    end
+  end
+end

data/lib/action_mcp/test_helper.rb

@@ -3,53 +3,76 @@
 require "active_support/testing/assertions"
 
 module ActionMCP
+  #---------------------------------------------------------------------------
+  # ActionMCP::TestHelper
+  #
+  # Include in any `ActiveSupport::TestCase`:
+  #
+  #   include ActionMCP::TestHelper
+  #
+  # and you get   assert_mcp_tool_findable,
+  #               assert_mcp_prompt_findable,
+  #               execute_mcp_tool,
+  #               execute_mcp_prompt,
+  #               assert_mcp_error_code,
+  #               assert_mcp_tool_output,
+  #               assert_mcp_prompt_output.
+  #
+  # Short alias names (without the prefix) remain for this gem’s own suite but
+  # are *not* documented for public use.
+  #---------------------------------------------------------------------------
   module TestHelper
     include ActiveSupport::Testing::Assertions
 
-    # Asserts that a tool is findable in the ToolsRegistry.
-    # @param [String] tool_name
-    def assert_tool_findable(tool_name)
-      assert ActionMCP::ToolsRegistry.tools.key?(tool_name), "Tool #{tool_name} not found in registry"
+    # ──── Registry assertions ────────────────────────────────────────────────
+    def assert_mcp_tool_findable(name, msg = nil)
+      assert ActionMCP::ToolsRegistry.tools.key?(name),
+             msg || "Tool #{name.inspect} not found in ToolsRegistry"
     end
+    alias assert_tool_findable assert_mcp_tool_findable
 
-    # Asserts that a prompt is findable in the PromptsRegistry.
-    # @param [String] prompt_name
-    def assert_prompt_findable(prompt_name)
-      assert ActionMCP::PromptsRegistry.prompts.key?(prompt_name), "Prompt #{prompt_name} not found in registry"
+    def assert_mcp_prompt_findable(name, msg = nil)
+      assert ActionMCP::PromptsRegistry.prompts.key?(name),
+             msg || "Prompt #{name.inspect} not found in PromptsRegistry"
     end
+    alias assert_prompt_findable assert_mcp_prompt_findable
 
-    # Executes a tool with the given name and arguments.
-    # @param [String] tool_name
-    # @param [Hash] args
-    def execute_tool(tool_name, args = {})
-      result = ActionMCP::ToolsRegistry.tool_call(tool_name, args)
-      assert_not result.is_error, "Tool #{tool_name} returned an error: #{result.to_h[:message]}"
-      result
+    # ──── Execution helpers (happy‑path only) ────────────────────────────────
+    def execute_mcp_tool(name, args = {})
+      resp = ActionMCP::ToolsRegistry.tool_call(name, args)
+      assert !resp.is_error, "Tool #{name.inspect} returned error: #{resp.to_h[:message]}"
+      resp
     end
+    alias execute_tool execute_mcp_tool
 
-    # Executes a prompt with the given name and arguments.
-    # @param [String] prompt_name
-    # @param [Hash] args
-    def execute_prompt(prompt_name, args = {})
-      result = ActionMCP::PromptsRegistry.prompt_call(prompt_name, args)
-      assert_not result.is_error, "Prompt #{prompt_name} returned an error: #{result.to_h[:message]}"
-      result
+    def execute_mcp_prompt(name, args = {})
+      resp = ActionMCP::PromptsRegistry.prompt_call(name, args)
+      assert !resp.is_error, "Prompt #{name.inspect} returned error: #{resp.to_h[:message]}"
+      resp
     end
+    alias execute_prompt execute_mcp_prompt
 
-    # Asserts that the output of a tool is equal to the expected output.
-    # @param [Hash] expected_output
-    # @param [ActionMCP::ToolResponse] result
-    def assert_tool_output(expected_output, result)
-      assert_equal expected_output, result.to_h[:content],
-                   "Tool output did not match expected output #{expected_output} != #{result.to_h[:content]}"
+    # ──── Negative‑path helper ───────────────────────────────────────────────
+    def assert_mcp_error_code(code, response, msg = nil)
+      assert response.error?, msg || "Expected response to be an error"
+      assert_equal code, response.to_h[:code],
+                   msg || "Expected error code #{code}, got #{response.to_h[:code]}"
     end
+    alias assert_error_code assert_mcp_error_code
 
-    # Asserts that the output of a prompt is equal to the expected output.
-    # @param [Hash] expected_output
-    # @param [ActionMCP::PromptResponse] result
-    def assert_prompt_output(expected_output, result)
-      assert_equal expected_output, result.to_h[:messages],
-                   "Prompt output did not match expected output #{expected_output} != #{result.to_h[:messages]}"
+    # ──── Output assertions ─────────────────────────────────────────────────
+    def assert_mcp_tool_output(expected, response, msg = nil)
+      assert response.success?, msg || "Expected a successful tool response"
+      assert_equal expected, response.contents.map(&:to_h),
+                   msg || "Tool output did not match expected"
     end
+    alias assert_tool_output assert_mcp_tool_output
+
+    def assert_mcp_prompt_output(expected, response, msg = nil)
+      assert response.success?, msg || "Expected a successful prompt response"
+      assert_equal expected, response.messages,
+                   msg || "Prompt output did not match expected"
+    end
+    alias assert_prompt_output assert_mcp_prompt_output
   end
 end

data/lib/action_mcp/tool.rb

@@ -16,6 +16,7 @@ module ActionMCP
     #   @return [Array<String>] The required properties of the tool.
     class_attribute :_schema_properties, instance_accessor: false, default: {}
     class_attribute :_required_properties, instance_accessor: false, default: []
+    class_attribute :_annotations, instance_accessor: false, default: {}
 
     # --------------------------------------------------------------------------
     # Tool Name and Description DSL
@@ -45,6 +46,29 @@ module ActionMCP
       def type
         :tool
       end
+
+      def annotate(key, value)
+        self._annotations = _annotations.merge(key.to_s => value)
+      end
+
+      # Convenience methods for common annotations
+      def destructive(enabled = true)
+        annotate(:destructive, enabled)
+      end
+
+      def read_only(enabled = true)
+        annotate(:readOnly, enabled)
+      end
+
+      # Return annotations based on protocol version
+      def annotations_for_protocol(protocol_version = nil)
+        # Only include annotations for 2025+ protocols
+        if protocol_version.nil? || protocol_version == "2024-11-05"
+          {}
+        else
+          _annotations
+        end
+      end
     end
 
     # --------------------------------------------------------------------------
@@ -114,14 +138,21 @@ module ActionMCP
     # Returns a hash representation of the tool definition including its JSON Schema.
     #
     # @return [Hash] The tool definition.
-    def self.to_h
+    def self.to_h(protocol_version: nil)
       schema = { type: "object", properties: _schema_properties }
       schema[:required] = _required_properties if _required_properties.any?
-      {
+
+      result = {
         name: tool_name,
         description: description.presence,
         inputSchema: schema
       }.compact
+
+      # Add annotations if protocol supports them
+      annotations = annotations_for_protocol(protocol_version)
+      result[:annotations] = annotations if annotations.any?
+
+      result
     end
 
     # --------------------------------------------------------------------------
@@ -131,24 +162,29 @@ module ActionMCP
     # Public entry point for executing the tool
     # Returns an array of Content objects collected from render calls
     def call
-      @response = ToolResponse.new # Create a new response for each invocation
+      @response = ToolResponse.new
+      performed = false            # ← track execution
 
-      # Check validations before proceeding
       if valid?
         begin
           run_callbacks :perform do
-            perform # Invoke the subclass-specific logic if valid
+            performed = true       # ← set if we reach the block
+            perform
           end
         rescue StandardError => e
-          # Handle exceptions during execution
           @response.mark_as_error!(:internal_error, message: e.message)
         end
       else
-        # Handle validation failure
-        @response.mark_as_error!(:invalid_request, message: "Invalid input", data: errors.full_messages)
+        @response.mark_as_error!(:invalid_request,
+                                 message: "Invalid input",
+                                 data: errors.full_messages)
       end
 
-      @response # Return the response with collected content
+      # If callbacks halted execution (`performed` still false) and
+      # nothing else marked an error, surface it as invalid_request.
+      @response.mark_as_error!(:invalid_request, message: "Aborted by callback") if !performed && !@response.error?
+
+      @response
     end
 
     def inspect

data/lib/action_mcp/version.rb

@@ -2,7 +2,7 @@
 
 require_relative "gem_version"
 module ActionMCP
-  VERSION = "0.31.0"
+  VERSION = "0.32.1"
 
   class << self
     alias version gem_version

data/lib/action_mcp.rb

@@ -34,11 +34,11 @@ module ActionMCP
   require_relative "action_mcp/version"
   require_relative "action_mcp/client"
   include Logging
-  PROTOCOL_VERSION = "2024-11-05"
-
+  PROTOCOL_VERSION = "2024-11-05"  # Default version
+  CURRENT_VERSION = "2025-03-26"   # Current version for the /mcp endpoint
+  SUPPORTED_VERSIONS = %w[2024-11-05 2025-03-26].freeze
   class << self
-    attr_accessor :server
-
+    delegate :server, to: "ActionMCP::Server"
     # Returns the configuration instance.
     #
     # @return [Configuration] the configuration instance