actionmcp 0.90.0 → 0.100.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f4e55c16fbbaf08a18d98c152d72d152a97170ac81e9f6126b24663f7f53ed14
-  data.tar.gz: 11e2f3cd710ee43e7ef868197bed0221d50da3ea513764a05856afb3334db8fb
+  metadata.gz: 9b01884f2ba4ded4a59d6c235583edbd00dae36da78215da26a1fbf83039838f
+  data.tar.gz: c97745755f33ece7ce05a4a2a904cde23e3fe67c3f1ecf9ee0cc962e6bdc9177
 SHA512:
-  metadata.gz: 4eeca2ab09bb4ee053d575d610fd6f1a236ee1038c008fad9f90b9aa0f78c339e21ceaecdf499d13c885e006e89ea224a74fc326e5d9b3cc091434c17733d50f
-  data.tar.gz: e1c15290f9a862dfb3d37cd8d077b9c3312370dd2e6e12f7bf57c661d5de20a682d1ca7c59e6149bdc94d543a2151cfcc576ede94afab07accdd8fb8ce82bb59
+  metadata.gz: 545540e721a557860d9263873c841fd703afd1ea9bed05ea489b738c5a81594cc6f560fdf3959d6d9ff992b3e4b247eb8efead8f5f234946429903b00ce06a96
+  data.tar.gz: 8c4a3d2abe05b4f65b26e6dfdd751350973e029341c8ed8bb1e3f880a046477afd59ce236a71d6e607dd82ab3220eaac1c3ee462c7c8861c1ec79a814eaa42ca

data/app/controllers/action_mcp/application_controller.rb

@@ -9,7 +9,6 @@ module ActionMCP
 
     include Engine.routes.url_helpers
     include JSONRPC_Rails::ControllerHelpers
-    include ActionController::Live
     include ActionController::Instrumentation
 
     # Provides the ActionMCP::Session for the current request.
@@ -27,136 +26,15 @@ module ActionMCP
       @session_key ||= "action_mcp-sessions-#{mcp_session.id}"
     end
 
-    # Handles GET requests for establishing server-initiated SSE streams (2025-03-26 spec).
+    # Handles GET requests - returns 405 Method Not Allowed as per MCP spec.
+    # SSE streaming is not supported. Clients should use Tasks for async operations.
     # <rails-lens:routes:begin>
     # ROUTE: /, name: mcp_get, via: GET
     # <rails-lens:routes:end>
     def show
