actionmcp 0.50.5 → 0.50.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 334dbf522501eda848a1ab5d66378792b71acfd4177366de980e868be405d4dc
-  data.tar.gz: 1d29dd025817770f2389e99e9e11978e3ca813af5326d1c89ffef867267a82be
+  metadata.gz: 17696f3f1e92327c6de4d8fa4ae5b6585bf8d9e173acb47beaf713dd9d1f8b07
+  data.tar.gz: 536f24be37c5c2fbc4f440fbf1c977eadee964cd6717be5981d63cbd35081cb7
 SHA512:
-  metadata.gz: 5c7ef8680677a244d909f482440aeed23033cfb9fbe4d109a14b474eefc4eec061436c22c39bd9b161f84c30cda9e707b9b79acf96bf54582e4fadef219ce5bd
-  data.tar.gz: b8f01db29cac834c91d75353dbeaa9d96c2cc5646c04eb8d17f625b63432e1304d0ae85a7a41a9f892020ab1d64a6c2fafe2cc2d28e017bc3184886da677d9f6
+  metadata.gz: cf5c45e416e66526ee4550d611e0bbea71a3150b2f8f02af58899450308399c27e3f710348feed1d8478b27acc6701b1d01e9d6e6ab4e6f763f43ede2051d526
+  data.tar.gz: 8a27fae5101d5deb20e5f3b3b7da0a2d3d5bdfdef04681737de63f985a34a7f8cb4e3f8a9f08ae2cf886662f7855c453b19325eb5ae3ce5ec9bca141cc5bcde7

data/app/controllers/action_mcp/application_controller.rb

@@ -137,9 +137,7 @@ module ActionMCP
     # Handles POST requests containing client JSON-RPC messages according to 2025-03-26 spec.
     # @route POST /mcp
     def create
-      unless post_accept_headers_valid?
-        return render_not_acceptable(post_accept_headers_error_message)
-      end
+      return render_not_acceptable(post_accept_headers_error_message) unless post_accept_headers_valid?
 
       is_initialize_request = check_if_initialize_request(jsonrpc_params)
       session_initially_missing = extract_session_id.nil?
@@ -209,7 +207,9 @@ module ActionMCP
         session = Session.find_by(id: session_id)
         if session
           if ActionMCP.configuration.vibed_ignore_version
-            session.update!(protocol_version: self.class::REQUIRED_PROTOCOL_VERSION) if session.protocol_version != self.class::REQUIRED_PROTOCOL_VERSION
+            if session.protocol_version != self.class::REQUIRED_PROTOCOL_VERSION
+              session.update!(protocol_version: self.class::REQUIRED_PROTOCOL_VERSION)
+            end
           elsif session.protocol_version != self.class::REQUIRED_PROTOCOL_VERSION
             session.update!(protocol_version: self.class::REQUIRED_PROTOCOL_VERSION)
           end
@@ -252,6 +252,7 @@ module ActionMCP
     # Checks if the parsed body represents an 'initialize' request.
     def check_if_initialize_request(payload)
       return false unless payload.is_a?(JSON_RPC::Request) && !jsonrpc_params_batch?
+
       payload.method == "initialize"
     end
 
@@ -332,6 +333,7 @@ module ActionMCP
       sse_event = "id: #{event_id}\ndata: #{data}\n\n"
       sse.write(sse_event)
       return unless ActionMCP.configuration.enable_sse_resumability
+
       begin
         session.store_sse_event(event_id, payload, session.max_stored_sse_events)
       rescue StandardError => e
@@ -342,6 +344,7 @@ module ActionMCP
     # Helper to clean up old SSE events for a session
     def cleanup_old_sse_events(session)
       return unless ActionMCP.configuration.enable_sse_resumability
+
       begin
         retention_period = session.sse_event_retention_period
         count = session.cleanup_old_sse_events(retention_period)

data/app/models/action_mcp/session.rb

@@ -64,7 +64,9 @@ module ActionMCP
     before_create :set_server_info, if: -> { role == "server" }
     before_create :set_server_capabilities, if: -> { role == "server" }
 
-    validates :protocol_version, inclusion: { in: SUPPORTED_VERSIONS }, allow_nil: true, unless: -> { ActionMCP.configuration.vibed_ignore_version }
+    validates :protocol_version, inclusion: { in: SUPPORTED_VERSIONS }, allow_nil: true, unless: lambda {
+      ActionMCP.configuration.vibed_ignore_version
+    }
 
     def close!
       dummy_callback = ->(*) { } # this callback seem broken

