actionmcp 0.22.0 → 0.25.0

data/lib/action_mcp/client/blueprint.rb

@@ -24,35 +24,16 @@ module ActionMCP
     #   # Generate a concrete URI from a blueprint with parameters
     #   uri = Blueprint.construct("file://{path}", { path: "/logs/app.log" })
     #
-    class Blueprint
+    class Blueprint < Collection
       # Initialize a new Blueprints collection with URI template definitions
       #
       # @param templates [Array<Hash>] Array of URI template definition hashes, each containing
       #   uriTemplate, name, description, and optionally mimeType keys
       # @param client [Object, nil] Optional client for lazy loading of templates
-      attr_reader :client
-
       def initialize(templates, client)
-        self.templates = templates
-        @client = client
-        @loaded = !templates.empty?
-      end
-
-      # Return all URI templates in the collection. If initialized with a client and templates
-      # haven't been loaded yet, this will trigger lazy loading from the client.
-      #
-      # @return [Array<Blueprint>] All blueprint objects in the collection
-      def all
-        load_templates unless @loaded
-        @templates
-      end
-
-      # Force reload all templates from the client and return them
-      #
-      # @return [Array<Blueprint>] All blueprint objects in the collection
-      def all!
-        load_templates(force: true)
-        @templates
+        super(templates, client)
+        self.templates = @collection_data
+        @load_method = :list_resource_templates
       end
 
       # Find a blueprint by its URI pattern
@@ -84,23 +65,6 @@ module ActionMCP
         blueprint.construct(params)
       end
 
-      # Filter blueprints based on a given block
-      #
-      # @yield [blueprint] Block that determines whether to include a blueprint
-      # @yieldparam blueprint [Blueprint] A blueprint from the collection
-      # @yieldreturn [Boolean] true to include the blueprint, false to exclude it
-      # @return [Array<Blueprint>] Blueprints that match the filter criteria
-      def filter(&block)
-        all.select(&block)
-      end
-
-      # Number of blueprints in the collection
-      #
-      # @return [Integer] The number of blueprints
-      def size
-        all.size
-      end
-
       # Check if the collection contains a blueprint with the given pattern
       #
       # @param pattern [String] The blueprint pattern to check for
@@ -116,41 +80,11 @@ module ActionMCP
         all.group_by(&:protocol)
       end
 
-      # Implements enumerable functionality for the collection
-      include Enumerable
-
-      # Yield each blueprint in the collection to the given block
-      #
-      # @yield [blueprint] Block to execute for each blueprint
-      # @yieldparam blueprint [Blueprint] A blueprint from the collection
-      # @return [Enumerator] If no block is given
-      def each(&block)
-        all.each(&block)
-      end
-
       # Convert raw template data into ResourceTemplate objects
       #
       # @param templates [Array<Hash>] Array of template definition hashes
       def templates=(templates)
-        @templates = templates.map { |template_data| ResourceTemplate.new(template_data) }
-      end
-
-      private
-
-      # Load or reload templates using the client
-      #
-      # @param force [Boolean] Whether to force reload even if templates are already loaded
-      # @return [void]
-      def load_templates(force: false)
-        return if @loaded && !force
-
-        begin
-          @client.list_resource_templates
-          @loaded = true
-        rescue StandardError => e
-          Rails.logger.error("Failed to load templates: #{e.message}")
-          @loaded = true unless @templates.empty?
-        end
+        @collection_data = templates.map { |template_data| ResourceTemplate.new(template_data) }
       end
 
       # Internal Blueprint class to represent individual URI templates

data/lib/action_mcp/client/catalog.rb

@@ -24,35 +24,16 @@ module ActionMCP
     #   # Get all resources matching a criteria
     #   rust_files = catalog.filter { |r| r.mime_type == "text/x-rust" }
     #
-    class Catalog
+    class Catalog < Collection
       # Initialize a new Catalog with resource definitions
       #
       # @param resources [Array<Hash>] Array of resource definition hashes, each containing
       #   uri, name, description, and mimeType keys
       # @param client [Object, nil] Optional client for lazy loading of resources
-      attr_reader :client
-
       def initialize(resources, client)
