actionmcp 0.50.1 → 0.50.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6673ed8cefa0458b617bcb9ceb865c4aef47a5448752cbe230dc950afea1941f
-  data.tar.gz: 68b8c888e2983cea309cd9498d1bde1887025d37058deabeb1b844c0ae3213d8
+  metadata.gz: 2331cbdf1a1729ce24b729693e34394f3e2725b81106942b5110770d7820225b
+  data.tar.gz: 672d31525a9f4632d8c2334e93a19bb8eb69a7e03e3ea9312d89d2e55a1d8bf7
 SHA512:
-  metadata.gz: 1493f47a18bcc5892c84efcfd51840b50cb6d69c9834c0d114cdaa8fe4a7f040d2ac9d84aec06a9599f25135e797bf85e056c7f602571fe6c47f07928e3c6aa9
-  data.tar.gz: a4d9cf8658e976d05d8330b9349d143cdf49abc281e974d40f9b70d11592ec619d1e55b47f74c5e6e94865d05a7d8c8fae363e1d98d1bed738fa7be2ee5c4ff2
+  metadata.gz: ef0c162837326d3e4514e51123eab9597cfa04aa6a9ca1a790b607d460b9544e5d372171f7bb78d38e5c3d7298090ca2dfd5a3228c4c9b6b5feeb126912cff4a
+  data.tar.gz: e88d3401976a55d7144b3359156bb2d110fa597da8a4df5e22898fc8e3d724f7b6ab42e6b70f53b48e966ba1616057a9e2881f917bae347470160b399e4b97b3

data/app/controllers/action_mcp/unified_controller.rb

@@ -9,7 +9,6 @@ module ActionMCP
 
     include JSONRPC_Rails::ControllerHelpers
     include ActionController::Live
-    # TODO: Include Instrumentation::ControllerRuntime if needed for metrics
 
     # Handles GET requests for establishing server-initiated SSE streams (2025-03-26 spec).
     # @route GET /mcp
@@ -47,7 +46,7 @@ module ActionMCP
 
       # 4. Setup Stream, Listener, and Heartbeat
       sse = SSE.new(response.stream)
-      listener = SSEListener.new(session) # Use the listener class (defined below or moved)
+      listener = SSEListener.new(session)
       connection_active = Concurrent::AtomicBoolean.new
       connection_active.make_true
       heartbeat_active = Concurrent::AtomicBoolean.new
@@ -68,7 +67,7 @@ module ActionMCP
       end
 
       # Handle resumability by sending missed events if Last-Event-ID is provided
-      if last_event_id.present? && last_event_id.to_i > 0
+      if last_event_id.present? && last_event_id.to_i.positive?
         begin
           # Fetch events that occurred after the Last-Event-ID
           missed_events = session.get_sse_events_after(last_event_id.to_i)
@@ -83,12 +82,13 @@ module ActionMCP
           else
             Rails.logger.info "Unified SSE (GET): No missed events to send for session: #{session.id}"
           end
-        rescue => e
+        rescue StandardError => e
           Rails.logger.error "Unified SSE (GET): Error sending missed events: #{e.message}"
         end
       end
 
       # Heartbeat sender proc
+      heartbeat_interval = ActionMCP.configuration.sse_heartbeat_interval || 15.seconds
       heartbeat_sender = lambda do
         if connection_active.true? && !response.stream.closed?
           begin
@@ -96,8 +96,7 @@ module ActionMCP
             future = Concurrent::Promises.future { write_sse_event(sse, session, { type: "ping" }) }
             future.value!(5) # 5 second timeout for write
             if heartbeat_active.true?
-              heartbeat_task = Concurrent::ScheduledTask.execute(ActionMCP.configuration.sse_heartbeat_interval,
-                                                                 &heartbeat_sender)
+              heartbeat_task = Concurrent::ScheduledTask.execute(heartbeat_interval, &heartbeat_sender)
             end
           rescue Concurrent::TimeoutError
             Rails.logger.warn "Unified SSE (GET): Heartbeat timed out for session: #{session.id}, closing."
