actionmcp 0.24.0 → 0.26.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6b50744d4dcd16237d18d1b5c787f721e56281c82d1037c776201226a06cc60c
-  data.tar.gz: ed2b466652be17b4443508719da7b474b1bfc941047815f9a45bc4acf39ca2d6
+  metadata.gz: 0aec61be52c83276c16704658590daabd252697eef047b1893ba73cde29ef145
+  data.tar.gz: f9558287a87d12c1eb1a0988a08ebe05b0d0fecc21307c71871ea13564779459
 SHA512:
-  metadata.gz: ba4f687a5368fb04a2f986b61859e19d05658c00e39dc2b600984db39f34fd3e0f56259e6d08c425d140c1f1641d55ee209ec0ae69109bde1e0ec5312b01cf57
-  data.tar.gz: 6daf198545188c392453e6a53b905fafd3aa6c84ab508114c563ef59ff1c8b0e44712d5c8c82dc8643497daef7136bc3c284baec482d9fd8193c3cf1a32d4fe0
+  metadata.gz: b29c52bd822c2b35618b6e42d242fd69e5c9b3347438bcc84961bf8ff4fb98d7d53eb8efa867b9566aff53b9b756b2b70ee55849b6250147d84ab3da6f2549f4
+  data.tar.gz: 5b24244146161a8d22f206dd0631e8ab854915ec0f7385a53b5407135add51a501c083cb4a86004c197eaf111f23b81b807c7fad2d941f6acc0fc6980d49af41

data/README.md

@@ -293,6 +293,117 @@ npx @modelcontextprotocol/inspector
 
 The default path will be http://localhost:3000/action_mcp
 
-## Conclusion
+Here's a section you can add to explain the profile system in ActionMCP:
+
+## Profiles
+
+ActionMCP supports a flexible profile system that allows you to selectively expose tools, prompts, and resources based on different usage scenarios. This is particularly useful for applications that need different MCP capabilities for different contexts (e.g., public API vs. admin interface).
+
+### Understanding Profiles
+
+Profiles are named configurations that define:
+
+- Which tools are available
+- Which prompts are accessible
+- Which resources can be accessed
+- Configuration options like logging level and change notifications
+
+By default, ActionMCP includes two profiles:
+- `primary`: Exposes all tools, prompts, and resources
+- `minimal`: Exposes no tools, prompts, or resources by default
+
+### Configuring Profiles
+
+Profiles are configured via a `config/mcp.yml` file in your Rails application. If this file doesn't exist, ActionMCP will use default settings from the gem.
+
+**Example configuration:**
+
+```yaml
+default:
+  tools:
+    - all  # Include all tools
+  prompts:
+    - all  # Include all prompts
+  resources:
+    - all  # Include all resources
+  options:
+    list_changed: false
+    logging_enabled: true
+    logging_level: info
+    resources_subscribe: false
+
+api_only:
+  tools:
+    - calculator
+    - weather
+  prompts: []  # No prompts for API
+  resources:
+    - user_profile
+  options:
+    list_changed: false
+    logging_level: warn
+
+admin:
+  tools:
+    - all
+  options:
+    logging_level: debug
+    list_changed: true
+    resources_subscribe: true
+```
+
+Each profile can specify:
+- `tools`: Array of tool names to include (use `all` to include all tools)
+- `prompts`: Array of prompt names to include (use `all` to include all prompts)
+- `resources`: Array of resource names to include (use `all` to include all resources)
+- `options`: Additional configuration options:
+  - `list_changed`: Whether to send change notifications
+  - `logging_enabled`: Whether to enable logging
+  - `logging_level`: The logging level to use
+  - `resources_subscribe`: Whether to enable resource subscriptions
+
+### Switching Profiles
+
+You can switch between profiles programmatically in your code:
+
+```ruby
+# Permanently switch to a different profile
+ActionMCP.configuration.use_profile(:only_tools)  # Switch to a profile named "only_tools"
+
+# Temporarily use a profile for a specific operation
+ActionMCP.with_profile(:minimal) do
+  # Code here uses the minimal profile
+  # After the block, reverts to the previous profile
+end
+```
+
+This makes it easy to control which MCP capabilities are available in different contexts of your application.
+
+### Inspecting Profiles
+
+ActionMCP includes rake tasks to help you manage and inspect your profiles:
+
+```bash
+# List all available profiles with their configurations
+bin/rails action_mcp:list_profiles
+
+# Show detailed information about a specific profile
+bin/rails action_mcp:show_profile[admin]
+
+# List all tools, prompts, resources, and profiles
+bin/rails action_mcp:list
+```
+
+The profile inspection tasks will highlight any issues, such as configured tools, prompts, or resources that don't actually exist in your application.
+
+### Use Cases
+
+Profiles are particularly useful for:
+
+1. **Multi-tenant applications**: Use different profiles for different customer tiers with Dorp or other gems
+2. **Access control**: Create profiles for different user roles (admin, staff, public)
+3. **Performance optimization**: Use a minimal profile for high-traffic endpoints
+4. **Testing environments**: Use specific test profiles in your test environment
+5. **Progressive enhancement**: Start with a minimal profile and gradually add capabilities
 