-        self.resources = resources
-        @client = client
-        @loaded = !resources.empty?
-      end
-
-      # Return all resources in the collection. If initialized with a client and resources
-      # haven't been loaded yet, this will trigger lazy loading from the client.
-      #
-      # @return [Array<Resource>] All resource objects in the collection
-      def all
-        load_resources unless @loaded
-        @resources
-      end
-
-      # Force reload all resources from the client and return them
-      #
-      # @return [Array<Resource>] All resource objects in the collection
-      def all!
-        load_resources(force: true)
-        @resources
+        super(resources, client)
+        self.resources = @collection_data
+        @load_method = :list_resources
       end
 
       # Find a resource by URI
@@ -79,16 +60,6 @@ module ActionMCP
         all.select { |resource| resource.mime_type == mime_type }
       end
 
-      # Filter resources based on a given block
-      #
-      # @yield [resource] Block that determines whether to include a resource
-      # @yieldparam resource [Resource] A resource from the collection
-      # @yieldreturn [Boolean] true to include the resource, false to exclude it
-      # @return [Array<Resource>] Resources that match the filter criteria
-      def filter(&block)
-        all.select(&block)
-      end
-
       # Get a list of all resource URIs
       #
       # @return [Array<String>] URIs of all resources in the collection
@@ -96,13 +67,6 @@ module ActionMCP
         all.map(&:uri)
       end
 
-      # Number of resources in the collection
-      #
-      # @return [Integer] The number of resources
-      def size
-        all.size
-      end
-
       # Check if the collection contains a resource with the given URI
       #
       # @param uri [String] The resource URI to check for
@@ -126,45 +90,15 @@ module ActionMCP
         keyword = keyword.downcase
         all.select do |resource|
           resource.name.downcase.include?(keyword) ||
-            (resource.description && resource.description.downcase.include?(keyword))
+            resource.description&.downcase&.include?(keyword)
         end
       end
 
-      # Implements enumerable functionality for the collection
-      include Enumerable
-
-      # Yield each resource in the collection to the given block
-      #
-      # @yield [resource] Block to execute for each resource
-      # @yieldparam resource [Resource] A resource from the collection
-      # @return [Enumerator] If no block is given
-      def each(&block)
-        all.each(&block)
-      end
-
       # Convert raw resource data into Resource objects
       #
       # @param raw_resources [Array<Hash>] Array of resource definition hashes
       def resources=(raw_resources)
-        @resources = raw_resources.map { |resource_data| Resource.new(resource_data) }
-      end
-
-      private
-
-      # Load or reload resources using the client
-      #
-      # @param force [Boolean] Whether to force reload even if resources are already loaded
-      # @return [void]
-      def load_resources(force: false)
-        return if @loaded && !force
-
-        begin
-          @client.list_resources
-          @loaded = true
-        rescue StandardError => e
-          Rails.logger.error("Failed to load resources: #{e.message}")
-          @loaded = true unless @resources.empty?
-        end
+        @collection_data = raw_resources.map { |resource_data| Resource.new(resource_data) }
       end
 
       # Internal Resource class to represent individual resources
@@ -185,7 +119,7 @@ module ActionMCP
         #
         # @return [String, nil] The file extension or nil if no extension
         def extension
-          File.extname(@name)[1..-1] if @name.include?(".")
+          File.extname(@name)[1..] if @name.include?(".")
         end
 
         # Check if this resource is a text file based on MIME type
@@ -206,7 +140,9 @@ module ActionMCP
         #
         # @return [String, nil] The path component of the URI
         def path
-          URI(@uri).path rescue nil
+          URI(@uri).path
+        rescue StandardError
+          nil
         end
 
         # Generate a hash representation of the resource

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

@@ -4,6 +4,7 @@ module ActionMCP
   module Client
     class JsonRpcHandler < JsonRpcHandlerBase
       attr_reader :client
+
       def initialize(transport, client)
         super(transport)
         @client = client
@@ -70,25 +71,30 @@ module ActionMCP
 
       def process_response(id, result)
         if transport.id == id
-          ## This initialize the transport
+          ## 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 client.toolbox.all
+          client.toolbox.tools = result["tools"]
+          return true
         when "prompts/list"
           client.prompt_book.prompts = result["prompts"]
-          return client.prompt_book.all
+          return true
         when "resources/list"
           client.catalog.resources = result["resources"]
-          return client.catalog.all
+          return true
         when "resources/templates/list"
           client.blueprint.templates = result["resourceTemplates"]
-          return client.blueprint.all
+          return true
         end
 
         puts "\e[31mUnknown response: #{id} #{result}\e[0m"
@@ -99,7 +105,6 @@ module ActionMCP
         puts "\e[31mUnknown error: #{id} #{error}\e[0m"
       end
 
