actionmcp 0.20.0 → 0.24.0

data/lib/action_mcp/client/collection.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+module ActionMCP
+  module Client
+    # Base collection class for MCP client collections
+    class Collection
+      include RequestTimeouts
+
+      attr_reader :client, :loaded
+
+      def initialize(items, client, silence_sql: true)
+        @collection_data = items || []
+        @client = client
+        @loaded = !(@collection_data.empty?)
+        @silence_sql = silence_sql
+      end
+
+      def all
+        silence_logs { load_items unless @loaded }
+        @collection_data
+      end
+
+      def all!(timeout: DEFAULT_TIMEOUT)
+        silence_logs { load_items(force: true, timeout: timeout) }
+        @collection_data
+      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
+
+      private
+
+      def silence_logs
+        return yield unless @silence_sql
+
+        original_log_level = Session.logger&.level
+        begin
+          # Temporarily increase log level to suppress SQL queries
+          Session.logger.level = Logger::WARN if Session.logger
+          yield
+        ensure
+          # Restore original log level
+          Session.logger.level = original_log_level if Session.logger
+        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/json_rpc_handler.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+module ActionMCP
+  module Client
+    class JsonRpcHandler < JsonRpcHandlerBase
+      attr_reader :client
+      def initialize(transport, client)
+        super(transport)
+        @client = client
+      end
+
+      protected
+
+      # Handle client-specific methods
+      # @param rpc_method [String]
+      # @param id [String, Integer]
+      # @param params [Hash]
+      def handle_method(rpc_method, id, params)
+        puts "\e[31mUnknown server method: #{rpc_method} #{id} #{params}\e[0m"
+      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
+          puts "\e[31m Resource #{params['uri']} was updated\e[0m"
+          # Handle resource update notification
+          # TODO: fetch updated resource or mark it as stale
+        when "notifications/tools/list_changed" # Tool list change notification
+          puts "\e[31m Tool list has changed\e[0m"
+          # Handle tool list change notification
+          # TODO: fetch new tools or mark them as stale
+        when "notifications/prompts/list_changed" # Prompt list change notification
+          puts "\e[31m Prompt list has changed\e[0m"
+          # Handle prompt list change notification
+          # TODO: fetch new prompts or mark them as stale
+        when "notifications/resources/list_changed" # Resource list change notification
+          puts "\e[31m Resource list has changed\e[0m"
+          # Handle resource list change notification
+          # TODO: fetch new resources or mark them as stale
+        else
+          super
+        end
+      end
+
+      def process_response(id, result)
+        if transport.id == id
+          ## This initializes the transport
+          client.server = Client::Server.new(result)
+          return send_initialized_notification
+        end
+
+        request = transport.messages.requests.find_by(jsonrpc_id: id)
+        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"]
+          return true
+        when "prompts/list"
+          client.prompt_book.prompts = result["prompts"]
+          return true
+        when "resources/list"
+          client.catalog.resources = result["resources"]
+          return true
+        when "resources/templates/list"
+          client.blueprint.templates = result["resourceTemplates"]
+          return true
+        end
+
+        puts "\e[31mUnknown response: #{id} #{result}\e[0m"
+      end
+
+      def process_error(id, error)
+        # Do something ?
+        puts "\e[31mUnknown error: #{id} #{error}\e[0m"
+      end
+
+
+      def send_initialized_notification
+        transport.initialize!
+        client.send_jsonrpc_notification("notifications/initialized")
+      end
+    end
+  end
+end

data/lib/action_mcp/client/logging.rb

@@ -0,0 +1,20 @@
+# 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/{transport → client}/messaging.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module ActionMCP
-  module Transport
+  module Client
     module Messaging
       def send_jsonrpc_request(method, params: nil, id: SecureRandom.uuid_v7)
         request = JsonRpc::Request.new(id: id, method: method, params: params)

data/lib/action_mcp/client/prompt_book.rb