-ActionMCP empowers developers to build MCP-compliant servers efficiently by handling the standardization and boilerplate associated with integrating with LLMs. With its intuitive abstractions for tools, prompts, and resource templates, you can quickly expose your application's capabilities to AI models while maintaining full control over how they interact with your system.
+By leveraging profiles, you can maintain a single ActionMCP codebase while providing tailored MCP capabilities for different contexts.

data/app/controllers/action_mcp/messages_controller.rb

@@ -6,11 +6,7 @@ module ActionMCP
 
     # @route POST / (sse_in)
     def create
-      begin
-        handle_post_message(clean_params, response)
-      rescue StandardError
-        head :internal_server_error
-      end
+      handle_post_message(params, response)
       head response.status
     end
 
@@ -25,22 +21,14 @@ module ActionMCP
     end
 
     def handle_post_message(params, response)
-      mcp_session.initialize! if params[:method] == "initialize"
       json_rpc_handler.call(params)
-
       response.status = :accepted
-    rescue StandardError => e
-      puts "Error: #{e.message}"
-      puts e.backtrace.join("\n")
+    rescue StandardError => _e
       response.status = :bad_request
     end
 
     def mcp_session
       @mcp_session ||= Session.find_or_create_by(id: params[:session_id])
     end
-
-    def clean_params
-      params.slice(:id, :method, :jsonrpc, :params, :result, :error)
-    end
   end
 end

data/app/controllers/action_mcp/sse_controller.rb

@@ -2,70 +2,122 @@
 
 module ActionMCP
   class SSEController < MCPController
-    HEARTBEAT_INTERVAL = 30 # TODO: The frequency of pings SHOULD be configurable
+    HEARTBEAT_INTERVAL = 30 # in seconds
+    INITIAL_CONNECTION_TIMEOUT = 5 # in seconds
     include ActionController::Live
 
     # @route GET /sse (sse_out)
     def events
-      # Set headers first
+      # Set headers for SSE
       response.headers["X-Accel-Buffering"] = "no"
       response.headers["Content-Type"] = "text/event-stream"
       response.headers["Cache-Control"] = "no-cache"
       response.headers["Connection"] = "keep-alive"
 
-      # Now start streaming - send endpoint
+      # Send the endpoint URL to the client
       send_endpoint_event(sse_in_url)
 
+      Rails.logger.info "SSE: Starting connection for session: #{session_id}"
+
+      # Use Concurrent primitives for state management
+      message_received = Concurrent::AtomicBoolean.new(false)
+      connection_active = Concurrent::AtomicBoolean.new(true)
+
       begin
-        # Create SSE instance once outside the callback with retry parameter
+        # Create SSE instance
         sse = SSE.new(response.stream)
 
-        # Start listener and process messages via the transport
+        # Start the connection monitor using a proper scheduled task
+        timeout_task = Concurrent::ScheduledTask.execute(INITIAL_CONNECTION_TIMEOUT) do
+          unless message_received.true?
+            Rails.logger.warn "No message received within #{INITIAL_CONNECTION_TIMEOUT} seconds, closing connection for session: #{session_id}"
+            error = build_timeout_error
+            # Safely write error and close the stream
+            Concurrent::Promise.execute do
+              sse.write(error) rescue nil
+              response.stream.close rescue nil
+              connection_active.make_false
+            end
+          end
+        end
+
+        # Initialize the listener
         listener = SSEListener.new(mcp_session)