data/lib/action_mcp/client/collection.rb

@@ -58,6 +58,7 @@ module ActionMCP
       # @return [Array<Object>] The next page of items, or empty array if no more pages
       def next_page(limit: nil)
         return [] unless has_more_pages?
+
         page(cursor: @next_cursor, limit: limit)
       end
 
@@ -66,7 +67,7 @@ module ActionMCP
       # @param limit [Integer, nil] Optional limit for page size
       # @yield [page] Block to process each page
       # @yieldparam page [Array<Object>] A page of items
-      def each_page(limit: nil, &block)
+      def each_page(limit: nil)
         return unless block_given?
 
         current_page = page(limit: limit)
@@ -125,12 +126,10 @@ module ActionMCP
         params[:cursor] = cursor if cursor
         params[:limit] = limit if limit
 
-        request_id = client.send(@load_method, params)
+        client.send(@load_method, params)
 
         start_time = Time.now
-        while !@loaded && (Time.now - start_time) < timeout
-          sleep(0.1)
-        end
+        sleep(0.1) while !@loaded && (Time.now - start_time) < timeout
 
         # Update @loaded status even if we timed out
         @loaded = true

data/lib/action_mcp/content/image.rb

@@ -23,8 +23,7 @@ module ActionMCP
       #
       # @return [Hash] The hash representation of the image content.
       def to_h
-        h = super.merge(data: @data, mimeType: @mime_type)
-        h
+        super.merge(data: @data, mimeType: @mime_type)
       end
     end
   end

data/lib/action_mcp/json_rpc_handler_base.rb

@@ -2,6 +2,34 @@
 
 module ActionMCP
   class JsonRpcHandlerBase
+    module Methods
+      # Common methods
+      PING = "ping"
+
+      # Server methods
+      INITIALIZE = "initialize"
+      COMPLETION_COMPLETE = "completion/complete"
+
+      # Resource methods
+      RESOURCES_LIST = "resources/list"
+      RESOURCES_TEMPLATES_LIST = "resources/templates/list"
+      RESOURCES_READ = "resources/read"
+      RESOURCES_SUBSCRIBE = "resources/subscribe"
+      RESOURCES_UNSUBSCRIBE = "resources/unsubscribe"
+
+      # Prompt methods
+      PROMPTS_GET = "prompts/get"
+      PROMPTS_LIST = "prompts/list"
+
+      # Tool methods
+      TOOLS_LIST = "tools/list"
+      TOOLS_CALL = "tools/call"
+
+      # Notification methods
+      NOTIFICATIONS_INITIALIZED = "notifications/initialized"
+      NOTIFICATIONS_CANCELLED = "notifications/cancelled"
+    end
+
     delegate :initialize!, :initialized?, to: :transport
     delegate :write, :read, to: :transport
     attr_reader :transport
@@ -11,38 +39,14 @@ module ActionMCP
       @transport = transport
     end
 
-    # Process a single line of input.
-    # @param line [String, 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
-      process_request(request)
+    # Process a request object.
+    # @param request [JSON_RPC::Request, JSON_RPC::Notification, JSON_RPC::Response]
+    def call(request)
+      raise NotImplementedError, "Subclasses must implement call"
     end
 
     protected
 
-    # Validate if the request follows JSON-RPC 2.0 specification
-    # @param request [Hash]
-    # @return [Boolean]
-    def valid_request?(request)
-      if request["jsonrpc"] != "2.0"
-        puts "Invalid request: #{request}"
-        return false
-      end
-      true
-    end
-
     # Handle common methods for both client and server
     # @param rpc_method [String]
     # @param id [String, Integer]
@@ -50,11 +54,10 @@ module ActionMCP
     # @return [Boolean] true if handled, false otherwise
     def handle_common_methods(rpc_method, id, params)
       case rpc_method
-      when "ping"
+      when Methods::PING
         transport.send_pong(id)
         true
       when %r{^notifications/}
-        puts "\e[31mProcessing notifications\e[0m"
         process_notifications(rpc_method, params)
         true
       else
@@ -62,47 +65,22 @@ module ActionMCP
       end
     end
 
