actionmcp 0.50.1 → 0.50.3

data/lib/action_mcp/server/json_rpc_handler.rb

@@ -4,37 +4,30 @@ module ActionMCP
   module Server
     class JsonRpcHandler < JsonRpcHandlerBase
       # 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
+      # @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)
+        when JSON_RPC::Notification
+          handle_notification(request)
+        when JSON_RPC::Response
+          handle_response(request)
         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
+      private
+
+      def handle_request(request)
+        @current_request_id = id = request.id
+        rpc_method = request.method
+        params = request.params
 
         case rpc_method
         when "initialize"
-          transport.send_capabilities(id, params)
+          message = transport.send_capabilities(id, params)
+          extract_message_payload(message, id)
         when %r{^prompts/}
           process_prompts(rpc_method, id, params)
         when %r{^resources/}
@@ -44,104 +37,178 @@ module ActionMCP
         when "completion/complete"
           process_completion_complete(id, params)
         else
-          transport.send_jsonrpc_error(id, :method_not_found, "Method not found #{rpc_method}")
+          error_response(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
 
+      def handle_notification(notification)
+        @current_request_id = nil
 
-      # Server methods (client → server)
-
-      # @param id [String]
-      # @param params [Hash]
-      # @example {
-      #     "ref": {
-      #       "type": "ref/prompt",
-      #       "name": "code_review"
-      #     },
-      #     "argument": {
-      #       "name": "language",
-      #       "value": "py"
-      #     }
-      #   }
-      # @return [Hash]
-      # @example {
-      #     "completion": {
-      #       "values": ["python", "pytorch", "pyside"],
-      #       "total": 10,
-      #       "hasMore": true
-      #     }
-      #   }
-      def process_completion_complete(id, params)
-        # TODO: Not Implemented, but to remove the error message in the inspector
-        transport.send_jsonrpc_response(id, result: { completion: { values: [], total: 0, hasMore: false } })
-        case params["ref"]["type"]
-        when "ref/prompt"
-          # TODO: Implement completion
-        when "ref/resource"
-          # TODO: Implement completion
+        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
       end
 
-      # @param rpc_method [String]
-      # @param id [String]
-      # @param params [Hash]
+      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
+          }
+        }
+      end
+
       def process_prompts(rpc_method, id, params)
+        params ||= {}
+
         case rpc_method
-        when "prompts/get" # Get specific prompt
-          transport.send_prompts_get(id, params["name"], params["arguments"])
-        when "prompts/list" # List available prompts
-          transport.send_prompts_list(id)
+        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
 
-      # @param rpc_method [String]
-      # @param id [String]
-      # @param params [Hash]
       def process_tools(rpc_method, id, params)
+        params ||= {}
+
         case rpc_method
-        when "tools/list" # List available tools
-          transport.send_tools_list(id, params)
-        when "tools/call" # Call a tool
-          transport.send_tools_call(id, params["name"], params["arguments"])
+        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
 
-      # @param rpc_method [String]
-      # @param id [String]
-      # @param params [Hash]
       def process_resources(rpc_method, id, params)
+        params ||= {}
+
         case rpc_method
-        when "resources/list" # List available resources
-          transport.send_resources_list(id)
-        when "resources/templates/list" # List resource templates
-          transport.send_resource_templates_list(id)
-        when "resources/read" # Read resource content
-          transport.send_resource_read(id, params)
-        when "resources/subscribe" # Subscribe to resource updates
-          transport.send_resource_subscribe(id, params["uri"])
-        when "resources/unsubscribe" # Unsubscribe from resource updates
-          transport.send_resource_unsubscribe(id, params["uri"])
+        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 }
+        })
+
+        if result.is_a?(ActionMCP::Session::Message)
+          extract_message_payload(result, id)
+        else
+          wrap_transport_result(result, id)
         end
       end
 
       def process_notifications(rpc_method, params)
         case rpc_method
-        when "notifications/initialized" # Client initialization complete
-          puts "\e[31mInitialized\e[0m"
+        when "notifications/initialized"
+          Rails.logger.info "Client notified initialization complete"
           transport.initialize!
         else
           super
         end
       end