-        message_received = false
-        if listener.start do |message|
-          # Send with proper SSE formatting
+        listener_started = listener.start do |message|
+          message_received.make_true
           sse.write(message)
-          message_received = true
         end
-          sleep 1
-          # Heartbeat loop
-          unless message_received
-            Rails.logger.warn "No message received within 1 second, closing connection for session: #{session_id}"
-            error = JsonRpc::Response.new(id: SecureRandom.uuid_v7,
-                                          error: JsonRpc::JsonRpcError.new(
-                                            :server_error, message: "No message received within 1 second"
-                                          ).to_h).to_h
-            sse.write(error)
-            return
-          end
 
-          until response.stream.closed?
-            sleep HEARTBEAT_INTERVAL
-            # mcp_session.send_ping!
-          end
-        else
+        unless listener_started
           Rails.logger.error "Listener failed to activate for session: #{session_id}"
-          raise "Failed to establish subscription"
+          error = build_listener_error
+          sse.write(error)
+          connection_active.make_false
+          return
+        end
+
+        # Schedule heartbeats using a proper timer
+        heartbeat = Concurrent::TimerTask.new(
+          execution_interval: HEARTBEAT_INTERVAL,
+          timeout_interval: 5 # Timeout for heartbeat operation
+        ) do
+          if connection_active.true? && !response.stream.closed?
+            begin
+              sse.write({ ping: true })
+            rescue StandardError => e
+              Rails.logger.debug "SSE: Heartbeat error: #{e.message}"
+              connection_active.make_false
+            end
+          else
+            raise Concurrent::CancelledOperationError
+          end
+        end
+        heartbeat.execute
+
+        # Wait for connection to be closed or cancelled
+        while connection_active.true? && !response.stream.closed?
+          sleep 0.1
         end
       rescue ActionController::Live::ClientDisconnected, IOError => e
-        Rails.logger.debug "SSE: Expected disconnection: #{e.message}"
+        Rails.logger.debug "SSE: Client disconnected: #{e.message}"
       rescue StandardError => e
         Rails.logger.error "SSE: Unexpected error: #{e.class} - #{e.message}\n#{e.backtrace.join("\n")}"
       ensure
-        response.stream.close
-        listener.stop
-        Rails.logger.debug "SSE: Connection closed for session: #{session_id}"
+        # Clean up resources
+        timeout_task&.cancel
+        heartbeat&.shutdown
+        listener&.stop
+        response.stream.close rescue nil
+
+        Rails.logger.debug "SSE: Connection cleaned up for session: #{session_id}"
       end
     end
 
     private
 
+    def build_timeout_error
+      JsonRpc::Response.new(
+        id: SecureRandom.uuid_v7,
+        error: JsonRpc::JsonRpcError.new(
+          :server_error,
+          message: "No message received within initial connection timeout"
+        ).to_h
+      ).to_h
+    end
+
+    def build_listener_error
+      JsonRpc::Response.new(
+        id: SecureRandom.uuid_v7,
+        error: JsonRpc::JsonRpcError.new(
+          :server_error,
+          message: "Failed to establish server connection"
+        ).to_h
+      ).to_h
+    end
+
     def send_endpoint_event(messages_url)
       endpoint = "#{messages_url}?session_id=#{session_id}"
-      SSE.new(response.stream,
-              event: "endpoint")
-         .write(endpoint)
+      SSE.new(response.stream, event: "endpoint").write(endpoint)
     end
 
     def default_url_options
@@ -77,11 +129,11 @@ module ActionMCP
     end
 
     def session_id
-      @session_id ||= mcp_session.id
+      mcp_session.id
     end
 
     def cache_key
-      "action_mcp:session:#{session_id}"
+      mcp_session.session_key
     end
   end
 
@@ -93,7 +145,8 @@ module ActionMCP
     # @param session [ActionMCP::Session]
     def initialize(session)
       @session = session
-      @stopped = false
+      @stopped = Concurrent::AtomicBoolean.new(false)
+      @subscription_active = Concurrent::AtomicBoolean.new(false)
     end
 
     # Start listening using ActionCable's adapter
