actionmcp 0.22.0 → 0.25.0

data/lib/action_mcp/client/resources.rb

@@ -4,40 +4,48 @@ module ActionMCP
   module Client
     module Resources
       # List all available resources from the server
-      # @return [Array<Hash>] List of available resources with their metadata
+      # @return [String] Request ID for tracking the request
       def list_resources
         request_id = SecureRandom.uuid_v7
 
         # Send request
         send_jsonrpc_request("resources/list", id: request_id)
+
+        # Return request ID for tracking the request
+        request_id
       end
 
       # List resource templates from the server
-      # @return [Array<Hash>] List of resource templates
+      # @return [String] Request ID for tracking the request
       def list_resource_templates
         request_id = SecureRandom.uuid_v7
 
         # Send request
         send_jsonrpc_request("resources/templates/list", id: request_id)
+
+        # Return request ID for tracking the request
+        request_id
       end
 
       # Read a specific resource
       # @param uri [String] URI of the resource to read
-      # @return [Hash] Resource content
+      # @return [String] Request ID for tracking the request
       def read_resource(uri)
         request_id = SecureRandom.uuid_v7
 
         # Send request
         send_jsonrpc_request("resources/read",
                              params: { uri: uri },
-                             id: request_id
-        )
+                             id: request_id)
+
+        # Return request ID for tracking the request
+        request_id
       end
 
       # Subscribe to updates for a specific resource
       # @param uri [String] URI of the resource to subscribe to
       # @param update_callback [Proc] Callback for resource updates
-      # @return [Boolean] Success status
+      # @return [String] Request ID for tracking the request
       def subscribe_resource(uri, update_callback)
         @resource_subscriptions ||= {}
         @resource_subscriptions[uri] = update_callback
@@ -47,13 +55,15 @@ module ActionMCP
         # Send request
         send_jsonrpc_request("resources/subscribe",
                              params: { uri: uri },
-                             id: request_id
-        )
+                             id: request_id)
+
+        # Return request ID for tracking the request
+        request_id
       end
 
       # Unsubscribe from updates for a specific resource
       # @param uri [String] URI of the resource to unsubscribe from
-      # @return [Boolean] Success status
+      # @return [String] Request ID for tracking the request
       def unsubscribe_resource(uri)
         @resource_subscriptions&.delete(uri)
 
@@ -62,8 +72,10 @@ module ActionMCP
         # Send request
         send_jsonrpc_request("resources/unsubscribe",
                              params: { uri: uri },
-                             id: request_id
-        )
+                             id: request_id)
+
+        # Return request ID for tracking the request
+        request_id
       end
     end
   end

data/lib/action_mcp/client/server.rb

@@ -1,9 +1,9 @@
+# frozen_string_literal: true
+
 module ActionMCP
   module Client
     class Server
-      attr_reader :name, :version
-
-      attr_reader :server_info, :capabilities
+      attr_reader :name, :version, :server_info, :capabilities
 
       def initialize(data)
         # Store protocol version if needed for later use

data/lib/action_mcp/client/toolbox.rb

@@ -18,30 +18,15 @@ module ActionMCP
     #   # Get all tools matching a criteria
     #   calculation_tools = toolbox.filter { |t| t.name.include?("calculate") }
     #
-    class Toolbox
-      attr_reader :client
-
+    class Toolbox < Collection
       # Initialize a new Toolbox with tool definitions
       #
       # @param tools [Array<Hash>] Array of tool definition hashes, each containing
       #   name, description, and inputSchema keys
       def initialize(tools, client)
-        self.tools = tools
-        @client = client
-        @loaded = !tools.empty?
-      end
-
-      # Return all tools in the collection
-      #
-      # @return [Array<Tool>] All tool objects in the collection
-      def all
-        load_tools unless @loaded
-        @tools
-      end
-
-      def all!
-        load_tools(force: true)
-        @tools
+        super(tools, client)
+        self.tools = @collection_data
+        @load_method = :list_tools
       end
 
       # Find a tool by name
@@ -89,8 +74,9 @@ module ActionMCP
       # @param keyword [String] Keyword to search for in tool names and descriptions
       # @return [Array<Tool>] Tools containing the keyword
       def search(keyword)
-        @tools.select do |tool|
-          tool.name.include?(keyword) || tool.description.downcase.include?(keyword.downcase)
+        all.select do |tool|
+          tool.name.include?(keyword) ||
+            tool.description&.downcase&.include?(keyword.downcase)
         end
       end
 
@@ -102,46 +88,18 @@ module ActionMCP
         case provider
         when :claude
           # Claude format
-          { "tools" => @tools.map(&:to_claude_h) }
+          { "tools" => all.map(&:to_claude_h) }
         when :openai
           # OpenAI format