-    # Method to be overridden by subclasses to handle specific RPC methods
-    # @param rpc_method [String]
-    # @param id [String, Integer]
-    # @param params [Hash]
-    def handle_method(rpc_method, id, params)
-      raise NotImplementedError, "Subclasses must implement handle_method"
-    end
-
-    private
-
-    # @param request [Hash]
-    def process_request(request)
-      return unless valid_request?(request)
-
-      request = request.with_indifferent_access
-
-      read(request)
-      id = request["id"]
-
-      unless (rpc_method = request["method"])
-        # this is a response or a bobo
-        return process_response(id, request["result"]) if request["result"]
-        return process_error(id, request["error"]) if request["error"]
-      end
-
-      params = request["params"]
-      # Try to handle common methods first
-      return if handle_common_methods(rpc_method, id, params)
-
-      # Delegate to subclass-specific handling
-      handle_method(rpc_method, id, params)
-    end
-
+    # Process notification methods
     def process_notifications(rpc_method, params)
       case rpc_method
-      when "notifications/cancelled" # [BOTH] Request cancellation
-        puts "\e[31m Request #{params['requestId']} cancelled: #{params['reason']}\e[0m"
-        # we don't need to do anything here
+      when Methods::NOTIFICATIONS_CANCELLED
+        handle_cancelled_notification(params)
       else
         Rails.logger.warn("Unknown notifications method: #{rpc_method}")
       end
     end
+
+    private
+
+    # Handle cancelled notification
+    def handle_cancelled_notification(params)
+      Rails.logger.warn "\e[31m Request #{params['requestId']} cancelled: #{params['reason']}\e[0m"
+      # we don't need to do anything here
+    end
   end
 end

data/lib/action_mcp/server/capabilities.rb

@@ -57,10 +57,10 @@ module ActionMCP
         capabilities_payload = session.server_capabilities_payload
         # If vibed_ignore_version is true, always use the latest supported version in the response
         # Otherwise, use the client's requested version
-        if ActionMCP.configuration.vibed_ignore_version
-          capabilities_payload[:protocolVersion] = PROTOCOL_VERSION
+        capabilities_payload[:protocolVersion] = if ActionMCP.configuration.vibed_ignore_version
+                                                   PROTOCOL_VERSION
         else
-          capabilities_payload[:protocolVersion] = client_protocol_version
+                                                   client_protocol_version
         end
 
         send_jsonrpc_response(request_id, result: capabilities_payload)

data/lib/action_mcp/server/error_aware.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module ActionMCP
+  module Server
+    module ErrorAware
+      private
+
+      # Validate required parameter and raise error if missing
+      def validate_required_param(params, key, error_message)
+        value = params[key] || params[key.to_sym]
+        raise JSON_RPC::JsonRpcError.new(:invalid_params, message: error_message) if value.nil?
+
+        value
+      end
+
+      # Validate params is not nil or empty
+      def validate_params_present(params, error_message)
+        raise JSON_RPC::JsonRpcError.new(:invalid_params, message: error_message) if params.nil? || params.empty?
+
+        params
+      end
+
+      # Safe execution with JSON-RPC error handling
+      def with_error_handling(request_id)
+        yield
+      rescue JSON_RPC::JsonRpcError => e
+        error_response(request_id, e)
+      end
+    end
+  end
+end

data/lib/action_mcp/server/error_handling.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module ActionMCP
+  module Server
+    module ErrorHandling
+      private
+
+      def error_response(id, error_or_symbol, message = nil, data = nil)
+        json_rpc_error = case error_or_symbol
+        when JSON_RPC::JsonRpcError
+                           error_or_symbol
+        when Symbol
+                           JSON_RPC::JsonRpcError.new(error_or_symbol, message: message, data: data)
+        else
+                           # If it's already an error hash
+                           error_or_symbol
+        end
+
+        {
+          type: :error,
+          request_id: id,
+          payload: {
+            jsonrpc: "2.0",
+            id: id,
+            error: json_rpc_error.to_h
+          }
+        }
+      end
+
+      # Helper method to create error response from any exception
+      def error_response_from_exception(id, exception)
+        if exception.is_a?(JSON_RPC::JsonRpcError)
+          error_response(id, exception)
+        else
+          error_response(id, :internal_error, exception.message)
+        end
+      end
+    end
+  end
+end