@@ -101,34 +154,49 @@ module ActionMCP
       Rails.logger.debug "Starting listener for channel: #{session_key}"
 
       success_callback = lambda {
-        puts "Successfully subscribed to channel: #{session_key}"
-        @subscription_active = true
+        Rails.logger.info "Successfully subscribed to channel: #{session_key}"
+        @subscription_active.make_true
       }
 
       # Set up message callback
       message_callback = lambda { |raw_message|
+        return if @stopped.true?
+
         begin
           # Try to parse the message if it's JSON
           message = MultiJson.load(raw_message)
           # Send the message to the callback
-          callback.call(message) if callback && !@stopped
-        rescue StandardError
+          callback.call(message) if callback
+        rescue StandardError => e
+          Rails.logger.error "Error processing message: #{e.message}"
           # Still try to send the raw message as a fallback
-          callback.call(raw_message) if callback && !@stopped
+          callback.call(raw_message) if callback
         end
       }
 
       # Subscribe using the ActionCable adapter
       adapter.subscribe(session_key, message_callback, success_callback)
 
-      # Give some time for the subscription to be established
-      sleep 0.5
+      # Use a future with timeout to check subscription status
+      subscription_future = Concurrent::Promises.future do
+        while !@subscription_active.true? && !@stopped.true?
+          sleep 0.1
+        end
+        @subscription_active.true?
+      end
 
-      @subscription_active
+      # Wait up to 1 second for subscription to be established
+      begin
+        subscription_result = subscription_future.value(1)
+        subscription_result || @subscription_active.true?
+      rescue Concurrent::TimeoutError
+        Rails.logger.warn "Timed out waiting for subscription activation"
+        false
+      end
     end
 
     def stop
-      @stopped = true
+      @stopped.make_true
       if (mcp_session = Session.find_by(id: session_key))
         mcp_session.close
       end

data/app/models/action_mcp/session/message.rb

@@ -8,7 +8,6 @@
 #  direction(The message recipient)       :string           default("client"), not null
 #  is_ping(Whether the message is a ping) :boolean          default(FALSE), not null
 #  message_json                           :jsonb
-#  message_text                           :string
 #  message_type(The type of the message)  :string           not null
 #  request_acknowledged                   :boolean          default(FALSE), not null
 #  request_cancelled                      :boolean          default(FALSE), not null
@@ -61,26 +60,26 @@ module ActionMCP
       def data=(payload)
         @data = payload
 
-        # Store original version and attempt to determine type
+        # Convert string payloads to JSON
         if payload.is_a?(String)
-          self.message_text = payload
           begin
             parsed_json = MultiJson.load(payload)
             self.message_json = parsed_json
-            self.message_text = nil
-            process_json_content(parsed_json)
           rescue MultiJson::ParseError
-            self.message_type = "text"
+            # Handle invalid JSON by creating an error object
+            self.message_json = { "error" => "Invalid JSON", "raw" => payload }
+            self.message_type = "invalid_json"
+            return
           end
         else
+          # Handle direct hash assignment
           self.message_json = payload
-          self.message_text = nil
-          process_json_content(payload)
         end
+        process_json_content(payload)
       end
 
       def data
-        message_json.presence || message_text
+        message_json
       end
 
       # Helper methods
@@ -98,6 +97,7 @@ module ActionMCP
 
       def rpc_method
         return false unless request?
+
         data["method"]
       end
 
@@ -108,9 +108,9 @@ module ActionMCP
       end
 
       def broadcast_message
-        if adapter.present?
-          adapter.broadcast(session_key, data.to_json)
-        end
+        return unless adapter.present?
+
+        adapter.broadcast(session_key, data.to_json)
       end
 
       def process_json_content(content)

data/app/models/action_mcp/session.rb

@@ -107,8 +107,9 @@ module ActionMCP
       # update the session initialized to true
       return false if initialized?
 
-      update!(initialized: true,
-              status: "initialized")
+      self.initialized = true
+      self.status = "initialized"
+      save
     end
 
     def message_flow

data/config/routes.rb

@@ -2,5 +2,5 @@
 
 ActionMCP::Engine.routes.draw do
   get "/", to: "sse#events", as: :sse_out