-      unless request.accepts.any? { |type| type.to_s == "text/event-stream" }
-        return render_not_acceptable("Client must accept 'text/event-stream' for GET requests.")
-      end
-
-      session_id_from_header = extract_session_id
-      return render_bad_request("Mcp-Session-Id header is required for GET requests.") unless session_id_from_header
-
-      session = mcp_session
-      if session.nil? || session.new_record?
-        return render_not_found("Session not found.")
-      elsif !session.initialized?
-        return render_bad_request("Session is not fully initialized.")
-      elsif session.status == "closed"
-        return render_not_found("Session has been terminated.")
-      end
-
-      # Authenticate the request via gateway
-      authenticate_gateway!
-      return if performed?
-
-      last_event_id = request.headers["Last-Event-ID"].presence
-      if last_event_id && ActionMCP.configuration.verbose_logging
-        Rails.logger.info "Unified SSE (GET): Resuming from Last-Event-ID: #{last_event_id}"
-      end
-
-      response.headers["Content-Type"] = "text/event-stream"
-      response.headers["X-Accel-Buffering"] = "no"
-      response.headers["Cache-Control"] = "no-cache"
-      response.headers["Connection"] = "keep-alive"
-      # Add MCP-Protocol-Version header for established sessions
-      response.headers["MCP-Protocol-Version"] = session.protocol_version
-
-      if ActionMCP.configuration.verbose_logging
-        Rails.logger.info "Unified SSE (GET): Starting stream for session: #{session.id}"
-      end
-
-      sse = SSE.new(response.stream)
-      listener = SSEListener.new(session)
-      connection_active = Concurrent::AtomicBoolean.new
-      connection_active.make_true
-      heartbeat_active = Concurrent::AtomicBoolean.new
-      heartbeat_active.make_true
-      heartbeat_task = nil
-
-      listener_started = listener.start do |message|
-        write_sse_event(sse, session, message)
-      end
-
-      unless listener_started
-        Rails.logger.error "Unified SSE (GET): Listener failed to activate for session: #{session.id}"
-        connection_active.make_false
-        return
-      end
-
-      if last_event_id.present? && last_event_id.to_i.positive?
-        begin
-          missed_events = session.get_sse_events_after(last_event_id.to_i)
-          if missed_events.any?
-            if ActionMCP.configuration.verbose_logging
-              Rails.logger.info "Unified SSE (GET): Sending #{missed_events.size} missed events for session: #{session.id}"
-            end
-            missed_events.each do |event|
-              sse.write(event.to_sse)
-            end
-          elsif ActionMCP.configuration.verbose_logging
-            if ActionMCP.configuration.verbose_logging
-              Rails.logger.info "Unified SSE (GET): No missed events to send for session: #{session.id}"
-            end
-          end
-        rescue StandardError => e
-          Rails.logger.error "Unified SSE (GET): Error sending missed events: #{e.message}"
-        end
-      end
-
-      heartbeat_interval = ActionMCP.configuration.sse_heartbeat_interval || 15.seconds
-      heartbeat_sender = lambda do
-        if connection_active.true? && !response.stream.closed?
-          begin
-            # Send a proper JSON-RPC notification for heartbeat
-            ping_notification = {
-              jsonrpc: "2.0",
-              method: "notifications/ping",
-              params: {}
-            }
-            future = Concurrent::Promises.future { write_sse_event(sse, session, ping_notification) }
-            future.value!(5)
-            if heartbeat_active.true?
-              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."
-            connection_active.make_false
-          rescue StandardError => e
-            if ActionMCP.configuration.verbose_logging
-              Rails.logger.debug "Unified SSE (GET): Heartbeat error for session: #{session.id}: #{e.message}"
-            end
-            connection_active.make_false
-          end
-        else
-          heartbeat_active.make_false
-        end
-      end
-
-      heartbeat_task = Concurrent::ScheduledTask.execute(heartbeat_interval, &heartbeat_sender)
-      sleep 0.1 while connection_active.true? && !response.stream.closed?
-    rescue ActionController::Live::ClientDisconnected, IOError => e
-      if ActionMCP.configuration.verbose_logging
-        Rails.logger.debug "Unified SSE (GET): Client disconnected for session: #{session&.id}: #{e.message}"
-      end
-    rescue StandardError => e
-      Rails.logger.error "Unified SSE (GET): Unexpected error for session: #{session&.id}: #{e.class} - #{e.message}\n#{e.backtrace.join("\n")}"
-    ensure
-      if ActionMCP.configuration.verbose_logging
-        Rails.logger.debug "Unified SSE (GET): Cleaning up connection for session: #{session&.id}"
-      end
-      heartbeat_active&.make_false
-      heartbeat_task&.cancel
-      listener&.stop
-      cleanup_old_sse_events(session) if session
-      sse&.close
-      begin
-        response.stream&.close
-      rescue StandardError
-        nil
-      end
+      # MCP Streamable HTTP spec allows servers to return 405 if they don't support SSE.
+      # ActionMCP uses Tasks for async operations instead of SSE streaming.
+      head :method_not_allowed
     end
 
     # Handles POST requests containing client JSON-RPC messages according to 2025-03-26 spec.
@@ -211,15 +89,6 @@ module ActionMCP
 
       result = json_rpc_handler.call(jsonrpc_params)
       process_handler_results(result, session, session_initially_missing, is_initialize_request)