data/lib/action_mcp/server/handlers/prompt_handler.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module ActionMCP
+  module Server
+    module Handlers
+      module PromptHandler
+        include ErrorAware
+
+        def process_prompts(rpc_method, id, params)
+          params ||= {}
+
+          with_error_handling(id) do
+            handler = prompt_method_handlers[rpc_method]
+            if handler
+              send(handler, id, params)
+            else
+              Rails.logger.warn("Unknown prompts method: #{rpc_method}")
+              raise JSON_RPC::JsonRpcError.new(:method_not_found, message: "Unknown prompts method: #{rpc_method}")
+            end
+          end
+        end
+
+        private
+
+        def prompt_method_handlers
+          {
+            JsonRpcHandlerBase::Methods::PROMPTS_GET => :handle_prompts_get,
+            JsonRpcHandlerBase::Methods::PROMPTS_LIST => :handle_prompts_list
+          }
+        end
+
+        def handle_prompts_get(id, params)
+          name = extract_name(params)
+          arguments = extract_arguments(params)
+
+          message = transport.send_prompts_get(id, name, arguments)
+          extract_message_payload(message, id)
+        end
+
+        def handle_prompts_list(id, _params)
+          message = transport.send_prompts_list(id)
+          extract_message_payload(message, id)
+        end
+
+        def extract_name(params)
+          params["name"] || params[:name]
+        end
+
+        def extract_arguments(params)
+          params["arguments"] || params[:arguments] || {}
+        end
+      end
+    end
+  end
+end

data/lib/action_mcp/server/handlers/resource_handler.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module ActionMCP
+  module Server
+    module Handlers
+      module ResourceHandler
+        include ErrorAware
+
+        def process_resources(rpc_method, id, params)
+          params ||= {}
+
+          with_error_handling(id) do
+            handler = resource_method_handlers[rpc_method]
+            if handler
+              send(handler, id, params)
+            else
+              Rails.logger.warn("Unknown resources method: #{rpc_method}")
+              raise JSON_RPC::JsonRpcError.new(:method_not_found, message: "Unknown resources method: #{rpc_method}")
+            end
+          end
+        end
+
+        private
+
+        def resource_method_handlers
+          {
+            JsonRpcHandlerBase::Methods::RESOURCES_LIST => :handle_resources_list,
+            JsonRpcHandlerBase::Methods::RESOURCES_TEMPLATES_LIST => :handle_resources_templates_list,
+            JsonRpcHandlerBase::Methods::RESOURCES_READ => :handle_resources_read,
+            JsonRpcHandlerBase::Methods::RESOURCES_SUBSCRIBE => :handle_resources_subscribe,
+            JsonRpcHandlerBase::Methods::RESOURCES_UNSUBSCRIBE => :handle_resources_unsubscribe
+          }
+        end
+
+        def handle_resources_list(id, _params)
+          message = transport.send_resources_list(id)
+          extract_message_payload(message, id)
+        end
+
+        def handle_resources_templates_list(id, _params)
+          message = transport.send_resource_templates_list(id)
+          extract_message_payload(message, id)
+        end
+
+        def handle_resources_read(id, params)
+          validate_params_present(params, "Resource URI is required")
+
+          message = transport.send_resource_read(id, params)
+          extract_message_payload(message, id)
+        end
+
+        def handle_resources_subscribe(id, params)
+          uri = validate_required_param(params, "uri", "Resource URI is required")
+
+          message = transport.send_resource_subscribe(id, uri)
+          extract_message_payload(message, id)
+        end
+
+        def handle_resources_unsubscribe(id, params)
+          uri = validate_required_param(params, "uri", "Resource URI is required")
+
+          message = transport.send_resource_unsubscribe(id, uri)
+          extract_message_payload(message, id)
+        end
+      end
+    end
+  end
+end

data/lib/action_mcp/server/handlers/tool_handler.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module ActionMCP
+  module Server
+    module Handlers
+      module ToolHandler
+        include ErrorAware
+
+        def process_tools(rpc_method, id, params)
+          params ||= {}
+
+          with_error_handling(id) do
+            handler = tool_method_handlers[rpc_method]
+            if handler
+              send(handler, id, params)
+            else
+              Rails.logger.warn("Unknown tools method: #{rpc_method}")
+              raise JSON_RPC::JsonRpcError.new(:method_not_found, message: "Unknown tools method: #{rpc_method}")
+            end
+          end
+        end
+
+        private
+
+        def tool_method_handlers
+          {
+            JsonRpcHandlerBase::Methods::TOOLS_LIST => :handle_tools_list,
+            JsonRpcHandlerBase::Methods::TOOLS_CALL => :handle_tools_call
+          }
+        end
+
+        def handle_tools_list(id, params)
+          message = transport.send_tools_list(id, params)
+          extract_message_payload(message, id)
+        end
+
+        def handle_tools_call(id, params)
+          name = validate_required_param(params, "name", "Tool name is required")
+          arguments = extract_arguments(params)
+
+          message = transport.send_tools_call(id, name, arguments)
+          extract_message_payload(message, id)
+        end
+
+        def extract_arguments(params)
+          params["arguments"] || params[:arguments] || {}
+        end
+      end
+    end
+  end
+end