@@ -112,7 +111,7 @@ module ActionMCP
       end
 
       # Start first heartbeat
-      heartbeat_task = Concurrent::ScheduledTask.execute(HEARTBEAT_INTERVAL, &heartbeat_sender)
+      heartbeat_task = Concurrent::ScheduledTask.execute(heartbeat_interval, &heartbeat_sender)
 
       # Keep connection alive while active
       sleep 0.1 while connection_active.true? && !response.stream.closed?
@@ -147,12 +146,13 @@ module ActionMCP
         return render_not_acceptable("Client must accept 'application/json' and 'text/event-stream'")
       end
 
-      # Determine if this is an initialize request (before session check)
+      # 2. Determine if this is an initialize request (before session check)
       is_initialize_request = check_if_initialize_request(jsonrpc_params)
 
       # 3. Check Session (unless it's an initialize request)
       session_initially_missing = extract_session_id.nil?
       session = mcp_session # This finds or initializes
+
       unless is_initialize_request
         if session_initially_missing
           return render_bad_request("Mcp-Session-Id header is required for this request.")
@@ -162,23 +162,24 @@ module ActionMCP
           return render_not_found("Session has been terminated.")
         end
       end
+
       if session.new_record?
         session.save!
         response.headers[MCP_SESSION_ID_HEADER] = session.id
       end
+
       # 4. Instantiate Handlers
       transport_handler = Server::TransportHandler.new(session)
       json_rpc_handler = Server::JsonRpcHandler.new(transport_handler)
 
       # 5. Call Handler
-      handler_results = json_rpc_handler.call(jsonrpc_params.to_h)
+      handler_results = json_rpc_handler.call(jsonrpc_params)
 
       # 6. Process Results
       process_handler_results(handler_results, session, session_initially_missing, is_initialize_request)
     rescue ActionController::Live::ClientDisconnected, IOError => e
       # Ensure stream is closed if SSE response was attempted and client disconnected
       Rails.logger.debug "Unified SSE (POST): Client disconnected during response: #{e.message}"
-      # Ensure stream is closed, cleanup might happen in ensure block if needed
       begin
         response.stream&.close
       rescue StandardError
@@ -197,7 +198,6 @@ module ActionMCP
       return render_bad_request("Mcp-Session-Id header is required for DELETE requests.") unless session_id_from_header
 
       # 2. Find Session
-      # Note: mcp_session helper finds based on header, but doesn't raise error if not found
       session = Session.find_by(id: session_id_from_header)
 
       if session.nil?
@@ -234,6 +234,7 @@ module ActionMCP
     # Checks if the parsed body represents an 'initialize' request.
     def check_if_initialize_request(payload)
       return false unless payload.is_a?(JSON_RPC::Request) && !jsonrpc_params_batch?
+
       payload.method == "initialize"
     end
 
@@ -243,19 +244,14 @@ module ActionMCP
       results ||= {}
 
       # Check if this is a notification request
-      is_notification = jsonrpc_params.is_a?(Hash) &&
-                        jsonrpc_params["method"].to_s.start_with?("notifications/") &&
-                        !jsonrpc_params.key?("id")
+      is_notification = jsonrpc_params.is_a?(JSON_RPC::Notification)
 
       # Extract request ID from results
       request_id = nil
       if results.is_a?(Hash)
         request_id = results[:request_id] || results[:id]
-
         # If we have a payload that's a response, extract ID from there as well
-        if results[:payload].is_a?(Hash) && results[:payload][:id]
-          request_id ||= results[:payload][:id]
-        end
+        request_id ||= results[:payload][:id] if results[:payload].is_a?(Hash) && results[:payload][:id]
       end
 
       # Default to empty hash for response payload if nil
@@ -263,29 +259,21 @@ module ActionMCP
       result_payload = results[:payload] || {}
 
       # Ensure payload has the correct ID if it's a hash