-    rescue ActionController::Live::ClientDisconnected, IOError => e
-      if ActionMCP.configuration.verbose_logging
-        Rails.logger.debug "Unified SSE (POST): Client disconnected during response: #{e.message}"
-      end
-      begin
-        response.stream&.close
-      rescue StandardError
-        nil
-      end
     rescue StandardError => e
       Rails.logger.error "Unified POST Error: #{e.class} - #{e.message}\n#{e.backtrace.join("\n")}"
       id = begin
@@ -298,7 +167,6 @@ module ActionMCP
         end
       end
 
-      ActionMCP.logger.debug "MCP-Protocol-Version header validation passed: #{header_version}"
       true
     end
 
@@ -320,28 +188,14 @@ module ActionMCP
       request.headers[MCP_SESSION_ID_HEADER].presence
     end
 
-    # Checks if the client's Accept header includes the required types.
-    def accepts_valid_content_types?
-      request.accepts.any? { |type| type.to_s == "application/json" } &&
-        request.accepts.any? { |type| type.to_s == "text/event-stream" }
-    end
-
-    # Checks if the Accept headers for POST are valid according to server preference.
+    # Checks if the Accept headers for POST are valid.
     def post_accept_headers_valid?
-      if ActionMCP.configuration.post_response_preference == :sse
-        accepts_valid_content_types?
-      else
-        request.accepts.any? { |type| type.to_s == "application/json" }
-      end
+      request.accepts.any? { |type| type.to_s == "application/json" }
     end
 
     # Returns the appropriate error message for POST Accept header validation.
     def post_accept_headers_error_message
-      if ActionMCP.configuration.post_response_preference == :sse
-        "Client must accept 'application/json' and 'text/event-stream'"
-      else
-        "Client must accept 'application/json'"
-      end
+      "Client must accept 'application/json'"
     end
 
     # Checks if the parsed body represents an 'initialize' request.
@@ -372,19 +226,11 @@ module ActionMCP
                   result
       end
 
-      # Determine response format
-      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
-        render_sse_response(payload, session, add_session_header)
-      else
-        render_json_response(payload, session, add_session_header)
-      end
+      render_json_response(payload, session, add_session_header)
     end
 
-    # Renders the JSON-RPC response(s) as a direct JSON HTTP response.
+    # Renders the JSON-RPC response as a JSON HTTP response.
     def render_json_response(payload, session, add_session_header)
       response.headers[MCP_SESSION_ID_HEADER] = session.id if add_session_header
       # Add MCP-Protocol-Version header if session has been initialized
@@ -393,62 +239,6 @@ module ActionMCP
       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)
-      response.headers[MCP_SESSION_ID_HEADER] = session.id if add_session_header
-      # Add MCP-Protocol-Version header if session has been initialized
-      response.headers["MCP-Protocol-Version"] = session.protocol_version if session&.initialized?
-      response.headers["Content-Type"] = "text/event-stream"
-      response.headers["X-Accel-Buffering"] = "no"
-      response.headers["Cache-Control"] = "no-cache"
-      response.headers["Connection"] = "keep-alive"
-      sse = SSE.new(response.stream)
-      write_sse_event(sse, session, payload)
-    ensure
-      sse&.close
-      begin
-        response.stream&.close
-      rescue StandardError
-        nil
-      end
-      Rails.logger.debug "Unified SSE (POST): Response stream closed." if ActionMCP.configuration.verbose_logging
-    end
-
-    # Helper to write a JSON payload as an SSE event with a unique ID.
-    # Also stores the event for potential resumability.
-    def write_sse_event(sse, session, payload)
-      event_id = session.increment_sse_counter!
-      # Ensure we're always writing valid JSON strings
-      data = case payload
-      when String
-               payload
-      when Hash
-               MultiJson.dump(payload)
-      else
-               MultiJson.dump(payload.to_h)
-      end
-      # Use the SSE class's write method with proper options
-      # According to MCP spec, we need to send with event type "message"
-      sse.write(data, event: "message", id: event_id)
-
-      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
-
-    # Helper to clean up old SSE events for a session
-    def cleanup_old_sse_events(session)
-      retention_period = session.sse_event_retention_period
-      count = session.cleanup_old_sse_events(retention_period)
-      if count.positive? && ActionMCP.configuration.verbose_logging
-        Rails.logger.debug "Cleaned up #{count} old SSE events for session: #{session.id}"
-      end
-    rescue StandardError => e
-      Rails.logger.error "Error cleaning up old SSE events: #{e.message}"
-    end
-
     def format_tools_list(tools, session)
       protocol_version = session.protocol_version || ActionMCP.configuration.protocol_version
       tools.map { |tool| tool.klass.to_h(protocol_version: protocol_version) }