-  post "/", to: "messages#create", as: :sse_in
+  post "/", to: "messages#create", as: :sse_in, defaults: { format: "json" }
 end

data/db/migrate/20250324203409_remove_session_message_text.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+class RemoveSessionMessageText < ActiveRecord::Migration[8.0]
+  def up
+    remove_column :action_mcp_session_messages, :message_text
+  end
+end

data/lib/action_mcp/client/base.rb

@@ -17,6 +17,7 @@ module ActionMCP
                   :server_capabilities, :session,
                   :catalog, :blueprint,
                   :prompt_book, :toolbox
+
       delegate :initialized?, to: :session
 
       def initialize(logger: ActionMCP.logger)
@@ -146,15 +147,14 @@ module ActionMCP
       end
 
       def server=(server)
-        if server.is_a?(Client::Server)
-          @server = server
+        @server = if server.is_a?(Client::Server)
+                    server
         else
-          @server = Client::Server.new(server)
+                    Client::Server.new(server)
         end
         session.server_capabilities = server.capabilities
         session.server_info = server.server_info
         session.save
-        server
       end
 
       def inspect
@@ -164,15 +164,13 @@ module ActionMCP
       protected
 
       def handle_raw_message(raw)
-        begin
-          @message_callback&.call(raw)
-        rescue MultiJson::ParseError => e
-          log_error("JSON parse error: #{e} (raw: #{raw})")
-          @error_callback&.call(e)
-        rescue StandardError => e
-          log_error("Error handling message: #{e} (raw: #{raw})")
-          @error_callback&.call(e)
-        end
+        @message_callback&.call(raw)
+      rescue MultiJson::ParseError => e
+        log_error("JSON parse error: #{e} (raw: #{raw})")
+        @error_callback&.call(e)
+      rescue StandardError => e
+        log_error("Error handling message: #{e} (raw: #{raw})")
+        @error_callback&.call(e)
       end
 
       def send_initial_capabilities
@@ -180,7 +178,7 @@ module ActionMCP
         # We have contact! Let's send our CV to the recruiter.
         # We persist the session object to the database
         session.save
-        params= {
+        params = {
           protocolVersion: session.protocol_version,
           capabilities: session.client_capabilities,
           clientInfo: session.client_info

data/lib/action_mcp/client/catalog.rb

@@ -90,7 +90,7 @@ module ActionMCP
         keyword = keyword.downcase
         all.select do |resource|
           resource.name.downcase.include?(keyword) ||
-            (resource.description && resource.description.downcase.include?(keyword))
+            resource.description&.downcase&.include?(keyword)
         end
       end
 
@@ -119,7 +119,7 @@ module ActionMCP
         #
         # @return [String, nil] The file extension or nil if no extension
         def extension
-          File.extname(@name)[1..-1] if @name.include?(".")
+          File.extname(@name)[1..] if @name.include?(".")
         end
 
         # Check if this resource is a text file based on MIME type
@@ -140,7 +140,9 @@ module ActionMCP
         #
         # @return [String, nil] The path component of the URI
         def path
-          URI(@uri).path rescue nil
+          URI(@uri).path
+        rescue StandardError
+          nil
         end
 
         # Generate a hash representation of the resource

data/lib/action_mcp/client/collection.rb

@@ -11,7 +11,7 @@ module ActionMCP
       def initialize(items, client, silence_sql: true)
         @collection_data = items || []
         @client = client
-        @loaded = !(@collection_data.empty?)
+        @loaded = !@collection_data.empty?
         @silence_sql = silence_sql
       end
 

data/lib/action_mcp/client/json_rpc_handler.rb

@@ -4,6 +4,7 @@ module ActionMCP
   module Client
     class JsonRpcHandler < JsonRpcHandlerBase
       attr_reader :client
+
       def initialize(transport, client)
         super(transport)
         @client = client
@@ -104,7 +105,6 @@ module ActionMCP
         puts "\e[31mUnknown error: #{id} #{error}\e[0m"
       end
 
-
       def send_initialized_notification
         transport.initialize!
         client.send_jsonrpc_notification("notifications/initialized")

data/lib/action_mcp/client/logging.rb

@@ -12,8 +12,7 @@ module ActionMCP
         # Send request
         send_jsonrpc_request("client/setLoggingLevel",
                              params: { level: level },
-                             id: request_id
-        )
+                             id: request_id)
       end
     end
   end

data/lib/action_mcp/client/prompts.rb

@@ -28,8 +28,7 @@ module ActionMCP
                                name: name,
                                arguments: arguments
                              },
