actionmcp 0.102.0 → 0.104.0

data/lib/action_mcp/client/collection.rb

@@ -1,168 +0,0 @@
-# frozen_string_literal: true
-
-module ActionMCP
-  module Client
-    # Base collection class for MCP client collections
-    class Collection
-      include RequestTimeouts
-
-      attr_reader :client, :loaded, :next_cursor, :total
-
-      def initialize(items, client, silence_sql: true)
-        @collection_data = items || []
-        @client = client
-        @loaded = !@collection_data.empty?
-        @silence_sql = silence_sql
-        @next_cursor = nil
-        @total = items&.size || 0
-      end
-
-      def all(limit: nil)
-        if limit
-          # If a limit is provided, use pagination
-          result = []
-          each_page(limit: limit) { |page| result.concat(page) }
-          result
-        else
-          # Otherwise, maintain the old behavior
-          silence_logs { load_items unless @loaded }
-          @collection_data
-        end
-      end
-
-      def all!(timeout: DEFAULT_TIMEOUT)
-        silence_logs { load_items(force: true, timeout: timeout) }
-        @collection_data
-      end
-
-      # Fetch a single page of results
-      #
-      # @param cursor [String, nil] Optional cursor for pagination
-      # @param limit [Integer, nil] Optional limit for page size
-      # @return [Array<Object>] The page of items
-      def page(cursor: nil, limit: nil)
-        silence_logs { load_page(cursor: cursor, limit: limit) }
-        @collection_data
-      end
-
-      # Check if there are more pages available
-      #
-      # @return [Boolean] true if there are more pages to fetch
-      def has_more_pages?
-        !@next_cursor.nil?
-      end
-
-      # Fetch the next page of results
-      #
-      # @param limit [Integer, nil] Optional limit for page size
-      # @return [Array<Object>] The next page of items, or empty array if no more pages
-      def next_page(limit: nil)
-        return [] unless has_more_pages?
-
-        page(cursor: @next_cursor, limit: limit)
-      end
-
-      # Iterate through all pages of results
-      #
-      # @param limit [Integer, nil] Optional limit for page size
-      # @yield [page] Block to process each page
-      # @yieldparam page [Array<Object>] A page of items
-      def each_page(limit: nil)
-        return unless block_given?
-
-        current_page = page(limit: limit)
-        yield current_page
-
-        while has_more_pages?
-          current_page = next_page(limit: limit)
-          yield current_page unless current_page.empty?
-        end
-      end
-
-      # Filter items based on a given block
-      #
-      # @yield [item] Block that determines whether to include an item
-      # @yieldparam item [Object] An item from the collection
-      # @yieldreturn [Boolean] true to include the item, false to exclude it
-      # @return [Array<Object>] Items that match the filter criteria
-      def filter(&block)
-        all.select(&block)
-      end
-
-      # Number of items in the collection
-      #
-      # @return [Integer] The number of items
-      def size
-        all.size
-      end
-
-      # Implements enumerable functionality
-      include Enumerable
-
-      def each(&block)
-        all.each(&block)
-      end
-
-      alias loaded? loaded
-
-      protected
-
-      def load_items(force: false, timeout: DEFAULT_TIMEOUT)
-        return if @loaded && !force
-
-        # Make sure @load_method is defined in the subclass
-        raise NotImplementedError, "Subclass must define @load_method" unless defined?(@load_method)
-
-        # Use the RequestTimeouts module to handle the request
-        load_with_timeout(@load_method, force: force, timeout: timeout)
-      end
-
-      def load_page(cursor: nil, limit: nil, timeout: DEFAULT_TIMEOUT)
-        # Make sure @load_method is defined in the subclass
-        raise NotImplementedError, "Subclass must define @load_method" unless defined?(@load_method)
-
-        # Use the RequestTimeouts module to handle the request with pagination params
-        params = {}
-        params[:cursor] = cursor if cursor
-        params[:limit] = limit if limit
-
-        client.send(@load_method, params)
-
-        start_time = Time.now
-        sleep(0.1) while !@loaded && (Time.now - start_time) < timeout
-
-        # Update @loaded status even if we timed out
-        @loaded = true
-
-        # Return the loaded data
-        @collection_data
-      end
-
-      private
-
-      def silence_logs
-        return yield unless @silence_sql
-
-        original_log_level = ActionMCP::Session.logger&.level
-        begin
-          # Temporarily increase log level to suppress SQL queries
-          ActionMCP::Session.logger.level = Logger::WARN if ActionMCP::Session.logger
-          yield
-        ensure
-          # Restore original log level
-          ActionMCP::Session.logger.level = original_log_level if ActionMCP::Session.logger && original_log_level
-        end
-      end
-
-      def log_error(message)
-        # Safely handle logging - don't assume Rails.logger exists
-        if defined?(Rails) && Rails.respond_to?(:logger) && Rails.logger
-          Rails.logger.error("[#{self.class.name}] #{message}")
-        else
-          # Fall back to puts if Rails.logger is not available
-          puts "[ERROR] [#{self.class.name}] #{message}"
-        end
-      end
-    end
-  end
-end