data/app/models/action_mcp/session.rb

@@ -73,12 +73,6 @@ module ActionMCP
              dependent: :delete_all,
              inverse_of: :session
 
-    has_many :sse_events,
-             class_name: "ActionMCP::Session::SSEEvent",
-             foreign_key: "session_id",
-             dependent: :delete_all,
-             inverse_of: :session
-
     has_many :tasks,
              class_name: "ActionMCP::Session::Task",
              foreign_key: "session_id",
@@ -184,57 +178,6 @@ module ActionMCP
       subscriptions.find_by(uri: uri)&.destroy
     end
 
-    # Atomically increments the SSE event counter and returns the new value.
-    # This ensures unique, sequential IDs for SSE events within the session.
-    # @return [Integer] The new value of the counter.
-    def increment_sse_counter!
-      # Use update_counters for an atomic increment operation
-      self.class.update_counters(id, sse_event_counter: 1)
-      # Reload to get the updated value (update_counters doesn't update the instance)
-      reload.sse_event_counter
-    end
-
-    # Stores an SSE event for potential resumption
-    # @param event_id [Integer] The event ID
-    # @param data [Hash, String] The event data
-    # @param max_events [Integer] Maximum number of events to store (oldest events are removed when exceeded)
-    # @return [ActionMCP::Session::SSEEvent] The created event
-    def store_sse_event(event_id, data, max_events = 100)
-      # Create the SSE event record
-      event = sse_events.create!(
-        event_id: event_id,
-        data: data
-      )
-
-      # Maintain cache limit by removing oldest events if needed
-      count = sse_events.count
-      excess = count - max_events
-      sse_events.order(event_id: :asc).limit(excess).delete_all if excess.positive?
-
-      event
-    end
-
-    # Retrieves SSE events after a given ID
-    # @param last_event_id [Integer] The ID to retrieve events after
-    # @param limit [Integer] Maximum number of events to return
-    # @return [Array<ActionMCP::Session::SSEEvent>] The events
-    def get_sse_events_after(last_event_id, limit = 50)
-      sse_events.where("event_id > ?", last_event_id)
-                .order(event_id: :asc)
-                .limit(limit)
-    end
-
-    # Cleans up old SSE events
-    # @param max_age [ActiveSupport::Duration] Maximum age of events to keep
-    # @return [Integer] Number of events removed
-    def cleanup_old_sse_events(max_age = 15.minutes)
-      cutoff_time = Time.current - max_age
-      events_to_delete = sse_events.where("created_at < ?", cutoff_time)
-      count = events_to_delete.count
-      events_to_delete.destroy_all
-      count
-    end
-
     def send_progress_notification(progressToken:, progress:, total: nil, message: nil)
       # Create a transport handler to send the notification
       handler = ActionMCP::Server::TransportHandler.new(self)
@@ -246,18 +189,6 @@ module ActionMCP
       )
     end
 