-                             id: request_id
-        )
+                             id: request_id)
 
         # Return request ID for tracking the request
         request_id

data/lib/action_mcp/client/request_timeouts.rb

@@ -22,9 +22,7 @@ module ActionMCP
         # Wait until either:
         # 1. The collection is loaded (@loaded becomes true from JsonRpcHandler)
         # 2. The timeout is reached
-        while !@loaded && (Time.now - start_time) < timeout
-          sleep(0.1)
-        end
+        sleep(0.1) while !@loaded && (Time.now - start_time) < timeout
 
         # If we timed out
         unless @loaded
@@ -33,9 +31,9 @@ module ActionMCP
           if request && !request.request_acknowledged?
             # Send cancel notification
             client.send_jsonrpc_notification("notifications/cancelled", {
-              requestId: request_id,
-              reason: "Request timed out after #{timeout} seconds"
-            })
+                                               requestId: request_id,
+                                               reason: "Request timed out after #{timeout} seconds"
+                                             })
 
             # Mark as cancelled in the database
             request.update(request_cancelled: true)
@@ -58,18 +56,18 @@ module ActionMCP
         # Find the request
         request = client.session.messages.requests.find_by(jsonrpc_id: request_id)
 
-        if request && !request.request_acknowledged?
-          # Send cancel notification
-          client.send_jsonrpc_notification("notifications/cancelled", {
-            requestId: request_id,
-            reason: "Request timed out after #{timeout} seconds"
-          })
+        return unless request && !request.request_acknowledged?
 
-          # Mark as cancelled in the database
-          request.update(request_cancelled: true)
+        # Send cancel notification
+        client.send_jsonrpc_notification("notifications/cancelled", {
+                                           requestId: request_id,
+                                           reason: "Request timed out after #{timeout} seconds"
+                                         })
 
-          log_error("Request #{method_name} timed out after #{timeout} seconds")
-        end
+        # Mark as cancelled in the database
+        request.update(request_cancelled: true)
+
+        log_error("Request #{method_name} timed out after #{timeout} seconds")
       end
     end
   end

data/lib/action_mcp/client/resources.rb

@@ -36,8 +36,7 @@ module ActionMCP
         # 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
@@ -56,8 +55,7 @@ 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
@@ -74,8 +72,7 @@ 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

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

@@ -76,7 +76,7 @@ module ActionMCP
       def search(keyword)
         all.select do |tool|
           tool.name.include?(keyword) ||
-            (tool.description && tool.description.downcase.include?(keyword.downcase))
+            tool.description&.downcase&.include?(keyword.downcase)
         end
       end
 
@@ -126,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

@@ -28,8 +28,7 @@ module ActionMCP
                                name: name,
                                arguments: arguments
                              },
-                             id: request_id
-        )
+                             id: request_id)
 
         # Return request ID for tracking the request
         request_id

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.24.0"
+  VERSION = "0.26.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
+

data/lib/tasks/action_mcp_tasks.rake

@@ -23,12 +23,12 @@ namespace :action_mcp do
     # Ensure Rails eager loads all classes
     Rails.application.eager_load!
 
-    puts "\e[32mACTION MCP PROMPTS\e[0m"  # Red
-    puts "\e[32m-----------------\e[0m"   # Red
+    puts "\e[32mACTION MCP PROMPTS\e[0m"  # Green
+    puts "\e[32m-----------------\e[0m"   # Green
     ActionMCP::Prompt.descendants.each do |prompt|
       next if prompt.abstract?
 
-      puts "\e[32m#{prompt.capability_name}:\e[0m #{prompt.description}" # Red name
+      puts "\e[32m#{prompt.capability_name}:\e[0m #{prompt.description}" # Green name
     end
     puts "\n"
   end
@@ -49,8 +49,79 @@ namespace :action_mcp do
     puts "\n"
   end
 
