actionmcp 0.51.0 → 0.52.1

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/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