actionmcp 0.50.13 → 0.52.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a8cbc049b43ac92baf337a6700c1a31f3dc7a9a5bc6c63a245d845b26f40a6a4
-  data.tar.gz: e116ae134611daf77d0db8955325c4f3318ab27b7bec45ce77b1f4bdebdbc413
+  metadata.gz: 123d51b56f85e45cb622885fb6bfcf6caf6d310292302a6ad4a9886e84c36af2
+  data.tar.gz: 15eb5bd01e1985a4eac9c6d83b463d0f939c02ccd330f72366fa0d08603c6f2b
 SHA512:
-  metadata.gz: 0ca8d760b8758d6325da76b10ef9b94e76312538c1a0d4765a793944746f3f4b83bed4a843b9e0de6a5c10a4878e2cece3157386a056750fc9fe6d57543054b5
-  data.tar.gz: '0692acfc6b64ee7c3bb7047cc863dd2976e7aca7bb6c19e39a146ced044e1136c71364598f02b5cff9a3af803114a647692005150d758957c0db427366bed185'
+  metadata.gz: 724a4dc93cc887ce3dc735fe6a00b375a36012887f2aa081b01a45b314460a297ebd3b17cfa423a55276462cca5736feea816a8691fcc0b6006bfb7a385b0f9b
+  data.tar.gz: 451af9c7919a5e65d80af1f3cc3b36e666148bc4b1351049a7ae33e01fd26daaad13b5d72b6a32476e9709c8b44a0291c2ad304f25d9607c99082bf59d99db02

data/README.md

@@ -380,6 +380,89 @@ This will create `config/mcp.yml` with example configurations for all environmen
 
 > **Note:** Authentication and authorization are not included. You are responsible for securing the endpoint.
 