-  desc "List all tools and prompts with their names and descriptions"
-  task list: %i[list_tools list_prompts list_resources] do
-    # This task lists all tools, prompts, and resources
+  # bin/rails action_mcp:show_profile[profile_name]
+  desc "Show configuration for a specific profile"
+  task :show_profile, [ :profile_name ] => :environment do |t, args|
+    # Ensure Rails eager loads all classes
+    Rails.application.eager_load!
+
+    profile_name = (args[:profile_name] || "primary").to_sym
+    profiles = ActionMCP.configuration.profiles
+
+    unless profiles.key?(profile_name)
+      puts "\e[31mProfile '#{profile_name}' not found!\e[0m"
+      puts "Available profiles: #{profiles.keys.join(', ')}"
+      next
+    end
+
+    # Temporarily activate this profile to show what would be included
+    ActionMCP.with_profile(profile_name) do
+      profile_config = profiles[profile_name]
+
+      puts "\e[35mPROFILE: #{profile_name.to_s.upcase}\e[0m"  # Purple
+      puts "\e[35m#{'-' * (profile_name.to_s.length + 9)}\e[0m"
+
+      # Show options
+      if profile_config[:options]
+        puts "\n\e[36mOptions:\e[0m"  # Cyan
+        profile_config[:options].each do |key, value|
+          puts "  #{key}: #{value}"
+        end
+      end
+
+      # Show Tools
+      puts "\n\e[34mIncluded Tools:\e[0m"  # Blue
+      if ActionMCP.configuration.filtered_tools.any?
+        ActionMCP.configuration.filtered_tools.each do |tool|
+          puts "  \e[34m#{tool.name}:\e[0m #{tool.description}"
+        end
+      else
+        puts "  None"
+      end
+
+      # Show Prompts
+      puts "\n\e[32mIncluded Prompts:\e[0m"  # Green
+      if ActionMCP.configuration.filtered_prompts.any?
+        ActionMCP.configuration.filtered_prompts.each do |prompt|
+          puts "  \e[32m#{prompt.name}:\e[0m #{prompt.description}"
+        end
+      else
+        puts "  None"
+      end
+
+      # Show Resources
+      puts "\n\e[33mIncluded Resources:\e[0m"  # Yellow
+      if ActionMCP.configuration.filtered_resources.any?
+        ActionMCP.configuration.filtered_resources.each do |resource|
+          puts "  \e[33m#{resource.name}:\e[0m #{resource.description}"
+        end
+      else
+        puts "  None"
+      end
+
+      # Show Capabilities
+      puts "\n\e[36mActive Capabilities:\e[0m"  # Cyan
+      capabilities = ActionMCP.configuration.capabilities
+      capabilities.each do |cap_name, cap_config|
+        puts "  #{cap_name}: #{cap_config.inspect}"
+      end
+    end
+
+    puts "\n"
+  end
+
+  desc "List all tools, prompts, resources and available profiles"
+  task list: %i[list_tools list_prompts list_resources list_profiles] do
+    # This task lists all tools, prompts, resources and profiles
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: actionmcp
 version: !ruby/object:Gem::Version
-  version: 0.24.0
+  version: 0.26.0
 platform: ruby
 authors:
 - Abdelkader Boudih
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-03-24 00:00:00.000000000 Z
+date: 2025-03-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: actioncable
@@ -106,6 +106,7 @@ files:
 - db/migrate/20250314230152_add_is_ping_to_session_message.rb
 - db/migrate/20250316005021_create_action_mcp_session_subscriptions.rb
 - db/migrate/20250316005649_create_action_mcp_session_resources.rb
+- db/migrate/20250324203409_remove_session_message_text.rb
 - exe/actionmcp_cli
 - lib/action_mcp.rb
 - lib/action_mcp/base_response.rb
@@ -183,6 +184,7 @@ files:
 - lib/generators/action_mcp/install/templates/application_mcp_prompt.rb
 - lib/generators/action_mcp/install/templates/application_mcp_res_template.rb
 - lib/generators/action_mcp/install/templates/application_mcp_tool.rb
+- lib/generators/action_mcp/install/templates/mcp.yml
 - lib/generators/action_mcp/prompt/prompt_generator.rb
 - lib/generators/action_mcp/prompt/templates/prompt.rb.erb
 - lib/generators/action_mcp/resource_template/resource_template_generator.rb