actionmcp 0.50.13 → 0.52.0

data/lib/action_mcp/configuration.rb

@@ -1,5 +1,8 @@
 # frozen_string_literal: true
 
+require_relative "gateway"
+require "active_support/core_ext/integer/time"
+
 module ActionMCP
   # Configuration class to hold settings for the ActionMCP server.
   class Configuration
@@ -30,7 +33,12 @@ module ActionMCP
                   :vibed_ignore_version,
                   # --- SSE Resumability Options ---
                   :sse_event_retention_period,
-                  :max_stored_sse_events
+                  :max_stored_sse_events,
+                  # --- Gateway Options ---
+                  :gateway_class,
+                  :current_class,
+                  # --- Session Store Options ---
+                  :session_store_type
 
     def initialize
       @logging_enabled = true
@@ -47,6 +55,13 @@ module ActionMCP
       # Resumability defaults
       @sse_event_retention_period = 15.minutes
       @max_stored_sse_events = 100
+
+      # Gateway - default to ApplicationGateway if it exists, otherwise ActionMCP::Gateway
+      @gateway_class = defined?(::ApplicationGateway) ? ::ApplicationGateway : ActionMCP::Gateway
+      @current_class = nil
+
+      # Session Store
+      @session_store_type = Rails.env.production? ? :active_record : :volatile
     end
 
     def name

data/lib/action_mcp/current.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module ActionMCP
+  class Current < ActiveSupport::CurrentAttributes
+    attribute :user
+    attribute :gateway
+
+    def user=(user)
+      super
+      set_user_time_zone if user.respond_to?(:time_zone)
+    end
+
+    private
+
+    def set_user_time_zone
+      Time.zone = user.time_zone
+    end
+  end
+end

data/lib/action_mcp/current_helpers.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module ActionMCP
+  module CurrentHelpers
+    extend ActiveSupport::Concern
+
+    protected
+
+    # Access the current user from ActionMCP::Current
+    def current_user
+      ActionMCP::Current.user
+    end
+
+    # Access the current gateway from ActionMCP::Current
+    def current_gateway
+      ActionMCP::Current.gateway
+    end
+  end
+end

data/lib/action_mcp/gateway.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module ActionMCP
+  class UnauthorizedError < StandardError; end
+
+  class Gateway
+    class << self
+      def identified_by(*attrs)
+        @identifiers ||= []
+        @identifiers.concat(attrs.map(&:to_sym)).uniq!
+        attr_accessor(*attrs)
+      end
+
+      def identifiers
+        @identifiers ||= []
+      end
+    end
+
+    identified_by :user
+
+    attr_reader :request
+
+    def call(request)
+      @request = request
+      connect
+      self
+    end
+
+    def connect
+      identities = authenticate!
+      reject_unauthorized_connection unless identities.is_a?(Hash)
+
+      # Assign all identities (e.g., :user, :account)
+      self.class.identifiers.each do |id|
+        value = identities[id]
+        reject_unauthorized_connection unless value
+
+        public_send("#{id}=", value)
+
+        # Set to ActionMCP::Current
+        ActionMCP::Current.public_send("#{id}=", value)
+      end
+
+      # Also set the gateway instance itself
+      ActionMCP::Current.gateway = self
+    end
+
+
+    protected
+
+    def authenticate!
+      token = extract_bearer_token
+      raise UnauthorizedError, "Missing token" unless token
+
+      payload = ActionMCP::JwtDecoder.decode(token)
+      resolve_user(payload)
+    rescue ActionMCP::JwtDecoder::DecodeError => e
+      raise UnauthorizedError, e.message
+    end
+
+    def extract_bearer_token
+      header = request.headers["Authorization"] || request.headers["authorization"]
+      return nil unless header&.start_with?("Bearer ")
+      header.split(" ", 2).last
+    end
+
+    def resolve_user(payload)
+      return nil unless payload.is_a?(Hash)
+      user_id = payload["user_id"] || payload["sub"]
+      return nil unless user_id
+      user = User.find_by(id: user_id)
+      return nil unless user
+
+      # Return a hash with all identified_by attributes
+      self.class.identifiers.each_with_object({}) do |identifier, hash|
+        hash[identifier] = user if identifier == :user
+        # Add support for other identifiers as needed
+      end
+    end
+
+    def reject_unauthorized_connection
+      raise UnauthorizedError, "Unauthorized"
+    end
+  end
+end

