actionmcp 0.51.0 → 0.52.0

data/lib/action_mcp/server/tools.rb

@@ -39,14 +39,25 @@ module ActionMCP
         tool_class = session.registered_tools.find { |t| t.tool_name == tool_name }
 
         if tool_class
-          # Create tool and set execution context
+          # Create tool and set execution context with request info
           tool = tool_class.new(arguments)
-          tool.with_context({ session: session })
+          tool.with_context({
+            session: session,
+            request: {
+              params: {
+                name: tool_name,
+                arguments: arguments,
+                _meta: _meta
+              }
+            }
+          })
 
           result = tool.call
 
           if result.is_error
-            send_jsonrpc_response(request_id, error: result)
+            # Convert ToolResponse error to proper JSON-RPC error format
+            error_hash = result.to_h
+            send_jsonrpc_response(request_id, error: error_hash)
           else
             send_jsonrpc_response(request_id, result: result)
           end

data/lib/action_mcp/server/transport_handler.rb

@@ -1,5 +1,8 @@
 # frozen_string_literal: true
 
+require_relative "response_collector"
+require_relative "base_messaging"
+
 module ActionMCP
   module Server
     class TransportHandler
@@ -9,6 +12,7 @@ module ActionMCP
       delegate :read, :write, to: :session
       include Logging
 
+      include  BaseMessaging  # Provides basic write_message
       include  Messaging
       include  Capabilities
       include  Tools
@@ -17,10 +21,14 @@ module ActionMCP
       include  Notifications
       include  Sampling
       include  Roots
+      include  ResponseCollector  # Must be included last to override write_message
 
       # @param [ActionMCP::Session] session
-      def initialize(session)
+      # @param messaging_mode [:write, :return] The mode for message handling
+      def initialize(session, messaging_mode: :write)
         @session = session
+        @messaging_mode = messaging_mode
+        initialize_response_collector if messaging_mode == :return
       end
 
       def send_pong(request_id)
@@ -29,10 +37,6 @@ module ActionMCP
 
       private
 
-      def write_message(data)
-        session.write(data)
-      end
-
       def format_registry_items(registry)
         registry.map { |item| item.klass.to_h }
       end

data/lib/action_mcp/server.rb

@@ -28,6 +28,13 @@ module ActionMCP
       @server = nil
     end
 