-      if result_payload.is_a?(Hash) && request_id
-        result_payload[:id] = request_id unless result_payload.key?(:id)
-      end
-
-      # Check if the payload is a notification
-      is_notification_payload = result_payload.is_a?(Hash) &&
-                              result_payload[:method]&.to_s&.start_with?("notifications/") &&
-                              !result_payload.key?(:id)
+      result_payload[:id] = request_id if result_payload.is_a?(Hash) && request_id && !result_payload.key?(:id)
 
       case result_type
       when :error
         # Ensure error responses preserve the ID
         error_payload = result_payload
-        if error_payload.is_a?(Hash) && !error_payload.key?(:id) && request_id
-          error_payload[:id] = request_id
-        end
+        error_payload[:id] = request_id if error_payload.is_a?(Hash) && !error_payload.key?(:id) && request_id
         render json: error_payload, status: results.fetch(:status, :bad_request)
+
       when :notifications_only
         head :accepted
+
       when :responses
         server_preference = ActionMCP.configuration.post_response_preference
         use_sse = (server_preference == :sse)
-
         add_session_header = is_initialize_request && session_initially_missing && session.persisted?
 
         if use_sse
@@ -293,18 +281,22 @@ module ActionMCP
         else
           render_json_response(result_payload, session, add_session_header)
         end
+
       else
-        # This was causing the "Unknown handler result type: " error
+        # Handle unknown result types
         Rails.logger.error "Unknown handler result type: #{result_type.inspect}"
 
-        # Return a proper JSON-RPC response with the preserved ID
-        # Default to a response with JSON-RPC message format
-        status = is_notification ? :accepted : :ok
-        render json: {
-          jsonrpc: "2.0",
-          id: request_id,
-          result: {}
-        }, status: status
+        # If the original request was a notification, don't send back a response with an ID
+        if is_notification
+          head :accepted
+        else
+          # For regular requests, return a proper JSON-RPC response
+          render json: {
+            jsonrpc: "2.0",
+            id: request_id,
+            result: result_payload
+          }, status: :ok
+        end
       end
     end
 
@@ -312,13 +304,11 @@ module ActionMCP
     def render_json_response(payload, session, add_session_header)
       response.headers[MCP_SESSION_ID_HEADER] = session.id if add_session_header
       response.headers["Content-Type"] = "application/json"
-
       render json: payload, status: :ok
     end
 
     # Renders the JSON-RPC response(s) as an SSE stream.
     def render_sse_response(payload, session, add_session_header)
-      # This is not recommended with puma
       response.headers[MCP_SESSION_ID_HEADER] = session.id if add_session_header
       response.headers["Content-Type"] = "text/event-stream"
       response.headers["X-Accel-Buffering"] = "no"
@@ -326,12 +316,6 @@ module ActionMCP
       response.headers["Connection"] = "keep-alive"
 
       sse = SSE.new(response.stream)
-      # TODO: Add logic for sending related server requests/notifications before/after response?
-
-      if payload.is_a?(Array)
-        # Send batched responses as separate events or one event? Spec allows batching.
-        # Let's send as one event for now, using one ID for the batch.
-      end
       write_sse_event(sse, session, payload)
     ensure
       # Close the stream after sending the response(s)
@@ -359,8 +343,8 @@ module ActionMCP
         retention_period = session.sse_event_retention_period
         count = session.cleanup_old_sse_events(retention_period)
 
-        Rails.logger.debug "Cleaned up #{count} old SSE events for session: #{session.id}" if count > 0
-      rescue => e
+        Rails.logger.debug "Cleaned up #{count} old SSE events for session: #{session.id}" if count.positive?
+      rescue StandardError => e
         Rails.logger.error "Error cleaning up old SSE events: #{e.message}"
       end
     end
@@ -378,12 +362,12 @@ module ActionMCP
       sse.stream.write(sse_event)
 
       # Store the event for potential resumption if resumability is enabled