data/lib/action_mcp/server/json_rpc_handler.rb

@@ -3,10 +3,17 @@
 module ActionMCP
   module Server
     class JsonRpcHandler < JsonRpcHandlerBase
+      include Handlers::ResourceHandler
+      include Handlers::ToolHandler
+      include Handlers::PromptHandler
+      include ErrorHandling
+      include ErrorAware
+
       # Handle server-specific methods
       # @param request [JSON_RPC::Request, JSON_RPC::Notification, JSON_RPC::Response]
       def call(request)
         read(request.to_h)
+
         case request
         when JSON_RPC::Request
           handle_request(request)
@@ -20,134 +27,63 @@ module ActionMCP
       private
 
       def handle_request(request)
-        @current_request_id = id = request.id
+        id = request.id
         rpc_method = request.method
         params = request.params
 
+        with_error_handling(id) do
+          # Try to handle common methods first (like ping)
+          return if handle_common_methods(rpc_method, id, params)
+
+          # Route to appropriate handler
+          route_to_handler(rpc_method, id, params)
+        end
+      end
+
+      def route_to_handler(rpc_method, id, params)
         case rpc_method
-        when "initialize"
-          message = transport.send_capabilities(id, params)
-          extract_message_payload(message, id)
+        when Methods::INITIALIZE
+          handle_initialize(id, params)
         when %r{^prompts/}
           process_prompts(rpc_method, id, params)
         when %r{^resources/}
           process_resources(rpc_method, id, params)
         when %r{^tools/}
           process_tools(rpc_method, id, params)
-        when "completion/complete"
+        when Methods::COMPLETION_COMPLETE
           process_completion_complete(id, params)
         else
-          error_response(id, :method_not_found, "Method not found: #{rpc_method}")
+          raise JSON_RPC::JsonRpcError.new(:method_not_found, message: "Method not found: #{rpc_method}")
         end
       end
 
+      def handle_initialize(id, params)
+        message = transport.send_capabilities(id, params)
+        extract_message_payload(message, id)
+      end
+
       def handle_notification(notification)
-        @current_request_id = nil
-
-        begin
-          method_name = notification.method.to_s
-          params = notification.params || {}
-
-          process_notifications(method_name, params)
-          { type: :notifications_only }
-        rescue StandardError => e
-          Rails.logger.error("Error handling notification #{notification.method}: #{e.message}")
-          Rails.logger.error(e.backtrace.join("\n"))
-          { type: :notifications_only }
-        end
+        method_name = notification.method.to_s
+        params = notification.params || {}
+
+        process_notifications(method_name, params)
+        { type: :notifications_only }
       end
 
       def handle_response(response)
         Rails.logger.debug("Received response: #{response.inspect}")
+
         {
           type: :responses,
           request_id: response.id,
-          payload: {
-            jsonrpc: "2.0",
-            id: response.id,
-            result: response.result
-          }
+          payload: build_response_payload(response)
         }
       end
 