-    # Calculates the retention period for SSE events based on configuration
-    # @return [ActiveSupport::Duration] The retention period
-    def sse_event_retention_period
-      ActionMCP.configuration.sse_event_retention_period || 15.minutes
-    end
-
-    # Calculates the maximum number of SSE events to store based on configuration
-    # @return [Integer] The maximum number of events
-    def max_stored_sse_events
-      ActionMCP.configuration.max_stored_sse_events || 100
-    end
-
     def send_progress_notification_legacy(token:, value:, message: nil)
       send_progress_notification(progressToken: token, progress: value, message: message)
     end

data/db/migrate/20251203000001_remove_sse_support.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+class RemoveSseSupport < ActiveRecord::Migration[8.1]
+  def up
+    # Drop SSE events table
+    drop_table :action_mcp_sse_events, if_exists: true
+
+    # Remove SSE counter from sessions
+    remove_column :action_mcp_sessions, :sse_event_counter, if_exists: true
+  end
+
+  def down
+    # Re-add sse_event_counter to sessions
+    unless column_exists?(:action_mcp_sessions, :sse_event_counter)
+      add_column :action_mcp_sessions, :sse_event_counter, :integer, default: 0, null: false
+    end
+
+    # Re-create SSE events table
+    unless table_exists?(:action_mcp_sse_events)
+      create_table :action_mcp_sse_events do |t|
+        t.references :session, null: false, type: :string, foreign_key: { to_table: :action_mcp_sessions }
+        t.integer :event_id, null: false
+        t.text :data, null: false
+        t.timestamps
+      end
+
+      add_index :action_mcp_sse_events, :created_at
+      add_index :action_mcp_sse_events, [ :session_id, :event_id ], unique: true
+    end
+  end
+end

data/db/migrate/20251204000001_add_progress_to_session_tasks.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+class AddProgressToSessionTasks < ActiveRecord::Migration[8.1]
+  def change
+    unless column_exists?(:action_mcp_session_tasks, :progress_percent)
+      add_column :action_mcp_session_tasks, :progress_percent, :integer, comment: "Task progress as percentage 0-100"
+    end
+    unless column_exists?(:action_mcp_session_tasks, :progress_message)
+      add_column :action_mcp_session_tasks, :progress_message, :string, comment: "Human-readable progress message"
+    end
+  end
+end

data/lib/action_mcp/configuration.rb

@@ -30,12 +30,7 @@ module ActionMCP
                   # --- Authentication Options ---
                   :authentication_methods,
                   # --- Transport Options ---
-                  :sse_heartbeat_interval,
-                  :post_response_preference, # :json or :sse
                   :protocol_version,
-                  # --- SSE Resumability Options ---
-                  :sse_event_retention_period,
-                  :max_stored_sse_events,
                   # --- Gateway Options ---
                   :gateway_class,
                   # --- Session Store Options ---
@@ -67,8 +62,6 @@ module ActionMCP
       # Authentication defaults - empty means all configured identifiers will be tried
       @authentication_methods = []
 
-      @sse_heartbeat_interval = 30
-      @post_response_preference = :json
       @protocol_version = "2025-06-18"  # Default to stable version for backwards compatibility
 
       # Tasks defaults (MCP 2025-11-25)
@@ -76,10 +69,6 @@ module ActionMCP
       @tasks_list_enabled = true
       @tasks_cancel_enabled = true
 
-      # Resumability defaults
-      @sse_event_retention_period = 15.minutes
-      @max_stored_sse_events = 100
-
       # Gateway - resolved lazily to account for Zeitwerk autoloading
       @gateway_class_name = nil
 
@@ -214,9 +203,6 @@ module ActionMCP
       capabilities = {}
       profile = @profiles[active_profile]
 
-      Rails.logger.debug "[ActionMCP] Generating capabilities for profile: #{active_profile}"
-      Rails.logger.debug "[ActionMCP] Profile config: #{profile.inspect}"
-
       # Check profile configuration instead of registry contents
       # If profile includes tools (either "all" or specific tools), advertise tools capability
       capabilities[:tools] = { listChanged: @list_changed } if profile && profile[:tools]&.any?