+    # Access the session store
+    def session_store
+      @session_store ||= SessionStoreFactory.create(
+        ActionMCP.configuration.session_store_type
+      )
+    end
+
     # Available pubsub adapter types
     ADAPTERS = {
       "test" => "SimplePubSub",

data/lib/action_mcp/tagged_stream_logging.rb

@@ -1,9 +1,5 @@
 # frozen_string_literal: true
 
-# frozen_string_literal: true
-
-# lib/action_mcp/tagged_io_logging.rb
-
 module ActionMCP
   module TaggedStreamLogging
     # ────────────  ANSI COLOURS  ────────────

data/lib/action_mcp/test_helper/progress_notification_assertions.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+module ActionMCP
+  module TestHelper
+    module ProgressNotificationAssertions
+      # Assert that at least one progress notification was sent with the given token
+      def assert_progress_notification_sent(token, message = nil)
+        notifications = get_progress_notifications(token)
+        assert notifications.any?,
+               message || "Expected at least one progress notification with token #{token}, but none were sent"
+      end
+
+      # Assert that no progress notifications were sent with the given token
+      def assert_no_progress_notification_sent(token, message = nil)
+        notifications = get_progress_notifications(token)
+        assert notifications.empty?,
+               message || "Expected no progress notifications with token #{token}, but #{notifications.size} were sent"
+      end
+
+      # Assert that progress values increase monotonically
+      def assert_progress_sequence_valid(token, message = nil)
+        notifications = get_progress_notifications(token)
+        progress_values = notifications.map { |n| n.params[:progress] }
+
+        assert progress_values.each_cons(2).all? { |a, b| b > a },
+               message || "Progress values must increase monotonically, but got: #{progress_values.inspect}"
+      end
+
+      # Assert specific fields in the latest progress notification
+      def assert_progress_notification_includes(token, expected, message = nil)
+        notifications = get_progress_notifications(token)
+        assert notifications.any?, "No progress notifications found for token #{token}"
+
+        notification = notifications.last
+        expected.each do |key, value|
+          actual = notification.params[key]
+          assert_equal value, actual,
+                       message || "Expected notification to have #{key}: #{value.inspect}, but got: #{actual.inspect}"
+        end
+      end
+
+      # Assert the total count of progress notifications for a token
+      def assert_progress_notification_count(token, expected_count, message = nil)
+        notifications = get_progress_notifications(token)
+        actual_count = notifications.size
+
+        assert_equal expected_count, actual_count,
+                     message || "Expected #{expected_count} progress notifications for token #{token}, but got #{actual_count}"
+      end
+
+      # Assert notification follows MCP spec structure
+      def assert_progress_notification_valid(notification, message = nil)
+        # Convert to hash if it's a notification object
+        data = notification.respond_to?(:to_h) ? notification.to_h : notification
+
+        # Verify JSON-RPC structure
+        assert_equal "2.0", data["jsonrpc"] || data[:jsonrpc],
+                     message || "Notification must have jsonrpc: 2.0"
+        assert_equal "notifications/progress", data[:method],
+                     message || "Notification method must be notifications/progress"
+        assert_nil data[:id],
+                   message || "Notifications must not have an id field"
+
+        # Verify params
+        params = data[:params]
+        assert params, "Notification must have params"
+        assert params[:progressToken], "Notification must have progressToken"
+        assert params[:progress], "Notification must have progress value"
+
+        # Type checks
+        assert [ String, Integer ].include?(params[:progressToken].class),
+               "progressToken must be string or integer"
+        assert params[:progress].is_a?(Numeric),
+               "progress must be numeric"
+
+        # Optional field type checks if present
+        if params.key?(:total)
+          assert params[:total].is_a?(Numeric),
+                 "total must be numeric when present"
+        end
+
+        if params.key?(:message)
+          assert params[:message].is_a?(String),
+                 "message must be string when present"
+        end
+      end
+
+      # Get the current session store (with helpful error if not using test store)
+      def progress_session_store
+        store = ActionMCP::Server.session_store
+        unless store.respond_to?(:notifications_for_token)
+          raise "Session store #{store.class} does not support notification tracking. " \
+                "Use TestSessionStore for progress notification tests."
+        end
+        store
+      end
+
+      private
+
+      def get_progress_notifications(token)
+        progress_session_store.notifications_for_token(token)
+      end
+    end
+  end
+end

data/lib/action_mcp/test_helper/session_store_assertions.rb

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+module ActionMCP
+  module TestHelper
+    module SessionStoreAssertions
+      # Server session store assertions
+      def assert_session_created(session_id, message = nil)
+        assert server_session_store.session_created?(session_id),
+               message || "Expected session #{session_id} to have been created"
+      end
+
+      def assert_session_not_created(session_id, message = nil)
+        assert_not server_session_store.session_created?(session_id),
+                   message || "Expected session #{session_id} not to have been created"
+      end
+
+      def assert_session_loaded(session_id, message = nil)
+        assert server_session_store.session_loaded?(session_id),
+               message || "Expected session #{session_id} to have been loaded"
+      end
+
+      def assert_session_not_loaded(session_id, message = nil)
+        assert_not server_session_store.session_loaded?(session_id),
+                   message || "Expected session #{session_id} not to have been loaded"
+      end
+
+      def assert_session_saved(session_id, message = nil)
+        assert server_session_store.session_saved?(session_id),
+               message || "Expected session #{session_id} to have been saved"
+      end
+
+      def assert_session_not_saved(session_id, message = nil)
+        assert_not server_session_store.session_saved?(session_id),
+                   message || "Expected session #{session_id} not to have been saved"
+      end
+
+      def assert_session_deleted(session_id, message = nil)
+        assert server_session_store.session_deleted?(session_id),
+               message || "Expected session #{session_id} to have been deleted"
+      end
+
+      def assert_session_not_deleted(session_id, message = nil)
+        assert_not server_session_store.session_deleted?(session_id),
+                   message || "Expected session #{session_id} not to have been deleted"
+      end
+
+      def assert_session_operation_count(expected, type = nil, message = nil)
+        actual = server_session_store.operation_count(type)
+        type_desc = type ? " of type #{type}" : ""
+        assert_equal expected, actual,
+                     message || "Expected #{expected} session operations#{type_desc}, got #{actual}"
+      end
+
+      # Client session store assertions
+      def assert_client_session_saved(session_id, message = nil)
+        assert client_session_store.session_saved?(session_id),
+               message || "Expected client session #{session_id} to have been saved"
+      end
+
+      def assert_client_session_not_saved(session_id, message = nil)
+        assert_not client_session_store.session_saved?(session_id),
+                   message || "Expected client session #{session_id} not to have been saved"
+      end
+
+      def assert_client_session_loaded(session_id, message = nil)
+        assert client_session_store.session_loaded?(session_id),
+               message || "Expected client session #{session_id} to have been loaded"
+      end
+
+      def assert_client_session_not_loaded(session_id, message = nil)
+        assert_not client_session_store.session_loaded?(session_id),
+                   message || "Expected client session #{session_id} not to have been loaded"
+      end
+
+      def assert_client_session_updated(session_id, message = nil)
+        assert client_session_store.session_updated?(session_id),
+               message || "Expected client session #{session_id} to have been updated"
+      end
+
+      def assert_client_session_not_updated(session_id, message = nil)
+        assert_not client_session_store.session_updated?(session_id),
+                   message || "Expected client session #{session_id} not to have been updated"
+      end
+
+      def assert_client_session_deleted(session_id, message = nil)
+        assert client_session_store.session_deleted?(session_id),
+               message || "Expected client session #{session_id} to have been deleted"
+      end
+
+      def assert_client_session_not_deleted(session_id, message = nil)
+        assert_not client_session_store.session_deleted?(session_id),
+                   message || "Expected client session #{session_id} not to have been deleted"
+      end
+
+      def assert_client_session_operation_count(expected, type = nil, message = nil)
+        actual = client_session_store.operation_count(type)
+        type_desc = type ? " of type #{type}" : ""
+        assert_equal expected, actual,
+                     message || "Expected #{expected} client session operations#{type_desc}, got #{actual}"
+      end
+
+      def assert_client_session_data_includes(session_id, expected_data, message = nil)
+        saved_data = client_session_store.last_saved_data(session_id)
+        assert saved_data, "No saved data found for session #{session_id}"
+
+        expected_data.each do |key, value|
+          assert_equal value, saved_data[key],
+                       message || "Expected session #{session_id} data to include #{key}: #{value}"
+        end
+      end
+
+      private
+
+      def server_session_store
+        store = ActionMCP::Server.session_store
+        raise "Server session store is not a TestSessionStore" unless store.is_a?(ActionMCP::Server::TestSessionStore)
+        store
+      end
+
+      def client_session_store
+        # This would need to be set by the test or could use a thread-local variable
+        # For now, we'll assume it's available as an instance variable
+        store = @client_session_store || Thread.current[:test_client_session_store]
+        raise "Client session store not set. Set @client_session_store or Thread.current[:test_client_session_store]" unless store
+        raise "Client session store is not a TestSessionStore" unless store.is_a?(ActionMCP::Client::TestSessionStore)
+        store
+      end
+    end
+  end
+end

data/lib/action_mcp/test_helper.rb

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
 
 require "active_support/testing/assertions"
+require_relative "test_helper/session_store_assertions"
+require_relative "test_helper/progress_notification_assertions"
 
 module ActionMCP
   #---------------------------------------------------------------------------
@@ -23,6 +25,8 @@ module ActionMCP
   #---------------------------------------------------------------------------
   module TestHelper
     include ActiveSupport::Testing::Assertions
+    include SessionStoreAssertions
+    include ProgressNotificationAssertions
 
     # ──── Registry assertions ────────────────────────────────────────────────
     def assert_mcp_tool_findable(name, msg = nil)

data/lib/action_mcp/tool.rb

@@ -7,6 +7,7 @@ module ActionMCP
   # Tools are registered automatically in the ToolsRegistry unless marked as abstract.
   class Tool < Capability
     include ActionMCP::Callbacks
+    include ActionMCP::CurrentHelpers
     # --------------------------------------------------------------------------
     # Class Attributes for Tool Metadata and Schema
     # --------------------------------------------------------------------------

data/lib/action_mcp/version.rb

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

data/lib/action_mcp.rb

@@ -8,7 +8,6 @@ require "concurrent"
 require "active_record/railtie"
 require "jsonrpc-rails"
 require "action_controller/railtie"
-require "action_cable/engine"
 require "action_mcp/configuration"
 require "action_mcp/log_subscriber"
 require "action_mcp/engine"

data/lib/generators/action_mcp/install/install_generator.rb

@@ -23,6 +23,10 @@ module ActionMcp
       def create_mcp_profile_file
         template "mcp.yml", File.join("config", "mcp.yml")
       end
+
+      def create_application_gateway_file
+        template "application_gateway.rb", File.join("app/mcp", "application_gateway.rb")
+      end
     end
   end
 end

data/lib/generators/action_mcp/install/templates/application_gateway.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+class ApplicationGateway < ActionMCP::Gateway
+  # Specify what attributes identify a connection
+  # Multiple identifiers can be used (e.g., user, account, organization)
+  identified_by :user
+
+  protected
+
+  # Override this method to implement your authentication logic
+  # Must return a hash with keys matching the identified_by attributes
+  # or raise ActionMCP::UnauthorizedError
+  def authenticate!
+    # Example using JWT:
+    token = extract_bearer_token
+    raise ActionMCP::UnauthorizedError, "Missing token" unless token
+
+    payload = ActionMCP::JwtDecoder.decode(token)
+    user = resolve_user(payload)
+
+    raise ActionMCP::UnauthorizedError, "Unauthorized" unless user
+
+    # Return a hash with all identified_by attributes
+    { user: user }
+  rescue ActionMCP::JwtDecoder::DecodeError => e
+    raise ActionMCP::UnauthorizedError, e.message
+  end
+
+  private
+
+  # Example method to resolve user from JWT payload
+  def resolve_user(payload)
+    return nil unless payload.is_a?(Hash)
+    user_id = payload["user_id"] || payload["sub"]
+    return nil unless user_id
+
+    # Replace with your User model lookup
+    User.find_by(id: user_id)
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: actionmcp
 version: !ruby/object:Gem::Version
-  version: 0.51.0
+  version: 0.52.0
 platform: ruby
 authors:
 - Abdelkader Boudih
@@ -93,6 +93,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '2.6'
+- !ruby/object:Gem::Dependency
+  name: jwt
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.10'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.10'
 description: It offers base classes and helpers for creating MCP applications, making
   it easier to integrate your Ruby/Rails application with the MCP standard
 email:
@@ -150,13 +164,17 @@ files:
 - lib/action_mcp/content/image.rb
 - lib/action_mcp/content/resource.rb
 - lib/action_mcp/content/text.rb
+- lib/action_mcp/current.rb
+- lib/action_mcp/current_helpers.rb
 - lib/action_mcp/engine.rb
+- lib/action_mcp/gateway.rb
 - lib/action_mcp/gem_version.rb
 - lib/action_mcp/instrumentation/controller_runtime.rb
 - lib/action_mcp/instrumentation/instrumentation.rb
 - lib/action_mcp/instrumentation/resource_instrumentation.rb
 - lib/action_mcp/integer_array.rb
 - lib/action_mcp/json_rpc_handler_base.rb
+- lib/action_mcp/jwt_decoder.rb
 - lib/action_mcp/log_subscriber.rb
 - lib/action_mcp/logging.rb
 - lib/action_mcp/prompt.rb
@@ -169,6 +187,7 @@ files:
 - lib/action_mcp/resource_template.rb
 - lib/action_mcp/resource_templates_registry.rb
 - lib/action_mcp/server.rb
+- lib/action_mcp/server/base_messaging.rb
 - lib/action_mcp/server/capabilities.rb
 - lib/action_mcp/server/configuration.rb
 - lib/action_mcp/server/error_aware.rb
@@ -182,9 +201,11 @@ files:
 - lib/action_mcp/server/prompts.rb
 - lib/action_mcp/server/registry_management.rb
 - lib/action_mcp/server/resources.rb
+- lib/action_mcp/server/response_collector.rb
 - lib/action_mcp/server/roots.rb
 - lib/action_mcp/server/sampling.rb
 - lib/action_mcp/server/sampling_request.rb
+- lib/action_mcp/server/session_store.rb
 - lib/action_mcp/server/simple_pub_sub.rb
 - lib/action_mcp/server/solid_cable_adapter.rb
 - lib/action_mcp/server/tools.rb
@@ -193,6 +214,8 @@ files:
 - lib/action_mcp/string_array.rb
 - lib/action_mcp/tagged_stream_logging.rb
 - lib/action_mcp/test_helper.rb
+- lib/action_mcp/test_helper/progress_notification_assertions.rb
+- lib/action_mcp/test_helper/session_store_assertions.rb
 - lib/action_mcp/tool.rb
 - lib/action_mcp/tool_response.rb
 - lib/action_mcp/tools_registry.rb
@@ -203,6 +226,7 @@ files:
 - lib/generators/action_mcp/config/config_generator.rb
 - lib/generators/action_mcp/config/templates/mcp.yml
 - lib/generators/action_mcp/install/install_generator.rb
+- lib/generators/action_mcp/install/templates/application_gateway.rb
 - lib/generators/action_mcp/install/templates/application_mcp_prompt.rb
 - lib/generators/action_mcp/install/templates/application_mcp_res_template.rb
 - lib/generators/action_mcp/install/templates/application_mcp_tool.rb