+## Authentication with Gateway
+
+ActionMCP provides a Gateway system similar to ActionCable's Connection for handling authentication. The Gateway allows you to authenticate users and make them available throughout your MCP components.
+
+### Creating an ApplicationGateway
+
+When you run the install generator, it creates an `ApplicationGateway` class:
+
+```ruby
+# app/mcp/application_gateway.rb
+class ApplicationGateway < ActionMCP::Gateway
+  # Specify what attributes identify a connection
+  identified_by :user
+
+  protected
+
+  def authenticate!
+    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 }
+  end
+
+  private
+
+  def resolve_user(payload)
+    user_id = payload["user_id"] || payload["sub"]
+    User.find_by(id: user_id) if user_id
+  end
+end
+```
+
+### Using Multiple Identifiers
+
+You can identify connections by multiple attributes:
+
+```ruby
+class ApplicationGateway < ActionMCP::Gateway
+  identified_by :user, :organization
+  
+  protected
+  
+  def authenticate!
+    # ... authentication logic ...
+    
+    { 
+      user: user,
+      organization: user.organization
+    }
+  end
+end
+```
+
+### Accessing Current User in Components
+
+Once authenticated, the current user (and other identifiers) are available in your tools, prompts, and resource templates:
+
+```ruby
+class MyTool < ApplicationMCPTool
+  def perform
+    # Access the authenticated user
+    if current_user
+      render text: "Hello, #{current_user.name}!"
+    else
+      render text: "Hi Stranger! It's been a while "
+    end
+  end
+end
+```
+
+### Current Attributes
+
+ActionMCP uses Rails' CurrentAttributes to store the authenticated context. The `ActionMCP::Current` class provides:
+- `ActionMCP::Current.user` - The authenticated user
+- `ActionMCP::Current.gateway` - The gateway instance
+- Any other attributes you define with `identified_by`
+
 ### 1. Create `mcp.ru`
 
 ```ruby

data/app/controllers/action_mcp/application_controller.rb

@@ -158,11 +158,11 @@ module ActionMCP
         response.headers[MCP_SESSION_ID_HEADER] = session.id
       end
 
-      transport_handler = Server::TransportHandler.new(session)
+      # Use return mode for the transport handler when we need to capture responses
+      transport_handler = Server::TransportHandler.new(session, messaging_mode: :return)
       json_rpc_handler = Server::JsonRpcHandler.new(transport_handler)
 
       result = json_rpc_handler.call(jsonrpc_params)
-
       process_handler_results(result, session, session_initially_missing, is_initialize_request)
     rescue ActionController::Live::ClientDisconnected, IOError => e
       Rails.logger.debug "Unified SSE (POST): Client disconnected during response: #{e.message}"
@@ -182,7 +182,7 @@ module ActionMCP
       session_id_from_header = extract_session_id
       return render_bad_request("Mcp-Session-Id header is required for DELETE requests.") unless session_id_from_header
 
-      session = Session.find_by(id: session_id_from_header)
+      session = Server.session_store.load_session(session_id_from_header)
       if session.nil?
         return render_not_found("Session not found.")
       elsif session.status == "closed"
@@ -206,7 +206,7 @@ module ActionMCP
     def find_or_initialize_session
       session_id = extract_session_id
       if session_id
-        session = Session.find_by(id: session_id)
+        session = Server.session_store.load_session(session_id)
         if session
           if ActionMCP.configuration.vibed_ignore_version
             if session.protocol_version != self.class::REQUIRED_PROTOCOL_VERSION
@@ -218,7 +218,7 @@ module ActionMCP
         end
         session
       else
-        Session.new(protocol_version: self.class::REQUIRED_PROTOCOL_VERSION)
+        Server.session_store.create_session(nil, protocol_version: self.class::REQUIRED_PROTOCOL_VERSION)
       end
     end
 
@@ -266,7 +266,13 @@ module ActionMCP
       end
 
       # Convert to hash for rendering
-      payload = result.message_json
+      payload = if result.respond_to?(:to_h)
+                  result.to_h
+      elsif result.respond_to?(:to_json)
+                  JSON.parse(result.to_json)
+      else
+                  result
+      end
 
       # Determine response format
       server_preference = ActionMCP.configuration.post_response_preference

data/app/models/action_mcp/session.rb

@@ -171,7 +171,11 @@ module ActionMCP
       )
 
       # Maintain cache limit by removing oldest events if needed
-      sse_events.order(event_id: :asc).limit(sse_events.count - max_events).destroy_all if sse_events.count > max_events
+      count = sse_events.count
+      excess = count - max_events
+      if excess.positive?
+        sse_events.order(event_id: :asc).limit(excess).delete_all
+      end
 
       event
     end

data/lib/action_mcp/client/base.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative "transport"
+
 module ActionMCP
   module Client
     # Base client class containing common MCP functionality
@@ -12,25 +14,20 @@ module ActionMCP
       include Roots
       include Logging
 
-      attr_reader :logger, :type,
+      attr_reader :logger, :transport,
                   :connection_error, :server,
                   :server_capabilities, :session,
                   :catalog, :blueprint,
                   :prompt_book, :toolbox
 
-      delegate :initialized?, to: :session
+      delegate :connected?, :ready?, to: :transport
 
-      def initialize(logger: ActionMCP.logger)
+      def initialize(transport:, logger: ActionMCP.logger, **options)
         @logger = logger
-        @connected = false
-        @session = Session.from_client.new(
-          protocol_version: PROTOCOL_VERSION,
-          client_info: client_info,
-          client_capabilities: client_capabilities
-        )
+        @transport = transport
+        @session = nil  # Session will be created/loaded based on server response
+        @session_id = options[:session_id]  # Optional session ID for resumption
         @server_capabilities = nil
-        @message_callback = nil
-        @error_callback = nil
         @connection_error = nil
         @initialized = false
 
@@ -42,148 +39,157 @@ module ActionMCP
         @prompt_book = PromptBook.new([], self)
         # Tool objects
         @toolbox = Toolbox.new([], self)
-      end
 
-      def connected?
-        @connected
+        setup_transport_callbacks
       end
 
-      # Connect to the MCP server, if something went wrong at initialization
+      # Connect to the MCP server
       def connect
-        return true if @connected
+        return true if connected?
 
         begin
-          log_debug("Connecting to MCP server...")
+          log_debug("Connecting to MCP server via #{transport.class.name}...")
           @connection_error = nil
 
-          # Start transport with proper error handling
-          success = start_transport
-
+          success = @transport.connect
           unless success
-            log_error("Failed to establish connection to MCP server")
+            log_error("Failed to establish transport connection")
             return false
           end
 
-          @connected = true
           log_debug("Connected to MCP server")
-
-          # Create handler only if it doesn't exist yet
-          @json_rpc_handler ||= JsonRpcHandler.new(session, self)
-
-          # Clear any existing message callback and set a new one
-          @message_callback = lambda do |response|
-            @json_rpc_handler.call(response)
-          end
-
           true
         rescue StandardError => e
           @connection_error = e.message
           log_error("Failed to connect to MCP server: #{e.message}")
-          @error_callback&.call(e)
           false
         end
       end
 
       # Disconnect from the MCP server
       def disconnect
-        return true unless @connected
+        return true unless connected?
 
         begin
-          stop_transport
-          @connected = false
+          @transport.disconnect
           log_debug("Disconnected from MCP server")
           true
         rescue StandardError => e
           log_error("Error disconnecting from MCP server: #{e.message}")
-          @error_callback&.call(e)
           false
         end
       end
 
-      # Set a callback for incoming messages
-      def on_message(&block)
-        @message_callback = block
-      end
-
-      # Set a callback for errors
-      def on_error(&block)
-        @error_callback = block
-      end
-
       # Send a request to the MCP server
       def write_message(payload)
-        unless @connected
-          log_error("Cannot send request - not connected")
+        unless ready?
+          log_error("Cannot send request - transport not ready")
           return false
         end
 
         begin
-          session.write(payload)
+          # Only write to session if it exists (after initialization)
+          session.write(payload) if session
           data = payload.to_json unless payload.is_a?(String)
-          send_message(data)
+          @transport.send_message(data)
           true
         rescue StandardError => e
           log_error("Failed to send request: #{e.message}")
-          @error_callback&.call(e)
           false
         end
       end
 
-      # Methods to be implemented by subclasses
-      def start_transport
-        raise NotImplementedError, "#{self.class} must implement #start_transport"
-      end
-
-      def stop_transport
-        raise NotImplementedError, "#{self.class} must implement #stop_transport"
-      end
-
-      def send_message(json)
-        raise NotImplementedError, "#{self.class} must implement #send_message"
-      end
-
-      def ready?
-        raise NotImplementedError, "#{self.class} must implement #ready?"
-      end
-
       def server=(server)
         @server = if server.is_a?(Client::Server)
                     server
         else
                     Client::Server.new(server)
         end
-        session.server_capabilities = server.capabilities
-        session.server_info = server.server_info
-        session.save
+
+        # Only update session if it exists
+        if @session
+          @session.server_capabilities = server.capabilities
+          @session.server_info = server.server_info
+          @session.save
+        end
+      end
+
+      def initialized?
+        @initialized && @session&.initialized?
       end
 
       def inspect
-        "#<#{self.class.name} server: #{server}, client_name: #{client_info[:name]}, client_version: #{client_info[:version]}, capabilities: #{client_capabilities} , connected: #{connected?}, initialized: #{initialized?}, session: #{session.id}>"
+        session_info = @session ? "session: #{@session.id}" : "session: none"
+        "#<#{self.class.name} transport: #{transport.class.name}, server: #{server}, client_name: #{client_info[:name]}, client_version: #{client_info[:version]}, capabilities: #{client_capabilities}, connected: #{connected?}, initialized: #{initialized?}, #{session_info}>"
       end
 
       protected
 
+      def setup_transport_callbacks
+        # Create JSON-RPC handler
+        @json_rpc_handler = JsonRpcHandler.new(session, self)
+
+        # Set up transport callbacks
+        @transport.on_message do |message|
+          handle_raw_message(message)
+        end
+
+        @transport.on_error do |error|
+          handle_transport_error(error)
+        end
+
+        @transport.on_connect do
+          handle_transport_connect
+        end
+
+        @transport.on_disconnect do
+          handle_transport_disconnect
+        end
+      end
+
       def handle_raw_message(raw)
-        @message_callback&.call(raw)
+        @json_rpc_handler.call(raw)
       rescue MultiJson::ParseError => e
         log_error("JSON parse error: #{e} (raw: #{raw})")
-        @error_callback&.call(e)
       rescue StandardError => e
         log_error("Error handling message: #{e} (raw: #{raw})")
-        @error_callback&.call(e)
+      end
+
+      def handle_transport_error(error)
+        @connection_error = error.message
+        log_error("Transport error: #{error.message}")
+      end
+
+      def handle_transport_connect
+        log_debug("Transport connected")
+        # Send initial capabilities after connection
+        send_initial_capabilities
+      end
+
+      def handle_transport_disconnect
+        log_debug("Transport disconnected")
       end
 
       def send_initial_capabilities
         log_debug("Sending client capabilities")
-        # We have contact! Let's send our CV to the recruiter.
-        # We persist the session object to the database
-        session.save
+
+        # If we have a session_id, we're trying to resume
+        if @session_id
+          log_debug("Attempting to resume session: #{@session_id}")
+        end
+
         params = {
-          protocolVersion: session.protocol_version,
-          capabilities: session.client_capabilities,
-          clientInfo: session.client_info
+          protocolVersion: PROTOCOL_VERSION,
+          capabilities: client_capabilities,
+          clientInfo: client_info
         }
-        send_jsonrpc_request("initialize", params: params, id: session.id)
+
+        # Include session_id if we're trying to resume
+        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
+        send_jsonrpc_request("initialize", params: params, id: request_id)
       end
 
       def client_capabilities

data/lib/action_mcp/client/json_rpc_handler.rb

@@ -70,13 +70,16 @@ module ActionMCP
       end
 
       def process_response(id, result)
-        if transport.id == id
-          ## This initializes the transport
-          client.server = Client::Server.new(result)
+        # Check if this is a response to an initialize request
+        # We need to check the actual request method, not just compare IDs
+        request = client.session ? transport.messages.requests.find_by(jsonrpc_id: id) : nil
+
+        # If no session yet, this might be the initialize response
+        if !client.session && result["serverInfo"]
+          handle_initialize_response(id, result)
           return send_initialized_notification
         end
 
-        request = transport.messages.requests.find_by(jsonrpc_id: id)
         return unless request
 
         # Mark the request as acknowledged
@@ -113,8 +116,42 @@ module ActionMCP
         puts "\e[31mUnknown error: #{id} #{error}\e[0m"
       end
 
+      def handle_initialize_response(request_id, result)
+        # Session ID comes from HTTP headers, not the response body
+        # The transport should have already extracted it
+        session_id = transport.instance_variable_get(:@session_id)
+
+        if session_id.nil?
+          client.log_error("No session ID received from server")
+          return
+        end
+
+        # Check if we're resuming an existing session
+        if client.instance_variable_get(:@session_id) && session_id == client.instance_variable_get(:@session_id)
+          # We're resuming an existing session
+          client.instance_variable_set(:@session, ActionMCP::Session.find(session_id))
+          client.log_info("Resumed existing session: #{session_id}")
+        else
+          # Create a new session with the server-provided ID
+          client.instance_variable_set(:@session, ActionMCP::Session.from_client.new(
+            id: session_id,
+            protocol_version: result["protocolVersion"] || PROTOCOL_VERSION,
+            client_info: client.client_info,
+            client_capabilities: client.client_capabilities,
+            server_info: result["serverInfo"],
+            server_capabilities: result["capabilities"]
+          ))
+          client.session.save
+          client.log_info("Created new session: #{session_id}")
+        end
+
+        # Set the server info
+        client.server = Client::Server.new(result)
+        client.instance_variable_set(:@initialized, true)
+      end
+
       def send_initialized_notification
-        transport.initialize!
+        transport.initialize! if transport.respond_to?(:initialize!)
         client.send_jsonrpc_notification("notifications/initialized")
       end
     end