actionmcp 0.30.1 → 0.31.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 29a0342672e73ed0ff4873d281705ffd06febdd23b9b2d755428b4cd4b74b2fb
-  data.tar.gz: b1a8a118514b2c41b886f9924b342643c11e3c481bf595211040f7aed8551fa3
+  metadata.gz: 92a0e52de9e401a8e10b8aa49d40cba39769e58f4206c7810face00774e9a5ab
+  data.tar.gz: a0e4fd9420fc44688ea20bb4d4697fbd009594a6d414bafc13563523ed9c5c8a
 SHA512:
-  metadata.gz: 8cdfe964fe67aeae7455b8decae512414ecb8e49610be7f75efd297162098ddbc2f2e5a5d76b6fc55eff9f488dce96aa3ed0c90531e5a263d9071635cf8e46e7
-  data.tar.gz: b27d59dea26c593800bbcbc7e59007c0e014c6ce751e48d54806033daa57b7081f13175b921f4ddc413e51139dbd807c553fbf325dce045a8e7e743fd6daa7e2
+  metadata.gz: 055db3b1d213b6993694f703bd94a729dc70e2c640580e33828ac8a9193a21302fefadb5de40a89cdde88587114af92966f8675a9e97600fdf53dc01bfd6843b
+  data.tar.gz: 413bc80f29ea5b92b3214a77cae4e42509569b9c5f93b2ce8e10b793797cabad6735fdb4103d96128ca425c1fcf4f04f35cfd5992eaaded1e6262e4f758b0355

data/app/controllers/action_mcp/messages_controller.rb

@@ -21,7 +21,8 @@ module ActionMCP
     end
 
     def handle_post_message(params, response)
-      json_rpc_handler.call(params)
+      filtered_params = filter_jsonrpc_params(params)
+      json_rpc_handler.call(filtered_params)
       response.status = :accepted
     rescue StandardError => _e
       response.status = :bad_request
@@ -30,5 +31,12 @@ module ActionMCP
     def mcp_session
       @mcp_session ||= Session.find_or_create_by(id: params[:session_id])
     end
+
+    def filter_jsonrpc_params(params)
+      # Valid JSON-RPC keys (both request and response)
+      valid_keys = [ "jsonrpc", "method", "params", "id", "result", "error" ]
+
+      params.to_h.slice(*valid_keys)
+    end
   end
 end

data/lib/action_mcp/sse_listener.rb

@@ -5,17 +5,14 @@ require "concurrent/promise"
 
 module ActionMCP
   # Listener class to subscribe to session messages via Action Cable adapter.
-  # Used by controllers handling Server-Sent Events streams.
   class SSEListener
-    attr_reader :session_key, :adapter
-
     delegate :session_key, :adapter, to: :@session
 
     # @param session [ActionMCP::Session]
     def initialize(session)
       @session = session
-      @stopped = Concurrent::AtomicBoolean.new(false)
-      @subscription_active = Concurrent::AtomicBoolean.new(false)
+      @stopped = Concurrent::AtomicBoolean.new
+      @subscription_active = Concurrent::AtomicBoolean.new
     end
 
     # Start listening using ActionCable's adapter
@@ -24,60 +21,83 @@ module ActionMCP
     def start(&callback)
       Rails.logger.debug "SSEListener: Starting for channel: #{session_key}"
 