-          { "tools" => @tools.map(&:to_openai_h) }
+          { "tools" => all.map(&:to_openai_h) }
         else
           # Default format (same as original)
-          { "tools" => @tools.map(&:to_h) }
+          { "tools" => all.map(&:to_h) }
         end
       end
 
-      # Implements enumerable functionality for the collection
-      include Enumerable
-
-      # Yield each tool in the collection to the given block
-      #
-      # @yield [tool] Block to execute for each tool
-      # @yieldparam tool [Tool] A tool from the collection
-      # @return [Enumerator] If no block is given
-      def each(&block)
-        @tools.each(&block)
-      end
-
       def tools=(tools)
-        @tools = tools.map { |tool_data| Tool.new(tool_data) }
-      end
-
-      private
-
-      def load_tools(force: false)
-        return if @loaded && !force
-
-        begin
-          @client.list_tools
-          @loaded = true
-        rescue StandardError => e
-          # Handle error appropriately
-          Rails.logger.error("Failed to load tools: #{e.message}")
-          # Still mark as loaded but with empty list?
-          @loaded = true unless @tools.empty?
-        end
+        @collection_data = tools.map { |tool_data| Tool.new(tool_data) }
       end
 
       # Internal Tool class to represent individual tools
@@ -168,7 +126,7 @@ module ActionMCP
         #
         # @return [Hash] Hash of property definitions
         def properties
-          @input_schema.dig("properties") || {}
+          @input_schema["properties"] || {}
         end
 
         # Check if the tool requires a specific property

data/lib/action_mcp/client/tools.rb

@@ -4,18 +4,21 @@ module ActionMCP
   module Client
     module Tools
       # List all available tools from the server
-      # @return [Array<Hash>] List of available tools with their metadata
+      # @return [String] Request ID for tracking the request
       def list_tools
         request_id = SecureRandom.uuid_v7
 
         # Send request
         send_jsonrpc_request("tools/list", id: request_id)
+
+        # Return request ID for timeout tracking
+        request_id
       end
 
       # Call a specific tool on the server
       # @param name [String] Name of the tool to call
       # @param arguments [Hash] Arguments to pass to the tool
-      # @return [Hash] The result of the tool execution
+      # @return [String] Request ID for tracking the request
       def call_tool(name, arguments)
         request_id = SecureRandom.uuid_v7
 
@@ -25,8 +28,10 @@ module ActionMCP
                                name: name,
                                arguments: arguments
                              },
-                             id: request_id
-        )
+                             id: request_id)
+
+        # Return request ID for tracking the request
+        request_id
       end
     end
   end

data/lib/action_mcp/configuration.rb

@@ -14,21 +14,22 @@ module ActionMCP
     # @!attribute resources_subscribe
     #   @return [Boolean] Whether to subscribe to resources.
     # @!attribute logging_level
-    #   @return [Symbol] The logging level.
+    #   @return [Symbol] The logging level.    attr_writer :name, :version
     attr_writer :name, :version
-    attr_accessor :logging_enabled, # This is not working yet
-                  :list_changed, # This is not working yet
-                  :resources_subscribe, # This is not working yet
-                  :logging_level # This is not working yet
-
-    # Initializes a new Configuration instance.
-    #
-    # @return [void]
+    attr_accessor :logging_enabled,
+                  :list_changed,
+                  :resources_subscribe,
+                  :logging_level,
+                  :active_profile,
+                  :profiles
 
     def initialize
       @logging_enabled = true
       @list_changed = false
       @logging_level = :info
+      @resources_subscribe = false
+      @active_profile = :primary
+      @profiles = default_profiles
     end
 
     def name
@@ -39,23 +40,127 @@ module ActionMCP
       @version || (has_rails_version ? Rails.application.version.to_s : "0.0.1")
     end
 