-      if ActionMCP.configuration.enable_sse_resumability
-        begin
-          session.store_sse_event(event_id, payload, session.max_stored_sse_events)
-        rescue => e
-          Rails.logger.error "Failed to store SSE event for resumability: #{e.message}"
-        end
+      return unless ActionMCP.configuration.enable_sse_resumability
+
+      begin
+        session.store_sse_event(event_id, payload, session.max_stored_sse_events)
+      rescue StandardError => e
+        Rails.logger.error "Failed to store SSE event for resumability: #{e.message}"
       end
     end
 
@@ -392,8 +376,5 @@ module ActionMCP
       protocol_version = session.protocol_version || ActionMCP.configuration.protocol_version
       tools.map { |tool| tool.klass.to_h(protocol_version: protocol_version) }
     end
-
-    # TODO: Add methods for handle_get (SSE setup, listener, heartbeat) - Partially Done
-    # TODO: Add method for handle_delete (session termination) - DONE (Basic)
   end
 end

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

@@ -57,6 +57,9 @@ module ActionMCP
       scope :notifications, -> { where(message_type: "notification") }
       scope :responses, -> { where(message_type: "response") }
 
+      validates :message_json, presence: true
+      validates :message_type, presence: true
+
       # @param payload [String, Hash]
       def data=(payload)
         # Convert string payloads to JSON
@@ -114,22 +117,28 @@ module ActionMCP
       end
 
       def process_json_content(content)
-        if content.is_a?(Hash) && content["jsonrpc"] == "2.0"
-          if content.key?("id") && content.key?("method")
-            self.message_type = "request"
-            self.jsonrpc_id = content["id"].to_s
-            # Set is_ping to true if the method is "ping"
-            self.is_ping = true if content["method"] == "ping"
-          elsif content.key?("method") && !content.key?("id")
-            self.message_type = "notification"
-          elsif content.key?("id") && content.key?("result")
-            self.message_type = "response"
-            self.jsonrpc_id = content["id"].to_s
-          elsif content.key?("id") && content.key?("error")
-            self.message_type = "error"
-            self.jsonrpc_id = content["id"].to_s
-          else
-            self.message_type = "invalid_jsonrpc"
+        if content.is_a?(JSON_RPC::Notification) || content.is_a?(JSON_RPC::Request) || content.is_a?(JSON_RPC::Response)
+          content = content.to_h.with_indifferent_access
+        end
+        if content.is_a?(Hash)
+          content = content.with_indifferent_access
+          if content["jsonrpc"] == "2.0"
+            if content.key?("id") && content.key?("method")
+              self.message_type = "request"
+              self.jsonrpc_id = content["id"].to_s
+              # Set is_ping to true if the method is "ping"
+              self.is_ping = true if content["method"] == "ping"
+            elsif content.key?("method") && !content.key?("id")
+              self.message_type = "notification"
+            elsif content.key?("id") && content.key?("result")
+              self.message_type = "response"
+              self.jsonrpc_id = content["id"].to_s
+            elsif content.key?("id") && content.key?("error")
+              self.message_type = "error"
+              self.jsonrpc_id = content["id"].to_s
+            else
+              self.message_type = "invalid_jsonrpc"
+            end
           end
         else
           self.message_type = "non_jsonrpc_json"

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

@@ -42,6 +42,7 @@ module ActionMCP
       # Serializes the data as JSON if it's not already a string
       def data_for_stream
         return data if data.is_a?(String)
+
         data.is_a?(Hash) ? data.to_json : data.to_s
       end
 

data/app/models/action_mcp/session.rb

@@ -167,9 +167,7 @@ module ActionMCP
       )
 
       # Maintain cache limit by removing oldest events if needed
-      if sse_events.count > max_events
-        sse_events.order(event_id: :asc).limit(sse_events.count - max_events).destroy_all
-      end
+      sse_events.order(event_id: :asc).limit(sse_events.count - max_events).destroy_all if sse_events.count > max_events
 
       event
     end