-
       def send_initialized_notification
         transport.initialize!
         client.send_jsonrpc_notification("notifications/initialized")

data/lib/action_mcp/client/logging.rb

@@ -12,8 +12,7 @@ module ActionMCP
         # Send request
         send_jsonrpc_request("client/setLoggingLevel",
                              params: { level: level },
-                             id: request_id
-        )
+                             id: request_id)
       end
     end
   end

data/lib/action_mcp/client/prompt_book.rb

@@ -24,27 +24,16 @@ module ActionMCP
     #   # Get all prompts matching a criteria
     #   text_prompts = book.filter { |p| p.name.include?("text") }
     #
-    class PromptBook
+    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
-      attr_reader :client
-
       def initialize(prompts, client)
-        self.prompts = prompts
-        @client = client
-        @loaded = !prompts.empty?
-      end
-
-      # Return all prompts in the collection. If initialized with a client and prompts
-      # haven't been loaded yet, this will trigger lazy loading from the client.
-      #
-      # @return [Array<Prompt>] All prompt objects in the collection
-      def all
-        load_prompts unless @loaded
-        @prompts
+        super(prompts, client)
+        self.prompts = @collection_data
+        @load_method = :list_prompts
       end
 
       # Find a prompt by name
@@ -55,16 +44,6 @@ module ActionMCP
         all.find { |prompt| prompt.name == name }
       end
 
-      # Filter prompts based on a given block
-      #
-      # @yield [prompt] Block that determines whether to include a prompt
-      # @yieldparam prompt [Prompt] A prompt from the collection
-      # @yieldreturn [Boolean] true to include the prompt, false to exclude it
-      # @return [Array<Prompt>] Prompts that match the filter criteria
-      def filter(&block)
-        all.select(&block)
-      end
-
       # Get a list of all prompt names
       #
       # @return [Array<String>] Names of all prompts in the collection
@@ -72,13 +51,6 @@ module ActionMCP
         all.map(&:name)
       end
 
-      # Number of prompts in the collection
-      #
-      # @return [Integer] The number of prompts
-      def size
-        all.size
-      end
-
       # Check if the collection contains a prompt with the given name
       #
       # @param name [String] The prompt name to check for
@@ -87,49 +59,11 @@ module ActionMCP
         all.any? { |prompt| prompt.name == name }
       end
 
-      # Implements enumerable functionality for the collection
-      include Enumerable
-
-      # Yield each prompt in the collection to the given block
-      #
-      # @yield [prompt] Block to execute for each prompt
-      # @yieldparam prompt [Prompt] A prompt from the collection
-      # @return [Enumerator] If no block is given
-      def each(&block)
-        all.each(&block)
-      end
-
-      # Force reload all prompts from the client and return them
-      #
-      # @return [Array<Prompt>] All prompt objects in the collection
-      def all!
-        load_prompts(force: true)
-        all
-      end
-
       # Convert raw prompt data into Prompt objects
       #
       # @param prompts [Array<Hash>] Array of prompt definition hashes
       def prompts=(prompts)
-        @prompts = prompts.map { |data| Prompt.new(data) }
-      end
-
-      private
-
-      # Load or reload prompts using the client
-      #
-      # @param force [Boolean] Whether to force reload even if prompts are already loaded
-      # @return [void]
-      def load_prompts(force: false)
-        return if @loaded && !force
-
-        begin
-          @client.list_prompts
-          @loaded = true
-        rescue StandardError => e
-          Rails.logger.error("Failed to load prompts: #{e.message}")
-          @loaded = true unless @prompts.empty?
-        end
+        @collection_data = prompts.map { |data| Prompt.new(data) }
       end
 
       # Internal Prompt class to represent individual prompts

data/lib/action_mcp/client/prompts.rb

@@ -4,18 +4,21 @@ module ActionMCP
   module Client
     module Prompts
       # List all available prompts from the server
-      # @return [Array<Hash>] List of available prompts with their metadata
+      # @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 [Hash] Prompt content with messages
+      # @return [String] Request ID for tracking the request
       def get_prompt(name, arguments = {})
         request_id = SecureRandom.uuid_v7
 
@@ -25,8 +28,10 @@ module ActionMCP
                                name: name,
                                arguments: arguments
                              },
-                             id: request_id
-        )
+                             id: request_id)
+
+        # Return request ID for tracking the request
+        request_id
       end
     end
   end

data/lib/action_mcp/client/request_timeouts.rb

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