actionmcp 0.31.1 → 0.33.0

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

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require "yaml"
+require "erb"
+
+module ActionMCP
+  module Server
+    # Configuration loader for ActionMCP server
+    class Configuration
+      attr_reader :config
+
+      def initialize(config_path = nil)
+        @config_path = config_path || default_config_path
+        @config = load_config
+      end
+
+      # Get the configuration for the current environment
+      def for_env(env = nil)
+        environment = env || (defined?(Rails) ? Rails.env : "development")
+        config[environment] || config["development"] || {}
+      end
+
+      # Get the adapter name for the current environment
+      def adapter_name(env = nil)
+        env_config = for_env(env)
+        env_config["adapter"]
+      end
+
+      # Get the adapter options for the current environment
+      def adapter_options(env = nil)
+        env_config = for_env(env)
+        env_config.except("adapter")
+      end
+
+      private
+
+      def load_config
+        return {} unless File.exist?(@config_path.to_s)
+
+        yaml = ERB.new(File.read(@config_path)).result
+        YAML.safe_load(yaml, aliases: true) || {}
+      rescue => e
+        Rails.logger.error("Error loading ActionMCP config: #{e.message}") if defined?(Rails) && Rails.respond_to?(:logger)
+        {}
+      end
+
+      def default_config_path
+        return Rails.root.join("config", "mcp.yml") if defined?(Rails) && Rails.respond_to?(:root)
+
+        # Fallback to looking for a mcp.yml in the current directory or parent directories
+        path = Dir.pwd
+        while path != "/"
+          config_path = File.join(path, "config", "mcp.yml")
+          return config_path if File.exist?(config_path)
+          path = File.dirname(path)
+        end
+
+        # Default to an empty config if no mcp.yml found
+        nil
+      end
+    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/simple_pub_sub.rb

@@ -0,0 +1,145 @@
+# frozen_string_literal: true
+
+require "securerandom"
+require "concurrent/map"
+require "concurrent/array"
+require "concurrent/executor/thread_pool_executor"
+
+module ActionMCP
+  module Server
+    # Simple in-memory PubSub implementation for testing and development
+    class SimplePubSub
+      # Thread pool configuration
+      DEFAULT_MIN_THREADS = 5
+      DEFAULT_MAX_THREADS = 10
+      DEFAULT_MAX_QUEUE = 100
+      DEFAULT_THREAD_TIMEOUT = 60  # seconds
+
+      def initialize(options = {})
+        @subscriptions = Concurrent::Map.new
+        @channels = Concurrent::Map.new
+
+        # Initialize thread pool for callbacks
+        pool_options = {
+          min_threads: options["min_threads"] || DEFAULT_MIN_THREADS,
+          max_threads: options["max_threads"] || DEFAULT_MAX_THREADS,
+          max_queue: options["max_queue"] || DEFAULT_MAX_QUEUE,
+          fallback_policy: :caller_runs, # Execute in the caller's thread if queue is full
+          idletime: DEFAULT_THREAD_TIMEOUT
+        }
+        @thread_pool = Concurrent::ThreadPoolExecutor.new(pool_options)
+      end
+
+      # Subscribe to a channel
+      # @param channel [String] The channel name
+      # @param message_callback [Proc] Callback for received messages
+      # @param success_callback [Proc] Callback for successful subscription
+      # @return [String] Subscription ID
+      def subscribe(channel, message_callback, success_callback = nil)
+        subscription_id = SecureRandom.uuid
+
+        @subscriptions[subscription_id] = {
+          channel: channel,
+          message_callback: message_callback
+        }
+
+        @channels[channel] ||= Concurrent::Array.new
+        @channels[channel] << subscription_id
+
+        log_subscription_event(channel, "Subscribed", subscription_id)
+        success_callback&.call
+
+        subscription_id
+      end
+
+      # Check if we're already subscribed to a channel
+      # @param channel [String] The channel name
+      # @return [Boolean] True if we're already subscribed
+      def subscribed_to?(channel)
+        channel_subs = @channels[channel]
+        return false if channel_subs.nil?
+        !channel_subs.empty?
+      end
+
+      # Unsubscribe from a channel
+      # @param channel [String] The channel name
+      # @param callback [Proc] Optional callback for unsubscribe completion
+      def unsubscribe(channel, callback = nil)
+        # Remove our subscriptions
+        subscription_ids = @channels[channel] || []
+        subscription_ids.each do |subscription_id|
+          @subscriptions.delete(subscription_id)
+        end
+
+        @channels.delete(channel)
+
+        log_subscription_event(channel, "Unsubscribed")
+        callback&.call
+      end
+
+      # Broadcast a message to a channel
+      # @param channel [String] The channel name
+      # @param message [String] The message to broadcast
+      def broadcast(channel, message)
+        subscription_ids = @channels[channel] || []
+        return if subscription_ids.empty?
+
+        log_broadcast_event(channel, message)
+
+        subscription_ids.each do |subscription_id|
+          subscription = @subscriptions[subscription_id]
+          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
+          end
+        end
+      end
+
+      # Check if a channel has subscribers
+      # @param channel [String] The channel name
+      # @return [Boolean] True if channel has subscribers
+      def has_subscribers?(channel)
+        subscribers = @channels[channel]
+        return false unless subscribers
+        !subscribers.empty?
+      end
+
+      # Shut down the thread pool gracefully
+      def shutdown
+        @thread_pool.shutdown
+        @thread_pool.wait_for_termination(5) # Wait up to 5 seconds for tasks to complete
+      end
+
+      private
+
+      def log_subscription_event(channel, action, subscription_id = nil)
+        return unless defined?(Rails) && Rails.respond_to?(:logger)
+
+        message = "SimplePubSub: #{action} channel=#{channel}"
+        message += " subscription_id=#{subscription_id}" if subscription_id
+
+        Rails.logger.debug(message)
+      end
+
+      def log_broadcast_event(channel, message)
+        return unless defined?(Rails) && Rails.respond_to?(:logger)
+
+        # Truncate the message for logging
+        truncated_message = message.to_s[0..100]
+        truncated_message += "..." if message.to_s.length > 100
+
+        Rails.logger.debug("SimplePubSub: Broadcasting to channel=#{channel} message=#{truncated_message}")
+      end
+
+      def log_error(message)
+        return unless defined?(Rails) && Rails.respond_to?(:logger)
+        Rails.logger.error("SimplePubSub: #{message}")
+      end
+    end
+  end
+end