+
+      def extract_message_payload(message, id)
+        if message.is_a?(ActionMCP::Session::Message)
+          {
+            type: :responses,
+            request_id: id,
+            payload: message.message_json
+          }
+        else
+        message
+        end
+      end
+
+      def wrap_transport_result(transport_result, id)
+        if transport_result.is_a?(Hash) && transport_result[:type]
+          transport_result
+        else
+          {
+            type: :responses,
+            request_id: id,
+            payload: transport_result
+          }
+        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
+
+        {
+          type: :error,
+          request_id: id,
+          payload: {
+            jsonrpc: "2.0",
+            id: id,
+            error: { code: error_code, message: message }
+          },
+          status: :bad_request
+        }
+      end
     end
   end
 end

data/lib/action_mcp/server/registry_management.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # lib/action_mcp/server/registry_management.rb
 module ActionMCP
   module Server

data/lib/action_mcp/server/simple_pub_sub.rb

@@ -13,7 +13,7 @@ module ActionMCP
       DEFAULT_MIN_THREADS = 5
       DEFAULT_MAX_THREADS = 10
       DEFAULT_MAX_QUEUE = 100
-      DEFAULT_THREAD_TIMEOUT = 60  # seconds
+      DEFAULT_THREAD_TIMEOUT = 60 # seconds
 
       def initialize(options = {})
         @subscriptions = Concurrent::Map.new
@@ -58,6 +58,7 @@ module ActionMCP
       def subscribed_to?(channel)
         channel_subs = @channels[channel]
         return false if channel_subs.nil?
+
         !channel_subs.empty?
       end
 
@@ -91,11 +92,9 @@ module ActionMCP
           next unless subscription && subscription[:message_callback]
 
           @thread_pool.post do
-            begin
-              subscription[:message_callback].call(message)
-            rescue StandardError => e
-              log_error("Error in message callback: #{e.message}\n#{e.backtrace.join("\n")}")
-            end
+            subscription[:message_callback].call(message)
+          rescue StandardError => e
+            log_error("Error in message callback: #{e.message}\n#{e.backtrace.join("\n")}")
           end
         end
       end
@@ -106,6 +105,7 @@ module ActionMCP
       def has_subscribers?(channel)
         subscribers = @channels[channel]
         return false unless subscribers
+
         !subscribers.empty?
       end
 
@@ -138,6 +138,7 @@ module ActionMCP
 
       def log_error(message)
         return unless defined?(Rails) && Rails.respond_to?(:logger)
+
         Rails.logger.error("SimplePubSub: #{message}")
       end
     end

data/lib/action_mcp/server/solid_cable_adapter.rb

@@ -39,13 +39,13 @@ module ActionMCP
       DEFAULT_MIN_THREADS = 5
       DEFAULT_MAX_THREADS = 10
       DEFAULT_MAX_QUEUE = 100
-      DEFAULT_THREAD_TIMEOUT = 60  # seconds
+      DEFAULT_THREAD_TIMEOUT = 60 # seconds
 
       def initialize(options = {})
         @options = options
         @subscriptions = Concurrent::Map.new
         @channels = Concurrent::Map.new
