actionmcp 0.22.0 → 0.25.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5c997c4c99f4ecf6409fb3749bb58efab0eb03622e70d9a447781125620e6c82
-  data.tar.gz: dd9fc6be1b7364f306a6cbcfe0cd9e8db3b00530e46056c6ad49e6995ab7810b
+  metadata.gz: 843ee149da81be07d55d13eb26fad244a21232a0d4f795c98429d556c67c2736
+  data.tar.gz: fbf8aa774b9afe3e72cc325a93d054f98950163e14bd618d851c10d70bf823dc
 SHA512:
-  metadata.gz: c6de9245cf20071a23b0f35181d1eb20db9a2fb96298c6afc165a05aa31f14c3f8035b2b3dbd9ac9b04319f0981ce26609f8afde1ab67ef99a055a070ce3018c
-  data.tar.gz: e8b0006312a943b8228408ab0fe5b859d4a638bfbbe89ddcb6be0d38465476fdb9977f6d2b322676eb1ddc1608abcc7531c9352495c7bde11bb04868586edae1
+  metadata.gz: b32d0b8d10b4a7ed6d8c86a76db959d5a453a5d0004dc6ccf2cee643d57c347777a4581dc0a1cf34f9d41dd202c01b0a28ce24169d9b43fabce96b980d857b8e
+  data.tar.gz: a42653c1903e8e5c8078fd4fc3b3e206c1c92a58cde623b166b6bbd840be45cf1d6339f08d55cbe1018a2c448522901c30d7d6d72ba1d6ff97b22f0c1e4a76e1

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
@@ -48,7 +47,7 @@ module ActionMCP
 
       after_create_commit :broadcast_message, if: :outgoing_message?
       # Set is_ping on responses if the original request was a ping
-      after_create :handle_ping_response, if: -> { %w[response error].include?(message_type) }
+      after_create :acknowledge_request, if: -> { %w[response error].include?(message_type) }
 
       # Scope to exclude both "ping" requests and their responses
       scope :without_pings, -> { where(is_ping: false) }
@@ -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)
@@ -136,17 +136,22 @@ module ActionMCP
         end
       end
 
-      def handle_ping_response
+      def acknowledge_request
         return unless jsonrpc_id.present?
 
         request_message = session.messages.find_by(
           jsonrpc_id: jsonrpc_id,
           message_type: "request"
         )
-        return unless request_message&.is_ping
 
-        self.is_ping = true
+        return unless request_message
+
+        # Set is_ping based on the request
+        self.is_ping = request_message.is_ping
+
+        # Mark the request as acknowledged for all responses
         request_message.update(request_acknowledged: true)
+
         save! if changed?
       end
     end

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