-    # Returns a hash of capabilities.
-    #
-    # @return [Hash] A hash containing the resources capabilities.
+    # Load custom profiles from Rails configuration
+    def load_profiles
+      # First load defaults from the gem
+      @profiles = default_profiles
+
+      # Then try to load from config/mcp.yml in the Rails app
+      config_path = Rails.root.join("config", "mcp.yml")
+      if File.exist?(config_path)
+        begin
+          yaml_content = YAML.safe_load(File.read(config_path), symbolize_names: true)
+          # Merge with defaults so user config overrides gem defaults
+          @profiles.deep_merge!(yaml_content) if yaml_content
+        rescue StandardError => e
+          Rails.logger.error "Failed to load MCP profiles from #{config_path}: #{e.message}"
+        end
+      end
+
+      # Apply the active profile
+      use_profile(@active_profile)
+
+      self
+    end
+
+    # Switch to a specific profile
+    def use_profile(profile_name)
+      profile_name = profile_name.to_sym
+      unless @profiles.key?(profile_name)
+        Rails.logger.warn "Profile '#{profile_name}' not found, using default"
+        profile_name = :default
+      end
+
+      @active_profile = profile_name
+      apply_profile_options
+
+      self
+    end
+
+    # Filter tools based on active profile
+    def filtered_tools
+      return ToolsRegistry.non_abstract if should_include_all?(:tools)
+
+      tool_names = @profiles[@active_profile][:tools] || []
+      # Convert tool names to underscored format
+      tool_names = tool_names.map { |name| name.to_s.underscore }
+      ToolsRegistry.non_abstract.select { |tool| tool_names.include?(tool.name.underscore) }
+    end
+
+    # Filter prompts based on active profile
+    def filtered_prompts
+      return PromptsRegistry.non_abstract if should_include_all?(:prompts)
+
+      prompt_names = @profiles[@active_profile][:prompts] || []
+      PromptsRegistry.non_abstract.select { |prompt| prompt_names.include?(prompt.name) }
+    end
+
+    # Filter resources based on active profile
+    def filtered_resources
+      return ResourceTemplatesRegistry.non_abstract if should_include_all?(:resources)
+
+      resource_names = @profiles[@active_profile][:resources] || []
+      ResourceTemplatesRegistry.non_abstract.select { |resource| resource_names.include?(resource.name) }
+    end
+
+    # Returns capabilities based on active profile
     def capabilities
       capabilities = {}
-      # Only include each capability if the corresponding registry is non-empty.
-      capabilities[:tools] = { listChanged: false } if ToolsRegistry.non_abstract.any?
-      capabilities[:prompts] = { listChanged: false } if PromptsRegistry.non_abstract.any?
+      # Only include each capability if the corresponding filtered registry is non-empty
+      capabilities[:tools] = { listChanged: @list_changed } if filtered_tools.any?
+      capabilities[:prompts] = { listChanged: @list_changed } if filtered_prompts.any?
       capabilities[:logging] = {} if @logging_enabled
-      # For now, we only have one type of resource, ResourceTemplate
-      # For Resources, we need to think about how to pass the list to the session.
-      capabilities[:resources] = {} if ResourceTemplatesRegistry.non_abstract.any?
+      capabilities[:resources] = { subscribe: @resources_subscribe } if filtered_resources.any?
       capabilities
     end
 
     private
 
+    def default_profiles
+      {
+        primary: {
+          tools: [ "all" ],
+          prompts: [ "all" ],
+          resources: [ "all" ],
+          options: {
+            list_changed: false,
+            logging_enabled: true,
+            logging_level: :info,
+            resources_subscribe: false
+          }
+        },
+        minimal: {
+          tools: [],
+          prompts: [],
+          resources: [],
+          options: {
+            list_changed: false,
+            logging_enabled: false,
+            logging_level: :warn,
+            resources_subscribe: false
+          }
+        }
+      }
+    end
+
+    def apply_profile_options
+      profile = @profiles[@active_profile]
+      return unless profile && profile[:options]
+
+      options = profile[:options]
+      @list_changed = options[:list_changed] unless options[:list_changed].nil?
+      @logging_enabled = options[:logging_enabled] unless options[:logging_enabled].nil?
+      @logging_level = options[:logging_level] unless options[:logging_level].nil?
+      @resources_subscribe = options[:resources_subscribe] unless options[:resources_subscribe].nil?
+    end
+
+    def should_include_all?(type)
+      return true unless @profiles[@active_profile]
+
+      items = @profiles[@active_profile][type]
+      items.nil? || items.include?("all")
+    end
+
     def has_rails_version
       gem "rails_app_version"
       require "rails_app_version/railtie"
@@ -66,21 +171,26 @@ module ActionMCP
   end
 
   class << self
-    attr_accessor :server
+    attr_accessor :server, :logger
 
     # Returns the configuration instance.
-    #
-    # @return [Configuration] the configuration instance
     def configuration
       @configuration ||= Configuration.new
     end
 
     # Configures the ActionMCP module.
-    #
-    # @yield [configuration] the configuration instance
-    # @return [void]
     def configure
       yield(configuration)
     end
+
+    # Temporarily use a different profile
+    def with_profile(profile_name)
+      previous_profile = configuration.active_profile
+      configuration.use_profile(profile_name)
+
+      yield if block_given?
+    ensure
+      configuration.use_profile(previous_profile) if block_given?
+    end
   end
 end

data/lib/action_mcp/engine.rb