@@ -0,0 +1,117 @@
+# 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

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module ActionMCP
+  module Client
+    module Prompts
+      # List all available prompts from the server
+      # @return [String] Request ID for tracking the request
+      def list_prompts
+        request_id = SecureRandom.uuid_v7
+
+        # Send request
+        send_jsonrpc_request("prompts/list", 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

@@ -0,0 +1,76 @@
+# 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
+        while !@loaded && (Time.now - start_time) < timeout
+          sleep(0.1)
+        end
+
+        # 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)
+
+        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
+      end
+    end
+  end
+end

data/lib/action_mcp/client/resources.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module ActionMCP
+  module Client
+    module Resources
+      # List all available resources from the server
+      # @return [String] Request ID for tracking the request
+      def list_resources
+        request_id = SecureRandom.uuid_v7
+
+        # Send request
+        send_jsonrpc_request("resources/list", id: request_id)
+
+        # Return request ID for tracking the request
+        request_id
+      end
+
+      # List resource templates from the server
+      # @return [String] Request ID for tracking the request
+      def list_resource_templates
+        request_id = SecureRandom.uuid_v7
+
+        # Send request
+        send_jsonrpc_request("resources/templates/list", id: request_id)
+
+        # Return request ID for tracking the request
+        request_id
+      end
+
+      # Read a specific resource
+      # @param uri [String] URI of the resource to read
+      # @return [String] Request ID for tracking the request
+      def read_resource(uri)
+        request_id = SecureRandom.uuid_v7
+
+        # Send request
+        send_jsonrpc_request("resources/read",
+                             params: { uri: uri },
+                             id: request_id
+        )
+
+        # Return request ID for tracking the request
+        request_id
+      end
+
+      # Subscribe to updates for a specific resource
+      # @param uri [String] URI of the resource to subscribe to
+      # @param update_callback [Proc] Callback for resource updates
+      # @return [String] Request ID for tracking the request
+      def subscribe_resource(uri, update_callback)
+        @resource_subscriptions ||= {}
+        @resource_subscriptions[uri] = update_callback
+
+        request_id = SecureRandom.uuid_v7
+
+        # Send request
+        send_jsonrpc_request("resources/subscribe",
+                             params: { uri: uri },
+                             id: request_id
+        )
+
+        # Return request ID for tracking the request
+        request_id
+      end
+
+      # Unsubscribe from updates for a specific resource
+      # @param uri [String] URI of the resource to unsubscribe from
+      # @return [String] Request ID for tracking the request
+      def unsubscribe_resource(uri)
+        @resource_subscriptions&.delete(uri)
+
+        request_id = SecureRandom.uuid_v7
+
+        # Send request
+        send_jsonrpc_request("resources/unsubscribe",
+                             params: { uri: uri },
+                             id: request_id
+        )
+
+        # Return request ID for tracking the request
+        request_id
+      end
+    end
+  end
+end

data/lib/action_mcp/client/roots.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module ActionMCP
+  module Client
+    module Roots
+      # Notify the server that the roots list has changed
+      def roots_list_changed_notification
+        send_jsonrpc_notification("notifications/roots/list_changed")
+        true
+      end
+    end
+  end
+end

data/lib/action_mcp/client/server.rb

@@ -0,0 +1,60 @@
+module ActionMCP
+  module Client
+    class Server
+      attr_reader :name, :version
+
+      attr_reader :server_info, :capabilities
+
+      def initialize(data)
+        # Store protocol version if needed for later use
+        @protocol_version = data["protocolVersion"]
+
+        # Extract server information
+        @server_info = data["serverInfo"] || {}
+        @name = server_info["name"]
+        @version = server_info["version"]
+
+        # Store capabilities for dynamic checking
+        @capabilities = data["capabilities"] || {}
+      end
+
+      # Check if 'tools' capability is present
+      def tools?
+        @capabilities.key?("tools")
+      end
+
+      # Check if 'prompts' capability is present
+      def prompts?
+        @capabilities.key?("prompts")
+      end
+
+      # Check if tools have a dynamic state based on listChanged flag
+      def dynamic_tools?
+        tool_cap = @capabilities["tools"] || {}
+        tool_cap["listChanged"] == true
+      end
+
+      # Check if logging capability exists
+      def logging?
+        @capabilities.key?("logging")
+      end
+
+      # Check if resources capability exists
+      def resources?
+        @capabilities.key?("resources")
+      end
+
+      # Check if resources have a dynamic state based on listChanged flag
+      def dynamic_resources?
+        resources_cap = @capabilities["resources"] || {}
+        resources_cap["listChanged"] == true
+      end
+
+      def inspect
+        "#<#{self.class.name} name: #{name}, version: #{version} with resources: #{resources?}, tools: #{tools?}, prompts: #{prompts?}, logging: #{logging?}>"
+      end
+
+      alias to_s inspect
+    end
+  end
+end