data/lib/action_mcp/engine.rb

@@ -10,7 +10,6 @@ module ActionMCP
     isolate_namespace ActionMCP
 
     ActiveSupport::Inflector.inflections(:en) do |inflect|
-      inflect.acronym "SSE"
       inflect.acronym "MCP"
     end
 

data/lib/action_mcp/filtered_logger.rb

@@ -17,9 +17,6 @@ module ActionMCP
 
         # Filter out repetitive MCP notifications
         return if FILTERED_METHODS.any? { |method| message.include?(method) }
-
-        # Filter out MCP protocol version debug messages
-        return if message.include?("MCP-Protocol-Version header validation passed")
       end
 
       super

data/lib/action_mcp/server/base_session.rb

@@ -5,7 +5,7 @@ module ActionMCP
     # Base session object that mimics ActiveRecord Session with common functionality
     class BaseSession
       attr_accessor :id, :status, :initialized, :role, :messages_count,
-                    :sse_event_counter, :protocol_version, :client_info,
+                    :protocol_version, :client_info,
                     :client_capabilities, :server_info, :server_capabilities,
                     :tool_registry, :prompt_registry, :resource_registry,
                     :created_at, :updated_at, :ended_at, :last_event_id,
@@ -16,8 +16,6 @@ module ActionMCP
         @messages = Concurrent::Array.new
         @subscriptions = Concurrent::Array.new
         @resources = Concurrent::Array.new
-        @sse_events = Concurrent::Array.new
-        @sse_counter = Concurrent::AtomicFixnum.new(0)
         @message_counter = Concurrent::AtomicFixnum.new(0)
         @new_record = true
 
@@ -119,47 +117,6 @@ module ActionMCP
         ResourceCollection.new(@resources)
       end
 
-      def sse_events
-        SSEEventCollection.new(@sse_events)
-      end
-
-      # SSE event management
-      def increment_sse_counter!
-        new_value = @sse_counter.increment
-        self.sse_event_counter = new_value
-        save
-        new_value
-      end
-
-      def store_sse_event(event_id, data, max_events = nil)
-        max_events ||= max_stored_sse_events
-        event = { event_id: event_id, data: data, created_at: Time.current }
-        @sse_events << event
-
-        @sse_events.shift while @sse_events.size > max_events
-
-        event
-      end
-
-      def get_sse_events_after(last_event_id, limit = 50)
-        @sse_events.select { |e| e[:event_id] > last_event_id }.first(limit)
-      end
-
-      def cleanup_old_sse_events(max_age = 15.minutes)
-        cutoff_time = Time.current - max_age
-        original_size = @sse_events.size
-        @sse_events.delete_if { |e| e[:created_at] < cutoff_time }
-        original_size - @sse_events.size
-      end
-
-      def max_stored_sse_events
-        ActionMCP.configuration.max_stored_sse_events || 100
-      end
-
-      def sse_event_retention_period
-        ActionMCP.configuration.sse_event_retention_period || 15.minutes
-      end
-
       # Adapter methods
       def adapter
         ActionMCP::Server.server.pubsub
@@ -418,33 +375,6 @@ module ActionMCP
 
       class ResourceCollection < Array
       end
-
-      class SSEEventCollection < Array
-        def create!(attributes)
-          self << attributes
-          attributes
-        end
-
-        def count
-          size
-        end
-
-        def where(_condition, value)
-          select { |e| e[:event_id] > value }
-        end
-
-        def order(field)
-          sort_by { |e| e[field.is_a?(Hash) ? field.keys.first : field] }
-        end
-
-        def limit(n)
-          first(n)
-        end
-
-        def delete_all
-          clear
-        end
-      end
     end
   end
 end

data/lib/action_mcp/version.rb

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

data/lib/action_mcp.rb

@@ -25,7 +25,6 @@ Zeitwerk::Loader.for_gem.tap do |loader|
   )
 
   loader.inflector.inflect("action_mcp" => "ActionMCP")
