actionmcp 0.52.0 → 0.52.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 123d51b56f85e45cb622885fb6bfcf6caf6d310292302a6ad4a9886e84c36af2
-  data.tar.gz: 15eb5bd01e1985a4eac9c6d83b463d0f939c02ccd330f72366fa0d08603c6f2b
+  metadata.gz: ba6892aa3c28876f79be1ab3b365b2ed70b449e6f55781de9ea565e3f26d4f8e
+  data.tar.gz: ba861b9e0ec4dcdfcf743a70e8fed177a98a169c86c56f9f5d7b50c4bf7bf7b6
 SHA512:
-  metadata.gz: 724a4dc93cc887ce3dc735fe6a00b375a36012887f2aa081b01a45b314460a297ebd3b17cfa423a55276462cca5736feea816a8691fcc0b6006bfb7a385b0f9b
-  data.tar.gz: 451af9c7919a5e65d80af1f3cc3b36e666148bc4b1351049a7ae33e01fd26daaad13b5d72b6a32476e9709c8b44a0291c2ad304f25d9607c99082bf59d99db02
+  metadata.gz: de7d1b0f9db37da9cc7be60ec42aac243ffb521cf878ba4c537269c0afeabdf22c5a2431b6eb5a1a00e79d574bdddbd444d63a1230543fb364b31d8d98ef36da
+  data.tar.gz: eafee3ce33017cfde2175f655caf5cc0e292b37a70427d36acf474e21503abea3ea71b124430c69cb8c29168f8993cac385f5f227c05863482a65e9b8f323e6e

data/README.md

