actionmcp 0.83.4 → 0.100.0

data/app/models/action_mcp/session.rb

@@ -73,8 +73,8 @@ module ActionMCP
              dependent: :delete_all,
              inverse_of: :session
 
-    has_many :sse_events,
-             class_name: "ActionMCP::Session::SSEEvent",
+    has_many :tasks,
+             class_name: "ActionMCP::Session::Task",
              foreign_key: "session_id",
              dependent: :delete_all,
              inverse_of: :session
@@ -178,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)
@@ -240,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/20250715070713_add_consents_to_action_mcp_sess.rb

@@ -2,6 +2,8 @@
 
 class AddConsentsToActionMCPSess < ActiveRecord::Migration[8.0]
   def change
+    return if column_exists?(:action_mcp_sessions, :consents)
+
     add_column :action_mcp_sessions, :consents, :json, default: {}, null: false
   end
 end

data/db/migrate/20251125000001_create_action_mcp_session_tasks.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+class CreateActionMCPSessionTasks < ActiveRecord::Migration[8.0]
+  def change
+    create_table :action_mcp_session_tasks, id: :string 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_tasks_session_id' },
+                             type: :string
+      t.string :status, null: false, default: 'working'
+      t.string :status_message
+      t.string :request_method, comment: 'e.g., tools/call, prompts/get'
+      t.string :request_name, comment: 'e.g., tool name, prompt name'
+      t.json :request_params, comment: 'Original request params'
+      t.json :result_payload, comment: 'Final result data'
+      t.integer :ttl, comment: 'Time to live in milliseconds'
+      t.integer :poll_interval, comment: 'Suggested polling interval in milliseconds'
+      t.datetime :last_updated_at, null: false
+
+      t.timestamps
+
+      t.index :status
+      t.index %i[session_id status]
+      t.index :created_at
+    end
+  end
+end

data/db/migrate/20251126000001_add_continuation_state_to_action_mcp_session_tasks.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+class AddContinuationStateToActionMCPSessionTasks < ActiveRecord::Migration[8.1]
+  def change
+    add_column :action_mcp_session_tasks, :continuation_state, :json, default: {}
+    add_column :action_mcp_session_tasks, :progress_percent, :integer
+    add_column :action_mcp_session_tasks, :progress_message, :string
+    add_column :action_mcp_session_tasks, :last_step_at, :datetime
+  end
+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/exe/actionmcp_cli

@@ -62,7 +62,7 @@ end
 
 # Function to generate a unique request ID
 def generate_request_id
-  SecureRandom.uuid
+  SecureRandom.uuid_v7
 end
 
 # Function to parse command shortcuts and return a Request object

data/lib/action_mcp/capability.rb

@@ -11,6 +11,7 @@ module ActionMCP
     include Renderable
 
     class_attribute :_capability_name, instance_accessor: false
+    class_attribute :_registered_name, instance_accessor: false
     class_attribute :_description, instance_accessor: false, default: ""
 
     attr_reader :execution_context

data/lib/action_mcp/client/base.rb

@@ -187,7 +187,7 @@ module ActionMCP
         params[:sessionId] = @session_id if @session_id
 
         # Use a unique request ID (not session ID since we don't have one yet)
-        request_id = SecureRandom.uuid
+        request_id = SecureRandom.uuid_v7
         send_jsonrpc_request("initialize", params: params, id: request_id)
       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 ---
@@ -48,7 +43,11 @@ module ActionMCP
                   :max_threads,
                   :max_queue,
                   :polling_interval,
-                  :connects_to
+                  :connects_to,
+                  # --- Tasks Options (MCP 2025-11-25) ---
+                  :tasks_enabled,
+                  :tasks_list_enabled,
+                  :tasks_cancel_enabled
 
     def initialize
       @logging_enabled = false
@@ -63,13 +62,12 @@ 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-03-26" # Default to legacy for backwards compatibility
+      @protocol_version = "2025-06-18"  # Default to stable version for backwards compatibility
 
-      # Resumability defaults
-      @sse_event_retention_period = 15.minutes
-      @max_stored_sse_events = 100
+      # Tasks defaults (MCP 2025-11-25)
+      @tasks_enabled = false
+      @tasks_list_enabled = true
+      @tasks_cancel_enabled = true
 
       # Gateway - resolved lazily to account for Zeitwerk autoloading
       @gateway_class_name = nil