-        @channel_subscribed = Concurrent::Map.new  # Track channel subscription status
+        @channel_subscribed = Concurrent::Map.new # Track channel subscription status
 
         # Initialize thread pool for callbacks
         pool_options = {
@@ -69,15 +69,13 @@ module ActionMCP
         end
 
         # If there's a connects_to option, pass it along
-        if @options["connects_to"]
-          pubsub_options[:connects_to] = @options["connects_to"]
-        end
+        pubsub_options[:connects_to] = @options["connects_to"] if @options["connects_to"]
 
         # Use mock version for testing or real version in production
-        if defined?(SolidCable) && !testing?
-          @solid_cable_pubsub = SolidCable::PubSub.new(pubsub_options)
+        @solid_cable_pubsub = if defined?(SolidCable) && !testing?
+                                SolidCable::PubSub.new(pubsub_options)
         else
-          @solid_cable_pubsub = MockSolidCablePubSub.new(pubsub_options)
+                                MockSolidCablePubSub.new(pubsub_options)
         end
       end
 
@@ -147,6 +145,7 @@ module ActionMCP
       def has_subscribers?(channel)
         subscribers = @channels[channel]
         return false unless subscribers
+
         !subscribers.empty?
       end
 
@@ -156,6 +155,7 @@ module ActionMCP
       def subscribed_to?(channel)
         channel_subs = @channels[channel]
         return false if channel_subs.nil?
+
         !channel_subs.empty?
       end
 
@@ -185,11 +185,9 @@ module ActionMCP
           next unless subscription && subscription[:message_callback]
 
           @thread_pool.post do
-            begin
-              subscription[:message_callback].call(message)
-            rescue StandardError => e
-              log_error("Error in message callback: #{e.message}\n#{e.backtrace.join("\n")}")
-            end
+            subscription[:message_callback].call(message)
+          rescue StandardError => e
+            log_error("Error in message callback: #{e.message}\n#{e.backtrace.join("\n")}")
           end
         end
       end
@@ -215,6 +213,7 @@ module ActionMCP
 
       def log_error(message)
         return unless defined?(Rails) && Rails.respond_to?(:logger)
+
         Rails.logger.error("SolidCableAdapter: #{message}")
       end
     end

data/lib/action_mcp/server/tools.rb

@@ -18,9 +18,9 @@ module ActionMCP
         end
 
         # Use session's registered tools instead of global registry
-        tools = session.registered_tools.map { |tool_class|
+        tools = session.registered_tools.map do |tool_class|
           tool_class.to_h(protocol_version: protocol_version)
-        }
+        end
 
         # Send completion progress notification if token is provided
         if progress_token

data/lib/action_mcp/server.rb

@@ -23,6 +23,7 @@ module ActionMCP
     # Shut down the server and clean up resources
     def shutdown
       return unless @server
+
       @server.shutdown
       @server = nil
     end
@@ -49,7 +50,7 @@ module ActionMCP
       def configure(config_path)
         shutdown_pubsub if @pubsub
         @configuration = Configuration.new(config_path)
-        @pubsub = nil  # Reset pubsub so it will be recreated with new config
+        @pubsub = nil # Reset pubsub so it will be recreated with new config
       end
 
       # Gracefully shut down the server and its resources
@@ -61,11 +62,11 @@ module ActionMCP
 
       # Shut down the pubsub adapter gracefully
       def shutdown_pubsub
-        return unless @pubsub && @pubsub.respond_to?(:shutdown)
+        return unless @pubsub.respond_to?(:shutdown)
 
         begin
           @pubsub.shutdown
-        rescue => e
+        rescue StandardError => e
           message = "Error shutting down pubsub adapter: #{e.message}"
           Rails.logger.error(message) if defined?(Rails) && Rails.respond_to?(:logger)
         ensure
@@ -87,7 +88,7 @@ module ActionMCP
         rescue NameError, LoadError => e
           message = "Error creating adapter #{adapter_name}: #{e.message}"
           Rails.logger.error(message) if defined?(Rails) && Rails.respond_to?(:logger)
-          SimplePubSub.new  # Fallback to simple pubsub
+          SimplePubSub.new # Fallback to simple pubsub
         end
       end
     end

data/lib/action_mcp/tool.rb

@@ -61,7 +61,7 @@ module ActionMCP
       end
 
       # Return annotations for the tool
-      def annotations_for_protocol(protocol_version = nil)
+      def annotations_for_protocol(_protocol_version = nil)
         # Always include annotations now that we only support 2025+
         _annotations
       end

data/lib/action_mcp/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: actionmcp
 version: !ruby/object:Gem::Version
-  version: 0.50.1
+  version: 0.50.3
 platform: ruby
 authors:
 - Abdelkader Boudih
@@ -23,6 +23,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 8.0.1
+- !ruby/object:Gem::Dependency
+  name: concurrent-ruby
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.3.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.3.1
 - !ruby/object:Gem::Dependency
   name: jsonrpc-rails
   requirement: !ruby/object:Gem::Requirement
@@ -79,20 +93,6 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '2.6'
-- !ruby/object:Gem::Dependency
-  name: concurrent-ruby
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 1.3.1
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 1.3.1
 description: It offers base classes and helpers for creating MCP applications, making
   it easier to integrate your Ruby/Rails application with the MCP standard
 email:
@@ -105,8 +105,7 @@ files:
 - MIT-LICENSE
 - README.md
 - Rakefile
-- app/controllers/action_mcp/mcp_controller.rb
-- app/controllers/action_mcp/unified_controller.rb
+- app/controllers/action_mcp/application_controller.rb
 - app/models/action_mcp.rb
 - app/models/action_mcp/application_record.rb
 - app/models/action_mcp/session.rb

data/app/controllers/action_mcp/mcp_controller.rb

@@ -1,79 +0,0 @@
-# frozen_string_literal: true
-
-module ActionMCP
-  class MCPController < ActionController::Metal
-    abstract!
-    ActionController::API.without_modules(:StrongParameters, :ParamsWrapper).each do |left|
-      include left
-    end
-    include Engine.routes.url_helpers
-
-    # Header name for MCP Session ID (as per 2025-03-26 spec)
-    MCP_SESSION_ID_HEADER = "Mcp-Session-Id"
-
-    # Provides the ActionMCP::Session for the current request.
-    # Handles finding existing sessions via header/param or initializing a new one.
-    # Specific controllers/handlers might need to enforce session ID presence based on context.
-    # @return [ActionMCP::Session] The session object (might be unsaved if new)
-    def mcp_session
-      @mcp_session ||= find_or_initialize_session
-    end
-
-    # Provides a unique key for caching or pub/sub based on the session ID.
-    # Ensures mcp_session is called first to establish the session ID.
-    # @return [String] The session key string.
-    def session_key
-      @session_key ||= "action_mcp-sessions-#{mcp_session.id}"
-    end
-
-    private
-
-    # Finds an existing session based on header or param, or initializes a new one.
-    # Note: This doesn't save the new session; that happens upon first use or explicitly.
-    def find_or_initialize_session
-      session_id = extract_session_id
-      if session_id
-        session = Session.find_by(id: session_id)
-        if session && session.protocol_version != self.class::REQUIRED_PROTOCOL_VERSION
-          # Update existing session to use 2025 protocol
-          session.update!(protocol_version: self.class::REQUIRED_PROTOCOL_VERSION)
-        end
-        session
-      else
-        # Create new session with 2025 protocol
-        Session.new(protocol_version: self.class::REQUIRED_PROTOCOL_VERSION)
-      end
-    end
-
-    # Renders a 400 Bad Request response with a JSON-RPC-like error structure.
-    def render_bad_request(message = "Bad Request")
-      # Using -32600 for Invalid Request based on JSON-RPC spec
-      render json: { jsonrpc: "2.0", error: { code: -32_600, message: message } }
-    end
-
-    # Renders a 404 Not Found response with a JSON-RPC-like error structure.
-    def render_not_found(message = "Not Found")
-      # Using a custom code or a generic server error range code might be appropriate.
-      # Let's use -32001 for a generic server error.
-      render json: { jsonrpc: "2.0", error: { code: -32_001, message: message } }
-    end
-
-    # Renders a 405 Method Not Allowed response.
-    def render_method_not_allowed(message = "Method Not Allowed")
-      # Using -32601 Method not found from JSON-RPC spec seems applicable
-      render json: { jsonrpc: "2.0", error: { code: -32_601, message: message } }
-    end
-
-    # Renders a 406 Not Acceptable response.
-    def render_not_acceptable(message = "Not Acceptable")
-      # No direct JSON-RPC equivalent, using a generic server error code.
-      render json: { jsonrpc: "2.0", error: { code: -32_002, message: message } }
-    end
-
-    # Renders a 501 Not Implemented response.
-    def render_not_implemented(message = "Not Implemented")
-      # No direct JSON-RPC equivalent, using a generic server error code.
-      render json: { jsonrpc: "2.0", error: { code: -32_003, message: message } }
-    end
-  end
-end