@@ -330,6 +330,115 @@ production:
   max_queue: 500      # Maximum number of tasks that can be queued
 ```
 
+## Session Storage
+
+ActionMCP provides a pluggable session storage system that allows you to choose how sessions are persisted based on your environment and requirements.
+
+### Session Store Types
+
+ActionMCP includes three session store implementations:
+
+1. **`:volatile`** - In-memory storage using Concurrent::Hash
+   - Default for development and test environments
+   - Sessions are lost on server restart
+   - Fast and lightweight for local development
+   - No external dependencies
+
+2. **`:active_record`** - Database-backed storage
+   - Default for production environment
+   - Sessions persist across server restarts
+   - Supports session resumability
+   - Requires database migrations
+
+3. **`:test`** - Special store for testing
+   - Tracks notifications and method calls
+   - Provides assertion helpers
+   - Automatically used in test environment when using TestHelper
+
+### Configuration
+
+You can configure the session store type in your Rails configuration:
+
+```ruby
+# config/application.rb or environment files
+Rails.application.configure do
+  config.action_mcp.session_store_type = :active_record  # or :volatile
+end
+```
+
+The defaults are:
+- Production: `:active_record`
+- Development: `:volatile`
+- Test: `:volatile` (or `:test` when using TestHelper)
+
+### Using Different Session Stores
+
+```ruby
+# The session store is automatically selected based on configuration
+# You can access it directly if needed:
+session_store = ActionMCP::Server.session_store
+
+# Create a session
+session = session_store.create_session(session_id, {
+  status: "initialized",
+  protocol_version: "2025-03-26",
+  # ... other session attributes
+})
+
+# Load a session
+session = session_store.load_session(session_id)
+
+# Update a session
+session_store.update_session(session_id, { status: "active" })
+
+# Delete a session
+session_store.delete_session(session_id)
+```
+
+### Session Resumability
+
+With the `:active_record` store, clients can resume sessions after disconnection:
+
+```ruby
+# Client includes session ID in request headers
+# Server automatically resumes the existing session
+headers["Mcp-Session-Id"] = "existing-session-id"
+
+# If the session exists, it will be resumed
+# If not, a new session will be created
+```
+
+### Custom Session Stores
+
+You can create custom session stores by inheriting from `ActionMCP::Server::SessionStore::Base`:
+
+```ruby
+class MyCustomSessionStore < ActionMCP::Server::SessionStore::Base
+  def create_session(session_id, payload = {})
+    # Implementation
+  end
+
+  def load_session(session_id)
+    # Implementation
+  end
+
+  def update_session(session_id, updates)
+    # Implementation
+  end
+
+  def delete_session(session_id)
+    # Implementation
+  end
+
+  def exists?(session_id)
+    # Implementation
+  end
+end
+
+# Register your custom store
+ActionMCP::Server.session_store = MyCustomSessionStore.new
+```
+
 ## Thread Pool Management
 
 ActionMCP uses thread pools to efficiently handle message callbacks. This prevents the system from being overwhelmed by too many threads under high load.

data/lib/action_mcp/client/active_record_session_store.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module ActionMCP
+  module Client
+    # ActiveRecord-backed session store for production
+    class ActiveRecordSessionStore
+      include SessionStore
+
+      def load_session(session_id)
+        session = ActionMCP::Session.find_by(id: session_id)
+        return nil unless session
+
+        {
+          id: session.id,
+          protocol_version: session.protocol_version,
+          client_info: session.client_info,
+          client_capabilities: session.client_capabilities,
+          server_info: session.server_info,
+          server_capabilities: session.server_capabilities,
+          created_at: session.created_at,
+          updated_at: session.updated_at
+        }
+      end
+
+      def save_session(session_id, session_data)
+        session = ActionMCP::Session.find_or_initialize_by(id: session_id)
+
+        # Only assign attributes that exist in the database
+        attributes = {}
+        attributes[:protocol_version] = session_data[:protocol_version] if session_data.key?(:protocol_version)
+        attributes[:client_info] = session_data[:client_info] if session_data.key?(:client_info)
+        attributes[:client_capabilities] = session_data[:client_capabilities] if session_data.key?(:client_capabilities)
+        attributes[:server_info] = session_data[:server_info] if session_data.key?(:server_info)
+        attributes[:server_capabilities] = session_data[:server_capabilities] if session_data.key?(:server_capabilities)
+
+        # Store any extra data in a jsonb column if available
+        # For now, we'll skip last_event_id and session_data as they don't exist in the DB
+
+        session.assign_attributes(attributes)
+        session.save!
+        session_data
+      end
+
+      def delete_session(session_id)
+        ActionMCP::Session.find_by(id: session_id)&.destroy
+      end
+
+      def session_exists?(session_id)
+        ActionMCP::Session.exists?(id: session_id)
+      end
+
+      def cleanup_expired_sessions(older_than: 24.hours.ago)
+        ActionMCP::Session.where("updated_at < ?", older_than).delete_all
+      end
+    end
+  end
+end

data/lib/action_mcp/client/session_store.rb

@@ -35,197 +35,5 @@ module ActionMCP
         load_session(session_id)
       end
     end
-
-    # Volatile session store for development (data lost on restart)
-    class VolatileSessionStore
-      include SessionStore
-
-      def initialize
-        @sessions = Concurrent::Hash.new
-      end
-
-      def load_session(session_id)
-        @sessions[session_id]
-      end
-
-      def save_session(session_id, session_data)
-        @sessions[session_id] = session_data.dup
-      end
-
-      def delete_session(session_id)
-        @sessions.delete(session_id)
-      end
-
-      def session_exists?(session_id)
-        @sessions.key?(session_id)
-      end
-
-      def clear_all
-        @sessions.clear
-      end
-
-      def session_count
-        @sessions.size
-      end
-    end
-
-    # ActiveRecord-backed session store for production
-    class ActiveRecordSessionStore
-      include SessionStore
-
-      def load_session(session_id)
-        session = ActionMCP::Session.find_by(id: session_id)
-        return nil unless session
-
-        {
-          id: session.id,
-          protocol_version: session.protocol_version,
-          client_info: session.client_info,
-          client_capabilities: session.client_capabilities,
-          server_info: session.server_info,
-          server_capabilities: session.server_capabilities,
-          created_at: session.created_at,
-          updated_at: session.updated_at
-        }
-      end
-
-      def save_session(session_id, session_data)
-        session = ActionMCP::Session.find_or_initialize_by(id: session_id)
-
-        # Only assign attributes that exist in the database
-        attributes = {}
-        attributes[:protocol_version] = session_data[:protocol_version] if session_data.key?(:protocol_version)
-        attributes[:client_info] = session_data[:client_info] if session_data.key?(:client_info)
-        attributes[:client_capabilities] = session_data[:client_capabilities] if session_data.key?(:client_capabilities)
-        attributes[:server_info] = session_data[:server_info] if session_data.key?(:server_info)
-        attributes[:server_capabilities] = session_data[:server_capabilities] if session_data.key?(:server_capabilities)
-
-        # Store any extra data in a jsonb column if available
-        # For now, we'll skip last_event_id and session_data as they don't exist in the DB
-
-        session.assign_attributes(attributes)
-        session.save!
-        session_data
-      end
-
-      def delete_session(session_id)
-        ActionMCP::Session.find_by(id: session_id)&.destroy
-      end
-
-      def session_exists?(session_id)
-        ActionMCP::Session.exists?(id: session_id)
-      end
-
-      def cleanup_expired_sessions(older_than: 24.hours.ago)
-        ActionMCP::Session.where("updated_at < ?", older_than).delete_all
-      end
-    end
-
-    # Test session store that tracks all operations for assertions
-    class TestSessionStore < VolatileSessionStore
-      attr_reader :operations, :saved_sessions, :loaded_sessions,
-                  :deleted_sessions, :updated_sessions
-
-      def initialize
-        super
-        @operations = Concurrent::Array.new
-        @saved_sessions = Concurrent::Array.new
-        @loaded_sessions = Concurrent::Array.new
-        @deleted_sessions = Concurrent::Array.new
-        @updated_sessions = Concurrent::Array.new
-      end
-
-      def load_session(session_id)
-        session = super
-        @operations << { type: :load, session_id: session_id, found: !session.nil? }
-        @loaded_sessions << session_id if session
-        session
-      end
-
-      def save_session(session_id, session_data)
-        super
-        @operations << { type: :save, session_id: session_id, data: session_data }
-        @saved_sessions << session_id
-      end
-
-      def delete_session(session_id)
-        result = super
-        @operations << { type: :delete, session_id: session_id }
-        @deleted_sessions << session_id
-        result
-      end
-
-      def update_session(session_id, attributes)
-        result = super
-        @operations << { type: :update, session_id: session_id, attributes: attributes }
-        @updated_sessions << session_id if result
-        result
-      end
-
-      # Test helper methods
-      def session_saved?(session_id)
-        @saved_sessions.include?(session_id)
-      end
-
-      def session_loaded?(session_id)
-        @loaded_sessions.include?(session_id)
-      end
-
-      def session_deleted?(session_id)
-        @deleted_sessions.include?(session_id)
-      end
-
-      def session_updated?(session_id)
-        @updated_sessions.include?(session_id)
-      end
-
-      def operation_count(type = nil)
-        if type
-          @operations.count { |op| op[:type] == type }
-        else
-          @operations.size
-        end
-      end
-
-      def last_saved_data(session_id)
-        @operations.reverse.find { |op| op[:type] == :save && op[:session_id] == session_id }&.dig(:data)
-      end
-
-      def reset_tracking!
-        @operations.clear
-        @saved_sessions.clear
-        @loaded_sessions.clear
-        @deleted_sessions.clear
-        @updated_sessions.clear
-      end
-    end
-
-    # Factory for creating session stores
-    class SessionStoreFactory
-      def self.create(type = nil, **options)
-        type ||= default_type
-
-        case type.to_sym
-        when :volatile, :memory
-          VolatileSessionStore.new
-        when :active_record, :persistent
-          ActiveRecordSessionStore.new
-        when :test
-          TestSessionStore.new
-        else
-          raise ArgumentError, "Unknown session store type: #{type}"
-        end
-      end
-
-      def self.default_type
-        if Rails.env.test?
-          :volatile  # Use volatile for tests unless explicitly using :test
-        elsif Rails.env.production?
-          :active_record
-        else
-          :volatile
-        end
-      end
-    end
   end
 end

data/lib/action_mcp/client/session_store_factory.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module ActionMCP
+  module Client
+    # Factory for creating session stores
+    class SessionStoreFactory
+      def self.create(type = nil, **_options)
+        type ||= default_type
+
+        case type.to_sym
+        when :volatile, :memory
+          VolatileSessionStore.new
+        when :active_record, :persistent
+          ActiveRecordSessionStore.new
+        when :test
+          TestSessionStore.new
+        else
+          raise ArgumentError, "Unknown session store type: #{type}"
+        end
+      end
+
+      def self.default_type
+        # Ensure Rails is defined or provide a fallback if this code can run
+        # outside a Rails environment.
+        # Will refactor this soon
+        if defined?(Rails) && Rails.env.test?
+          :volatile  # Use volatile for tests unless explicitly using :test
+        elsif defined?(Rails) && Rails.env.production?
+          :active_record
+        else
+          :volatile # Default for development or non-Rails environments
+        end
+      end
+    end
+  end
+end

data/lib/action_mcp/client/test_session_store.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module ActionMCP
+  module Client
+    # Test session store that tracks all operations for assertions
+    class TestSessionStore < VolatileSessionStore
+      attr_reader :operations, :saved_sessions, :loaded_sessions,
+                  :deleted_sessions, :updated_sessions
+
+      def initialize
+        super
+        @operations = Concurrent::Array.new
+        @saved_sessions = Concurrent::Array.new
+        @loaded_sessions = Concurrent::Array.new
+        @deleted_sessions = Concurrent::Array.new
+        @updated_sessions = Concurrent::Array.new
+      end
+
+      def load_session(session_id)
+        session = super
+        @operations << { type: :load, session_id: session_id, found: !session.nil? }
+        @loaded_sessions << session_id if session
+        session
+      end
+
+      def save_session(session_id, session_data)
+        super
+        @operations << { type: :save, session_id: session_id, data: session_data }
+        @saved_sessions << session_id
+      end
+
+      def delete_session(session_id)
+        result = super
+        @operations << { type: :delete, session_id: session_id }
+        @deleted_sessions << session_id
+        result
+      end
+
+      def update_session(session_id, attributes)
+        result = super
+        @operations << { type: :update, session_id: session_id, attributes: attributes }
+        @updated_sessions << session_id if result
+        result
+      end
+
+      # Test helper methods
+      def session_saved?(session_id)
+        @saved_sessions.include?(session_id)
+      end
+
+      def session_loaded?(session_id)
+        @loaded_sessions.include?(session_id)
+      end
+
+      def session_deleted?(session_id)
+        @deleted_sessions.include?(session_id)
+      end
+
+      def session_updated?(session_id)
+        @updated_sessions.include?(session_id)
+      end
+
+      def operation_count(type = nil)
+        if type
+          @operations.count { |op| op[:type] == type }
+        else
+          @operations.size
+        end
+      end
+
+      def last_saved_data(session_id)
+        @operations.reverse.find { |op| op[:type] == :save && op[:session_id] == session_id }&.dig(:data)
+      end
+
+      def reset_tracking!
+        @operations.clear
+        @saved_sessions.clear
+        @loaded_sessions.clear
+        @deleted_sessions.clear
+        @updated_sessions.clear
+      end
+    end
+  end
+end

data/lib/action_mcp/client/volatile_session_store.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module ActionMCP
+  module Client
+    # Volatile session store for development (data lost on restart)
+    class VolatileSessionStore
+      include SessionStore
+
+      def initialize
+        @sessions = Concurrent::Hash.new
+      end
+
+      def load_session(session_id)
+        @sessions[session_id]
+      end
+
+      def save_session(session_id, session_data)
+        @sessions[session_id] = session_data.dup
+      end
+
+      def delete_session(session_id)
+        @sessions.delete(session_id)
+      end
+
+      def session_exists?(session_id)
+        @sessions.key?(session_id)
+      end
+
+      def clear_all
+        @sessions.clear
+      end
+
+      def session_count
+        @sessions.size
+      end
+    end
+  end
+end

data/lib/action_mcp/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: actionmcp
 version: !ruby/object:Gem::Version
-  version: 0.52.0
+  version: 0.52.1
 platform: ruby
 authors:
 - Abdelkader Boudih
@@ -137,6 +137,7 @@ files:
 - lib/action_mcp/callbacks.rb
 - lib/action_mcp/capability.rb
 - lib/action_mcp/client.rb
+- lib/action_mcp/client/active_record_session_store.rb
 - lib/action_mcp/client/base.rb
 - lib/action_mcp/client/blueprint.rb
 - lib/action_mcp/client/catalog.rb
@@ -151,11 +152,14 @@ files:
 - lib/action_mcp/client/roots.rb
 - lib/action_mcp/client/server.rb
 - lib/action_mcp/client/session_store.rb
+- lib/action_mcp/client/session_store_factory.rb
 - lib/action_mcp/client/sse_client.rb
 - lib/action_mcp/client/streamable_http_transport.rb
+- lib/action_mcp/client/test_session_store.rb
 - lib/action_mcp/client/toolbox.rb
 - lib/action_mcp/client/tools.rb
 - lib/action_mcp/client/transport.rb
+- lib/action_mcp/client/volatile_session_store.rb
 - lib/action_mcp/configuration.rb
 - lib/action_mcp/console_detector.rb
 - lib/action_mcp/content.rb