@@ -205,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?
@@ -224,6 +219,18 @@ module ActionMCP
 
       capabilities[:elicitation] = {} if @elicitation_enabled
 
+      # Tasks capability (MCP 2025-11-25)
+      if @tasks_enabled
+        tasks_cap = {
+          requests: {
+            tools: { call: {} }
+          }
+        }
+        tasks_cap[:list] = {} if @tasks_list_enabled
+        tasks_cap[:cancel] = {} if @tasks_cancel_enabled
+        capabilities[:tasks] = tasks_cap
+      end
+
       capabilities
     end
 

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
 
@@ -61,6 +60,14 @@ module ActionMCP
 
     # Configure autoloading for the mcp/tools directory and identifiers
     initializer "action_mcp.autoloading", before: :set_autoload_paths do |app|
+      # Ensure ActionMCP base constants exist before Zeitwerk indexes app/mcp
+      # This prevents NameError when dependent gems have app/mcp
+      # directories with classes inheriting from ActionMCP::Tool, etc.
+      require "action_mcp/tool"
+      require "action_mcp/prompt"
+      require "action_mcp/resource_template"
+      require "action_mcp/gateway"
+
       mcp_path = app.root.join("app/mcp")
       identifiers_path = app.root.join("app/identifiers")
 

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/json_rpc_handler_base.rb

@@ -34,6 +34,16 @@ module ActionMCP
 
       # Elicitation methods
       ELICITATION_CREATE = "elicitation/create"
+
+      # Task methods (MCP 2025-11-25)
+      TASKS_GET = "tasks/get"
+      TASKS_RESULT = "tasks/result"
+      TASKS_LIST = "tasks/list"
+      TASKS_CANCEL = "tasks/cancel"
+      TASKS_RESUME = "tasks/resume"
+
+      # Task notifications
+      NOTIFICATIONS_TASKS_STATUS = "notifications/tasks/status"
     end
 
     delegate :initialize!, :initialized?, to: :transport

data/lib/action_mcp/prompt.rb

@@ -18,11 +18,27 @@ module ActionMCP
     def self.prompt_name(name = nil)
       if name
         self._capability_name = name
+        re_register_if_needed
+        name
       else
         _capability_name || default_prompt_name
       end
     end
 
+    # Re-registers the prompt if it was already registered under a different name
+    # @return [void]
+    def self.re_register_if_needed
+      return if abstract?
+      return unless _registered_name # Not yet registered
+
+      new_name = capability_name
+      return if _registered_name == new_name # No change
+
+      ActionMCP::PromptsRegistry.re_register(self, _registered_name)
+    end
+
+    private_class_method :re_register_if_needed
+
     # Returns the default prompt name based on the class name.
     #
     # @return [String] The default prompt name.

data/lib/action_mcp/registry_base.rb

@@ -21,7 +21,29 @@ module ActionMCP
       def register(klass)
         return if klass.abstract?
 
-        items[klass.capability_name] = klass
+        name = klass.capability_name
+        items[name] = klass
+        klass._registered_name = name if klass.respond_to?(:_registered_name=)
+      end
+
+      # Re-register an item under its current capability_name
+      # Removes old entry if name changed
+      #
+      # @param klass [Class] The class to re-register
+      # @param old_name [String] The previous registered name
+      # @return [void]
+      def re_register(klass, old_name)
+        return if klass.abstract?
+
+        new_name = klass.capability_name
+
+        # Remove old entry if it exists and points to this class
+        if old_name && items[old_name] == klass
+          items.delete(old_name)
+        end
+
+        items[new_name] = klass
+        klass._registered_name = new_name if klass.respond_to?(:_registered_name=)
       end
 
       # Unregister an item

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/server/handlers/router.rb

@@ -18,6 +18,8 @@ module ActionMCP
             @handler.process_resources(rpc_method, id, params)
           when %r{^tools/}
             @handler.process_tools(rpc_method, id, params)
+          when %r{^tasks/}
+            @handler.process_tasks(rpc_method, id, params)
           when "completion/complete"
             @handler.process_completion_complete(id, params)
           else