@@ -240,10 +238,10 @@ module ActionMCP
       tool_name = normalize_name(tool_class_or_name, :tool)
       self.tool_registry ||= []
 
-      if self.tool_registry.delete(tool_name)
-        save!
-        send_tools_list_changed_notification
-      end
+      return unless self.tool_registry.delete(tool_name)
+
+      save!
+      send_tools_list_changed_notification
     end
 
     def register_prompt(prompt_class_or_name)
@@ -263,10 +261,10 @@ module ActionMCP
       prompt_name = normalize_name(prompt_class_or_name, :prompt)
       self.prompt_registry ||= []
 
-      if self.prompt_registry.delete(prompt_name)
-        save!
-        send_prompts_list_changed_notification
-      end
+      return unless self.prompt_registry.delete(prompt_name)
+
+      save!
+      send_prompts_list_changed_notification
     end
 
     def register_resource_template(template_class_or_name)
@@ -286,28 +284,34 @@ module ActionMCP
       template_name = normalize_name(template_class_or_name, :resource_template)
       self.resource_registry ||= []
 
-      if self.resource_registry.delete(template_name)
-        save!
-        send_resources_list_changed_notification
-      end
+      return unless self.resource_registry.delete(template_name)
+
+      save!
+      send_resources_list_changed_notification
     end
 
     # Get registered items for this session
     def registered_tools
       (self.tool_registry || []).filter_map do |tool_name|
-        ActionMCP::ToolsRegistry.find(tool_name) rescue nil
+        ActionMCP::ToolsRegistry.find(tool_name)
+      rescue StandardError
+        nil
       end
     end
 
     def registered_prompts
       (self.prompt_registry || []).filter_map do |prompt_name|
-        ActionMCP::PromptsRegistry.find(prompt_name) rescue nil
+        ActionMCP::PromptsRegistry.find(prompt_name)
+      rescue StandardError
+        nil
       end
     end
 
     def registered_resource_templates
       (self.resource_registry || []).filter_map do |template_name|
-        ActionMCP::ResourceTemplatesRegistry.find(template_name) rescue nil
+        ActionMCP::ResourceTemplatesRegistry.find(template_name)
+      rescue StandardError
+        nil
       end
     end
 
@@ -379,21 +383,21 @@ module ActionMCP
 
     def send_tools_list_changed_notification
       # Only send if server capabilities allow it
-      if server_capabilities.dig("tools", "listChanged")
-        write(JSON_RPC::Notification.new(method: "notifications/tools/list_changed"))
-      end
+      return unless server_capabilities.dig("tools", "listChanged")
+
+      write(JSON_RPC::Notification.new(method: "notifications/tools/list_changed"))
     end
 
     def send_prompts_list_changed_notification
-      if server_capabilities.dig("prompts", "listChanged")
-        write(JSON_RPC::Notification.new(method: "notifications/prompts/list_changed"))
-      end
+      return unless server_capabilities.dig("prompts", "listChanged")
+
+      write(JSON_RPC::Notification.new(method: "notifications/prompts/list_changed"))
     end
 
     def send_resources_list_changed_notification
-      if server_capabilities.dig("resources", "listChanged")
-        write(JSON_RPC::Notification.new(method: "notifications/resources/list_changed"))
-      end
+      return unless server_capabilities.dig("resources", "listChanged")
+
+      write(JSON_RPC::Notification.new(method: "notifications/resources/list_changed"))
     end
   end
 end

data/app/models/concerns/mcp_console_helpers.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # app/models/concerns/mcp_console_helpers.rb
 module MCPConsoleHelpers
   extend ActiveSupport::Concern
@@ -12,9 +14,7 @@ module MCPConsoleHelpers
 
       messages.each do |msg|
         puts msg.inspect
-        if msg.data&.dig("method")
-          puts "  └─ #{msg.data['method']}"
-        end
+        puts "  └─ #{msg.data['method']}" if msg.data&.dig("method")
         puts
       end
     end

data/app/models/concerns/mcp_message_inspect.rb