data/lib/action_mcp/client/elicitation.rb

@@ -1,34 +0,0 @@
-# frozen_string_literal: true
-
-module ActionMCP
-  module Client
-    # Handles elicitation requests from servers
-    module Elicitation
-      # Process elicitation request from server
-      # @param id [String, Integer] The request ID
-      # @param params [Hash] The elicitation parameters
-      def process_elicitation_request(id, params)
-        params["message"]
-        params["requestedSchema"]
-
-        # In a real implementation, this would prompt the user
-        # For now, we'll just return a decline response
-        # Actual implementations should override this method
-        send_jsonrpc_response(id, result: {
-                                action: "decline"
-                              })
-      end
-
-      # Send elicitation response
-      # @param id [String, Integer] The request ID
-      # @param action [String] The action taken ("accept", "decline", "cancel")
-      # @param content [Hash, nil] The form data if action is "accept"
-      def send_elicitation_response(id, action:, content: nil)
-        result = { action: action }
-        result[:content] = content if action == "accept" && content
-
-        send_jsonrpc_response(id, result: result)
-      end
-    end
-  end
-end

data/lib/action_mcp/client/json_rpc_handler.rb

@@ -1,202 +0,0 @@
-# frozen_string_literal: true
-
-module ActionMCP
-  module Client
-    class JsonRpcHandler < JsonRpcHandlerBase
-      attr_reader :client
-
-      def initialize(transport, client)
-        super(transport)
-        @client = client
-      end
-
-      # Handle client-side JSON-RPC requests/responses
-      # @param request [JSON_RPC::Request, JSON_RPC::Notification, JSON_RPC::Response]
-      def call(request)
-        case request
-        when JSON_RPC::Request
-          handle_request(request)
-        when JSON_RPC::Notification
-          handle_notification(request)
-        when JSON_RPC::Response
-          handle_response(request)
-        end
-      end
-
-      private
-
-      def handle_request(request)
-        id = request.id
-        rpc_method = request.method
-        params = request.params
-
-        handle_method(rpc_method, id, params)
-      end
-
-      def handle_notification(notification)
-        # Handle server notifications to client
-        client.log_debug("Received notification: #{notification.method}")
-      end
-
-      def handle_response(response)
-        # Handle server responses to client requests
-        client.log_debug("Received response: #{response.id} - #{response.result ? 'success' : 'error'}")
-      end
-
-      protected
-
-      # Handle client-specific methods
-      # @param rpc_method [String]
-      # @param id [String, Integer]
-      # @param params [Hash]
-      def handle_method(rpc_method, id, params)
-        case rpc_method
-        when Methods::ELICITATION_CREATE
-          client.process_elicitation_request(id, params)
-        when %r{^roots/}
-          process_roots(rpc_method, id)
-        when %r{^sampling/}
-          process_sampling(rpc_method, id, params)
-        else
-          common_result = handle_common_methods(rpc_method, id, params)
-          client.log_warn("Unknown server method: #{rpc_method} #{id} #{params}") if common_result.nil?
-        end
-      end
-
-      # @param rpc_method [String]
-      # @param id [String]
-      def process_roots(rpc_method, id)
-        case rpc_method
-        when "roots/list" # List available roots
-          transport.send_roots_list(id)
-        else
-          Rails.logger.warn("Unknown roots method: #{rpc_method}")
-        end
-      end
-
-      # @param rpc_method [String]
-      # @param id [String]
-      # @param params [Hash]
-      def process_sampling(rpc_method, id, params)
-        case rpc_method
-        when "sampling/createMessage" # Create a message using AI
-          # @param id [String]
-          # @param params [SamplingRequest]
-          transport.send_sampling_create_message(id, params)
-        else
-          Rails.logger.warn("Unknown sampling method: #{rpc_method}")
-        end
-      end
-
-      # @param rpc_method [String]
-      def process_notifications(rpc_method, params)
-        case rpc_method
-        when "notifications/resources/updated" # Resource update notification
-          client.log_debug("Resource #{params['uri']} was updated")
-          # Handle resource update notification
-          # TODO: fetch updated resource or mark it as stale
-        when "notifications/tools/list_changed" # Tool list change notification
-          client.log_debug("Tool list has changed")
-          # Handle tool list change notification
-          # TODO: fetch new tools or mark them as stale
-        when "notifications/prompts/list_changed" # Prompt list change notification
-          client.log_debug("Prompt list has changed")
-          # Handle prompt list change notification
-          # TODO: fetch new prompts or mark them as stale
-        when "notifications/resources/list_changed" # Resource list change notification
-          client.log_debug("Resource list has changed")
-          # Handle resource list change notification
-          # TODO: fetch new resources or mark them as stale
-        else
-          super
-        end
-      end
-
-      def process_response(id, 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
-
-        return unless request
-
-        # Mark the request as acknowledged
-        request.update(request_acknowledged: true)
-
-        case request.rpc_method
-        when "tools/list"
-          client.toolbox.tools = result["tools"]
-          client.toolbox.instance_variable_set(:@next_cursor, result["nextCursor"])
-          client.toolbox.instance_variable_set(:@total, result["tools"]&.size || 0)
-          return true
-        when "prompts/list"
-          client.prompt_book.prompts = result["prompts"]
-          client.prompt_book.instance_variable_set(:@next_cursor, result["nextCursor"])
-          client.prompt_book.instance_variable_set(:@total, result["prompts"]&.size || 0)
-          return true
-        when "resources/list"
-          client.catalog.resources = result["resources"]
-          client.catalog.instance_variable_set(:@next_cursor, result["nextCursor"])
-          client.catalog.instance_variable_set(:@total, result["resources"]&.size || 0)
-          return true
-        when "resources/templates/list"
-          client.blueprint.templates = result["resourceTemplates"]
-          client.blueprint.instance_variable_set(:@next_cursor, result["nextCursor"])
-          client.blueprint.instance_variable_set(:@total, result["resourceTemplates"]&.size || 0)
-          return true
-        end
-
-        client.log_warn("Unknown response: #{id} #{result}")
-      end
-
-      def process_error(id, error)
-        # Do something ?
-        client.log_error("Unknown error: #{id} #{error}")
-      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"] || ActionMCP::DEFAULT_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! if transport.respond_to?(:initialize!)
-        client.send_jsonrpc_notification("notifications/initialized")
-      end
-    end
-  end
-end

data/lib/action_mcp/client/logging.rb

@@ -1,19 +0,0 @@
-# frozen_string_literal: true
-
-module ActionMCP
-  module Client
-    module Logging
-      # Set the client's logging level
-      # @param level [String] Logging level (debug, info, warning, error, etc.)
-      # @return [Boolean] Success status
-      def set_logging_level(level)
-        request_id = SecureRandom.uuid_v7
-
-        # Send request
-        send_jsonrpc_request("client/setLoggingLevel",
-                             params: { level: level },
-                             id: request_id)
-      end
-    end
-  end
-end

data/lib/action_mcp/client/messaging.rb

@@ -1,28 +0,0 @@
-# frozen_string_literal: true
-
-module ActionMCP
-  module Client
-    module Messaging
-      def send_jsonrpc_request(method, params: nil, id: SecureRandom.uuid_v7)
-        request = JSON_RPC::Request.new(id: id, method: method, params: params)
-        write_message(request)
-      end
-
-      def send_jsonrpc_response(request_id, result: nil, error: nil)
-        response = JSON_RPC::Response.new(id: request_id, result: result, error: error)
-        write_message(response)
-      end
-
-      def send_jsonrpc_notification(method, params = nil)
-        notification = JSON_RPC::Notification.new(method: method, params: params)
-        write_message(notification)
-      end
-
-      def send_jsonrpc_error(request_id, symbol, message, data = nil)
-        error = JSON_RPC::JsonRpcError.new(symbol, message:, data:)
-        response = JSON_RPC::Response.new(id: request_id, error:)
-        write_message(response)
-      end
-    end
-  end
-end

data/lib/action_mcp/client/prompt_book.rb

@@ -1,117 +0,0 @@
-# frozen_string_literal: true
-
-module ActionMCP
-  module Client
-    # PromptBook
-    #
-    # A collection that manages and provides access to prompt templates from the MCP server.
-    # The class stores prompt definitions along with their arguments and provides methods
-    # for retrieving, filtering, and accessing prompts. It supports lazy loading of prompts
-    # when initialized with a client.
-    #
-    # Example usage:
-    #   # Eager loading
-    #   prompts_data = client.list_prompts # Returns array of prompt definitions
-    #   book = PromptBook.new(prompts_data)
-    #
-    #   # Lazy loading
-    #   book = PromptBook.new([], client)
-    #   prompts = book.all # Prompts are loaded here
-    #
-    #   # Access a specific prompt by name
-    #   summary_prompt = book.find("summarize_text")
-    #
-    #   # Get all prompts matching a criteria
-    #   text_prompts = book.filter { |p| p.name.include?("text") }
-    #
-    class PromptBook < Collection
-      # Initialize a new PromptBook with prompt definitions
-      #
-      # @param prompts [Array<Hash>] Array of prompt definition hashes, each containing
-      #   name, description, and arguments keys
-      # @param client [Object, nil] Optional client for lazy loading of prompts
-      def initialize(prompts, client)
-        super(prompts, client)
-        self.prompts = @collection_data
-        @load_method = :list_prompts
-      end
-
-      # Find a prompt by name
-      #
-      # @param name [String] Name of the prompt to find
-      # @return [Prompt, nil] The prompt with the given name, or nil if not found
-      def find(name)
-        all.find { |prompt| prompt.name == name }
-      end
-
-      # Get a list of all prompt names
-      #
-      # @return [Array<String>] Names of all prompts in the collection
-      def names
-        all.map(&:name)
-      end
-
-      # Check if the collection contains a prompt with the given name
-      #
-      # @param name [String] The prompt name to check for
-      # @return [Boolean] true if a prompt with the name exists
-      def contains?(name)
-        all.any? { |prompt| prompt.name == name }
-      end
-
-      # Convert raw prompt data into Prompt objects
-      #
-      # @param prompts [Array<Hash>] Array of prompt definition hashes
-      def prompts=(prompts)
-        @collection_data = prompts.map { |data| Prompt.new(data) }
-      end
-
-      # Internal Prompt class to represent individual prompts
-      class Prompt
-        attr_reader :name, :description, :arguments
-
-        # Initialize a new Prompt instance
-        #
-        # @param data [Hash] Prompt definition hash containing name, description, and arguments
-        def initialize(data)
-          @name = data["name"]
-          @description = data["description"]
-          @arguments = data["arguments"] || []
-        end
-
-        # Get all required arguments for this prompt
-        #
-        # @return [Array<Hash>] Array of argument hashes that are required
-        def required_arguments
-          @arguments.select { |arg| arg["required"] }
-        end
-
-        # Get all optional arguments for this prompt
-        #
-        # @return [Array<Hash>] Array of argument hashes that are optional
-        def optional_arguments
-          @arguments.reject { |arg| arg["required"] }
-        end
-
-        # Check if the prompt has a specific argument
-        #
-        # @param name [String] Name of the argument to check for
-        # @return [Boolean] true if the argument exists
-        def has_argument?(name)
-          @arguments.any? { |arg| arg["name"] == name }
-        end
-
-        # Generate a hash representation of the prompt
-        #
-        # @return [Hash] Hash containing prompt details
-        def to_h
-          {
-            "name" => @name,
-            "description" => @description,
-            "arguments" => @arguments
-          }
-        end
-      end
-    end
-  end
-end

data/lib/action_mcp/client/prompts.rb

@@ -1,47 +0,0 @@
-# frozen_string_literal: true
-
-module ActionMCP
-  module Client
-    module Prompts
-      # List all available prompts from the server
-      # @param params [Hash] Optional parameters for pagination
-      # @option params [String] :cursor Pagination cursor for fetching next page
-      # @option params [Integer] :limit Maximum number of items to return
-      # @return [String] Request ID for tracking the request
-      def list_prompts(params = {})
-        request_id = SecureRandom.uuid_v7
-
-        # Send request with pagination parameters if provided
-        request_params = {}
-        request_params[:cursor] = params[:cursor] if params[:cursor]
-        request_params[:limit] = params[:limit] if params[:limit]
-
-        send_jsonrpc_request("prompts/list",
-                             params: request_params.empty? ? nil : request_params,
-                             id: request_id)
-
-        # Return request ID for tracking the request
-        request_id
-      end
-
-      # Get a specific prompt with arguments
-      # @param name [String] Name of the prompt to get
-      # @param arguments [Hash] Arguments to pass to the prompt
-      # @return [String] Request ID for tracking the request
-      def get_prompt(name, arguments = {})
-        request_id = SecureRandom.uuid_v7
-
-        # Send request
-        send_jsonrpc_request("prompts/get",
-                             params: {
-                               name: name,
-                               arguments: arguments
-                             },
-                             id: request_id)
-
-        # Return request ID for tracking the request
-        request_id
-      end
-    end
-  end
-end

data/lib/action_mcp/client/request_timeouts.rb

@@ -1,74 +0,0 @@
-# frozen_string_literal: true
-
-module ActionMCP
-  module Client
-    module RequestTimeouts
-      # Default timeout in seconds
-      DEFAULT_TIMEOUT = 1.0
-
-      # Load resources with timeout support - blocking until response or timeout
-      # @param method_name [Symbol] The method to call for loading (e.g., :list_resources)
-      # @param force [Boolean] Whether to force reload even if already loaded
-      # @param timeout [Float] Timeout in seconds
-      # @return [Boolean] Success status
-      def load_with_timeout(method_name, force: false, timeout: DEFAULT_TIMEOUT)
-        return true if @loaded && !force
-
-        # Make the request and store its ID
-        request_id = client.send(method_name)
-
-        start_time = Time.now
-
-        # Wait until either:
-        # 1. The collection is loaded (@loaded becomes true from JsonRpcHandler)
-        # 2. The timeout is reached
-        sleep(0.1) while !@loaded && (Time.now - start_time) < timeout
-
-        # If we timed out
-        unless @loaded
-          request = client.session.messages.requests.find_by(jsonrpc_id: request_id)
-
-          if request && !request.request_acknowledged?
-            # Send cancel notification
-            client.send_jsonrpc_notification("notifications/cancelled", {
-                                               requestId: request_id,
-                                               reason: "Request timed out after #{timeout} seconds"
-                                             })
-
-            # Mark as cancelled in the database
-            request.update(request_cancelled: true)
-
-            log_error("Request #{method_name} timed out after #{timeout} seconds")
-          end
-
-          # Mark as loaded even though we timed out
-          @loaded = true
-          return false
-        end
-
-        # Collection was successfully loaded
-        true
-      end
-
-      private
-
-      def handle_timeout(request_id, method_name, timeout)
-        # Find the request
-        request = client.session.messages.requests.find_by(jsonrpc_id: request_id)
-
-        return unless request && !request.request_acknowledged?
-
-        # Send cancel notification
-        client.send_jsonrpc_notification("notifications/cancelled", {
-                                           requestId: request_id,
-                                           reason: "Request timed out after #{timeout} seconds"
-                                         })
-
-        # Mark as cancelled in the database
-        request.update(request_cancelled: true)
-
-        log_error("Request #{method_name} timed out after #{timeout} seconds")
-      end
-    end
-  end
-end