-  loader.inflector.inflect("sse_listener" => "SSEListener")
 end.setup
 
 module ActionMCP

data/lib/tasks/action_mcp_tasks.rake

@@ -179,10 +179,7 @@ namespace :action_mcp do
 
     # Transport Configuration
     puts "\n\e[36mTransport Configuration:\e[0m"
-    puts "  SSE Heartbeat Interval: #{config.sse_heartbeat_interval}s"
-    puts "  Post Response Preference: #{config.post_response_preference}"
-    puts "  SSE Event Retention Period: #{config.sse_event_retention_period}"
-    puts "  Max Stored SSE Events: #{config.max_stored_sse_events}"
+    puts "  Protocol Version: #{config.protocol_version}"
 
     # Pub/Sub Adapter
     puts "\n\e[36mPub/Sub Adapter:\e[0m"
@@ -332,37 +329,6 @@ namespace :action_mcp do
       puts "  Error accessing message data: #{e.message}"
     end
 
-    # SSE Event Statistics (if table exists)
-    puts "\n\e[36mSSE Event Statistics:\e[0m"
-
-    begin
-      if ActionMCP::ApplicationRecord.connection.table_exists?("action_mcp_sse_events")
-        total_events = ActionMCP::Session::SSEEvent.count
-        puts "  Total SSE Events: #{total_events}"
-
-        if total_events.positive?
-          # Recent events
-          recent_events = ActionMCP::Session::SSEEvent.where("created_at > ?", 1.hour.ago).count
-          puts "  SSE Events (Last Hour): #{recent_events}"
-
-          # Events by session
-          events_by_session = ActionMCP::Session::SSEEvent.joins(:session)
-                                                          .group("action_mcp_sessions.id")
-                                                          .count
-                                                          .sort_by { |_session_id, count| -count }
-                                                          .first(5)
-          puts "  Top Sessions by SSE Events:"
-          events_by_session.each do |session_id, count|
-            puts "    #{session_id}: #{count} events"
-          end
-        end
-      else
-        puts "  SSE Events table not found"
-      end
-    rescue StandardError => e
-      puts "  Error accessing SSE event data: #{e.message}"
-    end
-
     # Storage Information
     puts "\n\e[36mStorage Information:\e[0m"
     puts "  Session Store Type: #{ActionMCP.configuration.session_store_type}"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: actionmcp
 version: !ruby/object:Gem::Version
-  version: 0.90.0
+  version: 0.100.0
 platform: ruby
 authors:
 - Abdelkader Boudih
@@ -155,7 +155,6 @@ files:
 - app/models/action_mcp/session.rb
 - app/models/action_mcp/session/message.rb
 - app/models/action_mcp/session/resource.rb
-- app/models/action_mcp/session/sse_event.rb
 - app/models/action_mcp/session/subscription.rb
 - app/models/action_mcp/session/task.rb
 - app/models/concerns/action_mcp/mcp_console_helpers.rb
@@ -166,6 +165,9 @@ files:
 - db/migrate/20250727000001_remove_oauth_support.rb
 - db/migrate/20251125000001_create_action_mcp_session_tasks.rb
 - db/migrate/20251126000001_add_continuation_state_to_action_mcp_session_tasks.rb
+- db/migrate/20251203000001_remove_sse_support.rb
+- db/migrate/20251204000001_add_progress_to_session_tasks.rb
+- db/test.sqlite3
 - exe/actionmcp_cli
 - lib/action_mcp.rb
 - lib/action_mcp/base_response.rb
@@ -275,7 +277,6 @@ files:
 - lib/action_mcp/server/tools.rb
 - lib/action_mcp/server/transport_handler.rb
 - lib/action_mcp/server/volatile_session_store.rb
-- lib/action_mcp/sse_listener.rb
 - lib/action_mcp/string_array.rb
 - lib/action_mcp/tagged_stream_logging.rb
 - lib/action_mcp/test_helper.rb

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