@@ -1,10 +1,12 @@
+# frozen_string_literal: true
+
 # app/models/concerns/mcp_message_inspect.rb
 module MCPMessageInspect
   extend ActiveSupport::Concern
 
   def inspect(show_data: false)
     if show_data
-      super()  # Rails default inspect
+      super() # Rails default inspect
     else
       build_summary_inspect
     end
@@ -54,9 +56,7 @@ module MCPMessageInspect
 
   def console?
     # Check if we're in a Rails console environment
-    defined?(Rails::Console) ||
-      defined?(::Rails.application) && Rails.application.console? ||
-      (defined?(IRB) && IRB.CurrentContext.kind_of?(IRB::ExtendCommandBundle))
+    defined?(Rails::Console)
   end
 
   def colorize(text, color)

data/db/migrate/20250512154359_consolidated_migration.rb

@@ -29,10 +29,10 @@ class ConsolidatedMigration < ActiveRecord::Migration[8.0]
     unless table_exists?(:action_mcp_session_messages)
       create_table :action_mcp_session_messages do |t|
         t.references :session, null: false,
-                    foreign_key: { to_table: :action_mcp_sessions,
-                                  on_delete: :cascade,
-                                  on_update: :cascade,
-                                  name: 'fk_action_mcp_session_messages_session_id' }, type: :string
+                               foreign_key: { to_table: :action_mcp_sessions,
+                                              on_delete: :cascade,
+                                              on_update: :cascade,
+                                              name: 'fk_action_mcp_session_messages_session_id' }, type: :string
         t.string :direction, null: false, comment: 'The message recipient', default: 'client'
         t.string :message_type, null: false, comment: 'The type of the message'
         t.string :jsonrpc_id
@@ -48,9 +48,9 @@ class ConsolidatedMigration < ActiveRecord::Migration[8.0]
     unless table_exists?(:action_mcp_session_subscriptions)
       create_table :action_mcp_session_subscriptions do |t|
         t.references :session,
-                    null: false,
-                    foreign_key: { to_table: :action_mcp_sessions, on_delete: :cascade },
-                    type: :string
+                     null: false,
+                     foreign_key: { to_table: :action_mcp_sessions, on_delete: :cascade },
+                     type: :string
         t.string :uri, null: false
         t.datetime :last_notification_at
         t.timestamps
@@ -61,9 +61,9 @@ class ConsolidatedMigration < ActiveRecord::Migration[8.0]
     unless table_exists?(:action_mcp_session_resources)
       create_table :action_mcp_session_resources do |t|
         t.references :session,
-                    null: false,
-                    foreign_key: { to_table: :action_mcp_sessions, on_delete: :cascade },
-                    type: :string
+                     null: false,
+                     foreign_key: { to_table: :action_mcp_sessions, on_delete: :cascade },
+                     type: :string
         t.string :uri, null: false
         t.string :name
         t.text :description
@@ -84,7 +84,7 @@ class ConsolidatedMigration < ActiveRecord::Migration[8.0]
         t.timestamps
 
         # Index for efficiently retrieving events after a given ID for a specific session
-        t.index [ :session_id, :event_id ], unique: true
+        t.index %i[session_id event_id], unique: true
         t.index :created_at # For cleanup of old events
       end
     end
@@ -111,27 +111,28 @@ class ConsolidatedMigration < ActiveRecord::Migration[8.0]
     end
 
     # For action_mcp_session_messages
-    if table_exists?(:action_mcp_session_messages)
-      unless column_exists?(:action_mcp_session_messages, :is_ping)
-        add_column :action_mcp_session_messages, :is_ping, :boolean, default: false, null: false, comment: 'Whether the message is a ping'
-      end
+    return unless table_exists?(:action_mcp_session_messages)
 
-      unless column_exists?(:action_mcp_session_messages, :request_acknowledged)
-        add_column :action_mcp_session_messages, :request_acknowledged, :boolean, default: false, null: false
-      end
+    unless column_exists?(:action_mcp_session_messages, :is_ping)
+      add_column :action_mcp_session_messages, :is_ping, :boolean, default: false, null: false,
+                                                                   comment: 'Whether the message is a ping'
+    end
 