-      success_callback = lambda {
+      success_callback = -> {
         Rails.logger.info "SSEListener: Successfully subscribed to channel: #{session_key}"
         @subscription_active.make_true
       }
 
-      # Set up message callback
-      message_callback = lambda { |raw_message|
-        return if @stopped.true?
+      message_callback = ->(raw_message) {
+        process_message(raw_message, callback)
+      }
+
+      # Subscribe using the ActionCable adapter
+      adapter.subscribe(session_key, message_callback, success_callback)
+
+      wait_for_subscription
+    end
+
+    # Stops the listener
+    def stop
+      return if @stopped.true?
+
+      @stopped.make_true
+      Rails.logger.debug "SSEListener: Stopping listener for channel: #{session_key}"
+    end
+
+    private
+
+    def process_message(raw_message, callback)
+      return if @stopped.true?
 
-        begin
-          # Try to parse the message if it's JSON
+      begin
+        Rails.logger.debug "SSEListener: Received raw message of type: #{raw_message.class}"
+
+        # Check if the message is a valid JSON string or has a message attribute
+        if raw_message.is_a?(String) && valid_json_format?(raw_message)
           message = MultiJson.load(raw_message)
-          # Send the message to the callback
-          # TODO: Add SSE event ID here if implementing resumability
           callback&.call(message)
-        rescue StandardError => e
-          Rails.logger.error "SSEListener: Error processing message: #{e.message}"
-          # Still try to send the raw message as a fallback? Or ignore?
-          # callback.call(raw_message) if callback
+        elsif raw_message.respond_to?(:message) && raw_message.message.is_a?(String) && valid_json_format?(raw_message.message)
+          message = MultiJson.load(raw_message.message)
+          callback&.call(message)
+        elsif raw_message.respond_to?(:to_json)
+          # Try to serialize the message object to JSON if it responds to to_json
+          message_json = raw_message.to_json
+          if valid_json_format?(message_json)
+            message = MultiJson.load(message_json)
+            callback&.call(message)
+          else
+            Rails.logger.warn "SSEListener: Message cannot be converted to valid JSON"
+          end
+        else
+          # Log that we received an invalid message format
+          display_message = raw_message.to_s[0..100]
+          Rails.logger.warn "SSEListener: Received invalid JSON format: #{display_message}..."
         end
-      }
+      rescue StandardError => e
+        Rails.logger.error "SSEListener: Error processing message: #{e.message}"
+        Rails.logger.error "SSEListener: Backtrace: #{e.backtrace.join("\n")}"
+      end
+    end
 
-      # Subscribe using the ActionCable adapter
-      adapter.subscribe(session_key, message_callback, success_callback)
+    def valid_json_format?(string)
+      return false if string.blank?
+      string = string.strip
+      (string.start_with?("{") && string.end_with?("}")) ||
+        (string.start_with?("[") && string.end_with?("]"))
+    end
 
-      # Use a future with timeout to check subscription status
+    def wait_for_subscription
       subscription_future = Concurrent::Promises.future do
         sleep 0.1 while !@subscription_active.true? && !@stopped.true?
         @subscription_active.true?
       end
 
-      # Wait up to 5 seconds for subscription to be established (increased timeout)
       begin
-        subscription_result = subscription_future.value(5)
-        subscription_result || @subscription_active.true?
+        subscription_future.value(5) || @subscription_active.true?
       rescue Concurrent::TimeoutError
-        Rails.logger.warn "SSEListener: Timed out waiting for subscription activation for #{session_key}"
+        Rails.logger.warn "SSEListener: Timed out waiting for subscription for #{session_key}"
         false
       end
     end
-
-    # Stops the listener and attempts to unsubscribe.
-    def stop
-      return if @stopped.true? # Prevent multiple stops
-
-      @stopped.make_true
-      # Unsubscribe using the adapter
-      # Note: ActionCable adapters might not have a direct 'unsubscribe' matching this pattern.
-      # We rely on closing the connection and potentially session cleanup.
-      # If using Redis adapter, explicit unsubscribe might be possible/needed.
-      # For now, just log.
-      Rails.logger.debug "SSEListener: Stopping listener for channel: #{session_key}"
-      # If session cleanup is needed when listener stops, add it here or ensure it happens elsewhere.
-      # Example: @session.close! if @session.role == 'server' # Be careful with side effects
-    end
   end
 end

data/lib/action_mcp/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: actionmcp
 version: !ruby/object:Gem::Version
-  version: 0.30.1
+  version: 0.31.0
 platform: ruby
 authors:
 - Abdelkader Boudih
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-04-11 00:00:00.000000000 Z
+date: 2025-04-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: actioncable