@@ -1,62 +0,0 @@
-# frozen_string_literal: true
-
-# <rails-lens:schema:begin>
-# table = "action_mcp_sse_events"
-# database_dialect = "SQLite"
-#
-# columns = [
-#   { name = "id", type = "integer", primary_key = true, nullable = false },
-#   { name = "session_id", type = "string", nullable = false },
-#   { name = "event_id", type = "integer", nullable = false },
-#   { name = "data", type = "text", nullable = false },
-#   { name = "created_at", type = "datetime", nullable = false },
-#   { name = "updated_at", type = "datetime", nullable = false }
-# ]
-#
-# indexes = [
-#   { name = "index_action_mcp_sse_events_on_created_at", columns = ["created_at"] },
-#   { name = "index_action_mcp_sse_events_on_session_id_and_event_id", columns = ["session_id", "event_id"], unique = true },
-#   { name = "index_action_mcp_sse_events_on_session_id", columns = ["session_id"] }
-# ]
-#
-# foreign_keys = [
-#   { column = "session_id", references_table = "action_mcp_sessions", references_column = "id" }
-# ]
-#
-# == Notes
-# - Association 'session' should specify inverse_of
-# - String column 'session_id' has no length limit - consider adding one
-# <rails-lens:schema:end>
-module ActionMCP
-  class Session
-    # Represents a Server-Sent Event (SSE) in an MCP session
-    # These events are stored for potential resumption when a client reconnects
-    class SSEEvent < ApplicationRecord
-      self.table_name = "action_mcp_sse_events"
-
-      belongs_to :session, class_name: "ActionMCP::Session"
-
-      # Validations
-      validates :event_id, presence: true, numericality: { only_integer: true, greater_than: 0 }
-      validates :data, presence: true
-
-      # Scopes
-      scope :recent, -> { order(event_id: :desc) }
-      scope :after_id, ->(id) { where("event_id > ?", id) }
-      scope :before, ->(time) { where("created_at < ?", time) }
-
-      # 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
-
-      # Generates the SSE formatted event string
-      # @return [String] The formatted SSE event
-      def to_sse
-        "id: #{event_id}\ndata: #{data_for_stream}\n\n"
-      end
-    end
-  end
-end

data/lib/action_mcp/sse_listener.rb

@@ -1,81 +0,0 @@
-# frozen_string_literal: true
-
-require "concurrent/atomic/atomic_boolean"
-require "concurrent/promise"
-
-module ActionMCP
-  # Listener class to subscribe to session messages via PubSub adapter.
-  class SSEListener
-    delegate :session_key, :adapter, to: :@session
-
-    # @param session [ActionMCP::Session]
-    def initialize(session)
-      @session = session
-      @stopped = Concurrent::AtomicBoolean.new
-      @subscription_active = Concurrent::AtomicBoolean.new
-    end
-
-    # Start listening using PubSub adapter
-    # @yield [Hash] Yields parsed message received from the pub/sub channel
-    # @return [Boolean] True if subscription was successful within timeout, false otherwise.
-    def start(&callback)
-      success_callback = lambda {
-        @subscription_active.make_true
-      }
-
-      message_callback = lambda { |raw_message|
-        process_message(raw_message, callback)
-      }
-
-      # Subscribe using the PubSub 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
-    end
-
-    private
-
-    def process_message(raw_message, callback)
-      return if @stopped.true?
-
-      begin
-        # 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)
-          callback&.call(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
-
-    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
-
-    def wait_for_subscription
-      subscription_future = Concurrent::Promises.future do
-        sleep 0.1 while !@subscription_active.true? && !@stopped.true?
-        @subscription_active.true?
-      end
-
-      begin
-        subscription_future.value(5) || @subscription_active.true?
-      rescue Concurrent::TimeoutError
-        false
-      end
-    end
-  end
-end