@@ -12,6 +12,7 @@ module ActionMCP
       inflect.acronym "SSE"
       inflect.acronym "MCP"
     end
+
     # Provide a configuration namespace for ActionMCP
     config.action_mcp = ActionMCP.configuration
 
@@ -19,6 +20,11 @@ module ActionMCP
       ActionMCP::ResourceTemplate.registered_templates.clear
     end
 
+    # Load MCP profiles during initialization
+    initializer "action_mcp.load_profiles" do
+      ActionMCP.configuration.load_profiles
+    end
+
     # Configure autoloading for the mcp/tools directory
     initializer "action_mcp.autoloading", before: :set_autoload_paths do |app|
       mcp_path = app.root.join("app/mcp")

data/lib/action_mcp/json_rpc_handler_base.rb

@@ -75,6 +75,7 @@ module ActionMCP
     # @param request [Hash]
     def process_request(request)
       return unless valid_request?(request)
+
       read(request)
 
       id = request["id"]

data/lib/action_mcp/registry_base.rb

@@ -64,7 +64,9 @@ module ActionMCP
       include Enumerable
 
       # Using a Data type for items.
-      Item = Data.define(:name, :klass)
+      Item = Data.define(:name, :klass) do
+        delegate :description, to: :klass
+      end
 
       # Initializes a new RegistryScope instance.
       #

data/lib/action_mcp/server/capabilities.rb

@@ -12,7 +12,7 @@ module ActionMCP
         session.store_client_info(@client_info)
         session.store_client_capabilities(@client_capabilities)
         session.set_protocol_version(@protocol_version)
-        session.save
+        session.initialize!
         # TODO: , if the server don't support the protocol version, send a response with error
         send_jsonrpc_response(request_id, result: session.server_capabilities_payload)
       end

data/lib/action_mcp/server/json_rpc_handler.rb

@@ -22,7 +22,7 @@ module ActionMCP
         when "completion/complete" # Completion requests
           process_completion_complete(id, params)
         else
-          puts "\e[31mUnknown client method: #{rpc_method}\e[0m"
+          transport.send_jsonrpc_error(id, :method_not_found, "Method not found")
         end
       end
 

data/lib/action_mcp/server/messaging.rb

@@ -4,24 +4,47 @@ module ActionMCP
   module Server
     module Messaging
       def send_jsonrpc_request(method, params: nil, id: SecureRandom.uuid_v7)
-        request = JsonRpc::Request.new(id: id, method: method, params: params)
-        write_message(request)
+        send_message(:request, method: method, params: params, id: id)
       end
 
       def send_jsonrpc_response(request_id, result: nil, error: nil)
-        response = JsonRpc::Response.new(id: request_id, result: result, error: error)
-        write_message(response)
+        send_message(:response, id: request_id, result: result, error: error)
       end
 
       def send_jsonrpc_notification(method, params = nil)
-        notification = JsonRpc::Notification.new(method: method, params: params)
-        write_message(notification)
+        send_message(:notification, method: method, params: params)
       end
 
       def send_jsonrpc_error(request_id, symbol, message, data = nil)
-        error = JsonRpc::JsonRpcError.new(symbol, message:, data:)
-        response = JsonRpc::Response.new(id: request_id, error:)
-        write_message(response)
+        error = JsonRpc::JsonRpcError.new(symbol, message: message, data: data)
+        send_jsonrpc_response(request_id, error: error)
+      end
+
+      private
+
+      # Factory method to create and send appropriate JSON-RPC message
+      def send_message(type, **args)
+        message = case type
+        when :request
+                    JsonRpc::Request.new(
+                      id: args[:id],
+                      method: args[:method],
+                      params: args[:params]
+                    )
+        when :response
+                    JsonRpc::Response.new(
+                      id: args[:id],
+                      result: args[:result],
+                      error: args[:error]
+                    )
+        when :notification
+                    JsonRpc::Notification.new(
+                      method: args[:method],
+                      params: args[:params]
+                    )
+        end
+
+        write_message(message)
       end
     end
   end

data/lib/action_mcp/version.rb

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

data/lib/generators/action_mcp/install/install_generator.rb

@@ -19,6 +19,10 @@ module ActionMcp
         template "application_mcp_res_template.rb",
                  File.join("app/mcp/resource_templates", "application_mcp_res_template.rb")
       end
+
+      def create_mcp_profile_file
+        template "mcp.yml", File.join("config", "mcp.yml")
+      end
     end
   end
 end

data/lib/generators/action_mcp/install/templates/mcp.yml

@@ -0,0 +1,11 @@
+primary:
+  tools:
+    - all
+  prompts:
+    - all
+  resources:
+    - all
+  options:
+    list_changed: false
+    resources_subscribe: false
+