-      def process_prompts(rpc_method, id, params)
-        params ||= {}
-
-        case rpc_method
-        when "prompts/get"
-          name = params["name"] || params[:name]
-          arguments = params["arguments"] || params[:arguments] || {}
-          message = transport.send_prompts_get(id, name, arguments)
-          extract_message_payload(message, id)
-        when "prompts/list"
-          message = transport.send_prompts_list(id)
-          extract_message_payload(message, id)
-        else
-          Rails.logger.warn("Unknown prompts method: #{rpc_method}")
-          error_response(id, :method_not_found, "Unknown prompts method: #{rpc_method}")
-        end
-      end
-
-      def process_tools(rpc_method, id, params)
-        params ||= {}
-
-        case rpc_method
-        when "tools/list"
-          message = transport.send_tools_list(id, params)
-          extract_message_payload(message, id)
-        when "tools/call"
-          name = params["name"] || params[:name]
-          arguments = params["arguments"] || params[:arguments] || {}
-
-          return error_response(id, :invalid_params, "Tool name is required") if name.nil?
-
-          message = transport.send_tools_call(id, name, arguments)
-          extract_message_payload(message, id)
-        else
-          Rails.logger.warn("Unknown tools method: #{rpc_method}")
-          error_response(id, :method_not_found, "Unknown tools method: #{rpc_method}")
-        end
-      end
-
-      def process_resources(rpc_method, id, params)
-        params ||= {}
-
-        case rpc_method
-        when "resources/list"
-          message = transport.send_resources_list(id)
-          extract_message_payload(message, id)
-        when "resources/templates/list"
-          message = transport.send_resource_templates_list(id)
-          extract_message_payload(message, id)
-        when "resources/read"
-          return error_response(id, :invalid_params, "Resource URI is required") if params.nil? || params.empty?
-
-          message = transport.send_resource_read(id, params)
-          extract_message_payload(message, id)
-        when "resources/subscribe"
-          uri = params["uri"] || params[:uri]
-          return error_response(id, :invalid_params, "Resource URI is required") if uri.nil?
-
-          message = transport.send_resource_subscribe(id, uri)
-          extract_message_payload(message, id)
-        when "resources/unsubscribe"
-          uri = params["uri"] || params[:uri]
-          return error_response(id, :invalid_params, "Resource URI is required") if uri.nil?
-
-          message = transport.send_resource_unsubscribe(id, uri)
-          extract_message_payload(message, id)
-        else
-          Rails.logger.warn("Unknown resources method: #{rpc_method}")
-          error_response(id, :method_not_found, "Unknown resources method: #{rpc_method}")
-        end
-      end
-
       def process_completion_complete(id, params)
         params ||= {}
 
-        result = transport.send_jsonrpc_response(id, result: {
-          completion: { values: [], total: 0, hasMore: false }
-        })
+        result = transport.send_jsonrpc_response(id, result: build_completion_result)
 
         if result.is_a?(ActionMCP::Session::Message)
           extract_message_payload(result, id)
@@ -158,8 +94,7 @@ module ActionMCP
 
       def process_notifications(rpc_method, params)
         case rpc_method
-        when "notifications/initialized"
-          Rails.logger.info "Client notified initialization complete"
+        when Methods::NOTIFICATIONS_INITIALIZED
           transport.initialize!
         else
           super
@@ -174,7 +109,7 @@ module ActionMCP
             payload: message.message_json
           }
         else
-        message
+          message
         end
       end
 
@@ -190,23 +125,17 @@ module ActionMCP
         end
       end
 
-      def error_response(id, code, message)
-        error_code = case code
-        when :method_not_found then -32_601
-        when :invalid_params then -32_602
-        when :internal_error then -32_603
-        else -32_000
-        end
+      def build_response_payload(response)
+        {
+          jsonrpc: "2.0",
+          id: response.id,
+          result: response.result
+        }
+      end
 
+      def build_completion_result
         {
-          type: :error,
-          request_id: id,
-          payload: {
-            jsonrpc: "2.0",
-            id: id,
-            error: { code: error_code, message: message }
-          },
-          status: :bad_request
+          completion: { values: [], total: 0, hasMore: false }
         }
       end
     end

data/lib/action_mcp/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: actionmcp
 version: !ruby/object:Gem::Version
-  version: 0.50.5
+  version: 0.50.7
 platform: ruby
 authors:
 - Abdelkader Boudih
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-05-14 00:00:00.000000000 Z
+date: 2025-05-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -169,6 +169,11 @@ files:
 - lib/action_mcp/server.rb
 - lib/action_mcp/server/capabilities.rb
 - lib/action_mcp/server/configuration.rb
+- lib/action_mcp/server/error_aware.rb
+- lib/action_mcp/server/error_handling.rb
+- lib/action_mcp/server/handlers/prompt_handler.rb
+- lib/action_mcp/server/handlers/resource_handler.rb
+- lib/action_mcp/server/handlers/tool_handler.rb
 - lib/action_mcp/server/json_rpc_handler.rb
 - lib/action_mcp/server/messaging.rb
 - lib/action_mcp/server/notifications.rb