data/lib/action_mcp/json_rpc_handler_base.rb

@@ -51,13 +51,18 @@ module ActionMCP
     # @param rpc_method [String]
     # @param id [String, Integer]
     # @param params [Hash]
-    # @return [Boolean] true if handled, false otherwise
+    # @return [JSON_RPC::Response, nil] Response if handled, nil otherwise
     def handle_common_methods(rpc_method, id, params)
       case rpc_method
       when Methods::PING
         transport.send_pong(id)
+        # In return mode, get the response that was just created
+        transport.messaging_mode == :return ? transport.get_last_response : true
       when %r{^notifications/}
         process_notifications(rpc_method, params)
+        true
+      else
+        nil
       end
     end
 

data/lib/action_mcp/jwt_decoder.rb

@@ -0,0 +1,26 @@
+require "jwt"
+
+module ActionMCP
+  class JwtDecoder
+    class DecodeError < StandardError; end
+
+    # Configurable defaults
+    class << self
+      attr_accessor :secret, :algorithm
+
+      def decode(token)
+        payload, _header = JWT.decode(token, secret, true, { algorithm: algorithm })
+        payload
+      rescue JWT::ExpiredSignature
+        raise DecodeError, "Token has expired"
+      rescue JWT::DecodeError => e
+        # Simplify the error message for invalid tokens
+        raise DecodeError, "Invalid token"
+      end
+    end
+
+    # Defaults (can be overridden in an initializer)
+    self.secret = ENV.fetch("ACTION_MCP_JWT_SECRET") { "change-me" }
+    self.algorithm = "HS256"
+  end
+end

data/lib/action_mcp/prompt.rb

@@ -4,6 +4,7 @@ module ActionMCP
   # Abstract base class for Prompts
   class Prompt < Capability
     include ActionMCP::Callbacks
+    include ActionMCP::CurrentHelpers
     class_attribute :_argument_definitions, instance_accessor: false, default: []
 
     # ---------------------------------------------------

data/lib/action_mcp/resource_template.rb

@@ -10,6 +10,7 @@ module ActionMCP
     include ResourceCallbacks
     include Logging
     include UriAmbiguityChecker
+    include CurrentHelpers
 
     # Track all registered templates
     @registered_templates = []

data/lib/action_mcp/server/base_messaging.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module ActionMCP
+  module Server
+    # Base messaging functionality
+    module BaseMessaging
+      private
+
+      def write_message(data)
+        session.write(data)
+      end
+    end
+  end
+end

data/lib/action_mcp/server/capabilities.rb

@@ -13,6 +13,7 @@ module ActionMCP
         client_protocol_version = params["protocolVersion"]
         client_info = params["clientInfo"]
         client_capabilities = params["capabilities"]
+        session_id = params["sessionId"]
 
         unless client_protocol_version.is_a?(String) && client_protocol_version.present?
           return send_jsonrpc_error(request_id, :invalid_params, "Missing or invalid 'protocolVersion'")
@@ -32,6 +33,28 @@ module ActionMCP
           return send_jsonrpc_error(request_id, :invalid_params, "Missing or invalid 'capabilities'")
         end
 
+        # Handle session resumption if sessionId provided
+        if session_id
+          existing_session = ActionMCP::Session.find_by(id: session_id)
+          if existing_session && existing_session.initialized?
+            # Resume existing session - update transport reference
+            transport.instance_variable_set(:@session, existing_session)
+            Rails.logger.info("Resuming existing session: #{session_id}")
+
+            # Return existing session info
+            capabilities_payload = existing_session.server_capabilities_payload
+            capabilities_payload[:protocolVersion] = if ActionMCP.configuration.vibed_ignore_version
+                                                       PROTOCOL_VERSION
+            else
+                                                       client_protocol_version
+            end
+            return send_jsonrpc_response(request_id, result: capabilities_payload)
+          else
+            Rails.logger.warn("Session #{session_id} not found or not initialized, creating new session")
+          end
+        end
+
+        # Create new session if not resuming
         session.store_client_info(client_info)
         session.store_client_capabilities(client_capabilities)
         session.set_protocol_version(client_protocol_version)