data/lib/action_mcp/server/handlers/task_handler.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module ActionMCP
+  module Server
+    module Handlers
+      # Handler for MCP 2025-11-25 Tasks feature
+      # Tasks provide durable state machines for tracking async request execution
+      module TaskHandler
+        include ErrorAware
+
+        def process_tasks(rpc_method, id, params)
+          params ||= {}
+
+          with_error_handling(id) do
+            handler = task_method_handlers[rpc_method]
+            if handler
+              send(handler, id, params)
+            else
+              Rails.logger.warn("Unknown tasks method: #{rpc_method}")
+              raise JSON_RPC::JsonRpcError.new(:method_not_found, message: "Unknown tasks method: #{rpc_method}")
+            end
+          end
+        end
+
+        private
+
+        def task_method_handlers
+          {
+            JsonRpcHandlerBase::Methods::TASKS_GET => :handle_tasks_get,
+            JsonRpcHandlerBase::Methods::TASKS_RESULT => :handle_tasks_result,
+            JsonRpcHandlerBase::Methods::TASKS_LIST => :handle_tasks_list,
+            JsonRpcHandlerBase::Methods::TASKS_CANCEL => :handle_tasks_cancel,
+            JsonRpcHandlerBase::Methods::TASKS_RESUME => :handle_tasks_resume
+          }
+        end
+
+        def handle_tasks_get(id, params)
+          task_id = validate_required_param(params, "taskId", "Task ID is required")
+          task = find_task_or_error(id, task_id)
+          return unless task
+
+          transport.send_tasks_get(id, task_id)
+        end
+
+        def handle_tasks_result(id, params)
+          task_id = validate_required_param(params, "taskId", "Task ID is required")
+          task = find_task_or_error(id, task_id)
+          return unless task
+
+          transport.send_tasks_result(id, task_id)
+        end
+
+        def handle_tasks_list(id, params)
+          cursor = params["cursor"]
+          transport.send_tasks_list(id, cursor: cursor)
+        end
+
+        def handle_tasks_cancel(id, params)
+          task_id = validate_required_param(params, "taskId", "Task ID is required")
+          task = find_task_or_error(id, task_id)
+          return unless task
+
+          transport.send_tasks_cancel(id, task_id)
+        end
+
+        def handle_tasks_resume(id, params)
+          task_id = validate_required_param(params, "taskId", "Task ID is required")
+          input = params["input"]
+          task = find_task_or_error(id, task_id)
+          return unless task
+
+          transport.send_tasks_resume(id, task_id, input)
+        end
+
+        def find_task_or_error(id, task_id)
+          task = transport.session.tasks.find_by(id: task_id)
+          unless task
+            transport.send_jsonrpc_error(id, :invalid_params, "Task '#{task_id}' not found")
+            return nil
+          end
+          task
+        end
+      end
+    end
+  end
+end

data/lib/action_mcp/server/json_rpc_handler.rb

@@ -7,6 +7,7 @@ module ActionMCP
       include Handlers::ToolHandler
       include Handlers::PromptHandler
       include Handlers::LoggingHandler
+      include Handlers::TaskHandler
       include ErrorHandling
       include ErrorAware
 
@@ -54,6 +55,8 @@ module ActionMCP
           process_resources(rpc_method, id, params)
         when %r{^tools/}
           process_tools(rpc_method, id, params)
+        when %r{^tasks/}
+          process_tasks(rpc_method, id, params)
         when Methods::COMPLETION_COMPLETE
           process_completion_complete(id, params)
         when Methods::LOGGING_SET_LEVEL

data/lib/action_mcp/server/simple_pub_sub.rb

@@ -36,7 +36,7 @@ module ActionMCP
       # @param success_callback [Proc] Callback for successful subscription
       # @return [String] Subscription ID
       def subscribe(channel, message_callback, success_callback = nil)
-        subscription_id = SecureRandom.uuid
+        subscription_id = SecureRandom.uuid_v7
 
         @subscriptions[subscription_id] = {
           channel: channel,

data/lib/action_mcp/server/solid_mcp_adapter.rb

@@ -21,7 +21,7 @@ module ActionMCP
       # @param success_callback [Proc] Callback for successful subscription
       # @return [String] Subscription ID
       def subscribe(channel, message_callback, success_callback = nil)
-        subscription_id = SecureRandom.uuid
+        subscription_id = SecureRandom.uuid_v7
         session_id = extract_session_id(channel)
 
         @subscriptions[subscription_id] = {