-      unless column_exists?(:action_mcp_session_messages, :request_cancelled)
-        add_column :action_mcp_session_messages, :request_cancelled, :boolean, null: false, default: false
-      end
+    unless column_exists?(:action_mcp_session_messages, :request_acknowledged)
+      add_column :action_mcp_session_messages, :request_acknowledged, :boolean, default: false, null: false
+    end
 
-      if column_exists?(:action_mcp_session_messages, :message_text)
-        remove_column :action_mcp_session_messages, :message_text
-      end
+    unless column_exists?(:action_mcp_session_messages, :request_cancelled)
+      add_column :action_mcp_session_messages, :request_cancelled, :boolean, null: false, default: false
+    end
 
-      if column_exists?(:action_mcp_session_messages, :direction)
-        change_column_comment :action_mcp_session_messages, :direction, 'The message recipient'
-      end
+    if column_exists?(:action_mcp_session_messages, :message_text)
+      remove_column :action_mcp_session_messages, :message_text
     end
+
+    return unless column_exists?(:action_mcp_session_messages, :direction)
+
+    change_column_comment :action_mcp_session_messages, :direction, 'The message recipient'
   end
 
   private

data/exe/actionmcp_cli

@@ -56,7 +56,7 @@ if endpoint.nil?
 end
 
 unless endpoint =~ %r{\Ahttps?://}
-  puts "Error: Only HTTP(S) endpoints are supported. STDIO/command endpoints are not allowed."
+  puts 'Error: Only HTTP(S) endpoints are supported. STDIO/command endpoints are not allowed.'
   exit 1
 end
 

data/lib/action_mcp/client.rb

@@ -13,12 +13,12 @@ module ActionMCP
   #   client = ActionMCP.create_client("http://127.0.0.1:3001/action_mcp")
   #   client.connect
   def self.create_client(endpoint, logger: Logger.new($stdout), **options)
-    if endpoint =~ %r{\Ahttps?://}
-      logger.info("Creating SSE client for endpoint: #{endpoint}")
-      Client::SSEClient.new(endpoint, logger: logger, **options)
-    else
+    unless endpoint =~ %r{\Ahttps?://}
       raise ArgumentError, "Only HTTP(S) endpoints are supported. STDIO and other transports are not supported."
     end
+
+    logger.info("Creating SSE client for endpoint: #{endpoint}")
+    Client::SSEClient.new(endpoint, logger: logger, **options)
   end
 
   module Client

data/lib/action_mcp/engine.rb

@@ -47,5 +47,32 @@ module ActionMCP
     initializer "action_mcp.logger" do
       ActionMCP.logger = ::Rails.logger
     end
+
+    # Add metrics instrumentation
+    initializer "action_mcp.metrics" do
+      ActiveSupport::Notifications.subscribe "process_action.action_controller" do |name, start, finish, id, payload|
+        if payload[:controller].to_s.start_with?("ActionMCP::")
+          # Process action through our log subscriber
+          ActionMCP::LogSubscriber.new.process_action(
+            ActiveSupport::Notifications::Event.new(name, start, finish, id, payload)
+          )
+        end
+      end
+
+      # Set up default event metrics
+      # SQL queries
+      ActionMCP::LogSubscriber.subscribe_event "sql.active_record", :db_queries, accumulate: true
+
+      # Query runtime
+      ActionMCP::LogSubscriber.subscribe_event "sql.active_record", :sql_runtime,
+                                               duration: true, accumulate: true
+
+      # View rendering
+      ActionMCP::LogSubscriber.subscribe_event "render_template.action_view", :view_runtime,
+                                               duration: true, accumulate: true
+
+      # Cache operations
+      ActionMCP::LogSubscriber.subscribe_event "cache_*.*", :cache_operations, accumulate: true
+    end
   end
 end