data/lib/action_mcp/server/error_aware.rb

@@ -24,7 +24,14 @@ module ActionMCP
       def with_error_handling(request_id)
         yield
       rescue JSON_RPC::JsonRpcError => e
-        error_response(request_id, e)
+        if transport.messaging_mode == :return
+          response = error_response(request_id, e)
+          transport.write_message(response)
+          response
+        else
+          transport.send_jsonrpc_response(request_id, error: e)
+          nil
+        end
       end
     end
   end

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

@@ -36,7 +36,8 @@ module ActionMCP
         def handle_tools_call(id, params)
           name = validate_required_param(params, "name", "Tool name is required")
           arguments = extract_arguments(params)
-          transport.send_tools_call(id, name, arguments)
+          _meta = params["_meta"] || params[:_meta] || {}
+          transport.send_tools_call(id, name, arguments, _meta)
         end
 
         def extract_arguments(params)

data/lib/action_mcp/server/json_rpc_handler.rb

@@ -31,11 +31,18 @@ module ActionMCP
         rpc_method = request.method
         params = request.params
 
-        with_error_handling(id) do
-          common_method = handle_common_methods(rpc_method, id, params)
-          return common_method if common_method
-          route_to_handler(rpc_method, id, params)
+        result = with_error_handling(id) do
+          common_result = handle_common_methods(rpc_method, id, params)
+          if common_result
+            common_result
+          else
+            route_to_handler(rpc_method, id, params)
+            # In return mode, get the last response that was collected
+            transport.messaging_mode == :return ? transport.get_last_response : nil
+          end
         end
+
+        result
       end
 
       def route_to_handler(rpc_method, id, params)
@@ -64,6 +71,7 @@ module ActionMCP
         params = notification.params || {}
 
         process_notifications(method_name, params)
+        # Notifications don't expect a response
         nil
       end
 

data/lib/action_mcp/server/messaging.rb

@@ -3,6 +3,11 @@
 module ActionMCP
   module Server
     module Messaging
+      # Operation mode for the messaging module
+      # :write - writes messages directly (default, for SSE)
+      # :return - returns messages without writing (for JSON responses)
+      attr_accessor :messaging_mode
+
       def send_jsonrpc_request(method, params: nil, id: SecureRandom.uuid_v7)
         send_message(:request, method: method, params: params, id: id)
       end
@@ -44,7 +49,13 @@ module ActionMCP
                     )
         end
 
-        write_message(message)
+        if messaging_mode == :return
+          write_message(message)  # This will be intercepted by ResponseCollector
+          message
+        else
+          write_message(message)
+          nil
+        end
       end
     end
   end

data/lib/action_mcp/server/registry_management.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-# lib/action_mcp/server/registry_management.rb
 module ActionMCP
   module Server
     module RegistryManagement

data/lib/action_mcp/server/response_collector.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module ActionMCP
+  module Server
+    # Module to collect responses when operating in :return mode
+    module ResponseCollector
+      attr_reader :collected_responses
+
+      def initialize_response_collector
+        @collected_responses = []
+      end
+
+      # Override write_message to collect responses instead of writing them
+      def write_message(message)
+        if messaging_mode == :return
+          @collected_responses ||= []
+          @collected_responses << message
+          message
+        else
+          super
+        end
+      end
+
+      # Get all collected responses
+      def get_collected_responses
+        @collected_responses || []
+      end
+
+      # Get the last response (useful for single request/response scenarios)
+      def get_last_response
+        @collected_responses&.last
+      end
+
+      # Clear collected responses
+      def clear_collected_responses
+        @collected_responses = []
+      end
+    end
+  end
+end