actionmcp 0.102.0 → 0.103.0

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

data/lib/action_mcp/client/resources.rb

@@ -1,100 +0,0 @@
-# frozen_string_literal: true
-
-module ActionMCP
-  module Client
-    module Resources
-      # List all available resources 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_resources(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("resources/list",
-                             params: request_params.empty? ? nil : request_params,
-                             id: request_id)
-
-        # Return request ID for tracking the request
-        request_id
-      end
-
-      # List resource templates 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_resource_templates(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("resources/templates/list",
-                             params: request_params.empty? ? nil : request_params,
-                             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

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

@@ -1,60 +0,0 @@
-# frozen_string_literal: true
-
-module ActionMCP
-  module Client
-    class Server
-      attr_reader :name, :version, :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

data/lib/action_mcp/client/session_store.rb

@@ -1,39 +0,0 @@
-# frozen_string_literal: true
-
-module ActionMCP
-  module Client
-    # Abstract interface for session storage
-    module SessionStore
-      # Load session data by ID
-      def load_session(session_id)
-        raise NotImplementedError, "#{self.class} must implement #load_session"
-      end
-
-      # Save session data
-      def save_session(session_id, session_data)
-        raise NotImplementedError, "#{self.class} must implement #save_session"
-      end
-
-      # Delete session
-      def delete_session(session_id)
-        raise NotImplementedError, "#{self.class} must implement #delete_session"
-      end
-
-      # Check if session exists
-      def session_exists?(session_id)
-        raise NotImplementedError, "#{self.class} must implement #session_exists?"
-      end
-
-      # Update specific session attributes
-      def update_session(session_id, attributes)
-        session_data = load_session(session_id)
-        return nil unless session_data
-
-        session_data.merge!(attributes)
-        save_session(session_id, session_data)
-        # Return the reloaded session to get the actual saved values
-        load_session(session_id)
-      end
-    end
-  end
-end

data/lib/action_mcp/client/session_store_factory.rb

@@ -1,27 +0,0 @@
-# frozen_string_literal: true
-
-module ActionMCP
-  module Client
-    # Factory for creating session stores
-    class SessionStoreFactory
-      def self.create(type = nil, **_options)
-        type ||= default_type
-
-        case type.to_sym
-        when :volatile, :memory
-          VolatileSessionStore.new
-        when :active_record, :persistent
-          ActiveRecordSessionStore.new
-        when :test
-          TestSessionStore.new
-        else
-          raise ArgumentError, "Unknown session store type: #{type}"
-        end
-      end
-
-      def self.default_type
-        ActionMCP.configuration.client_session_store_type
-      end
-    end
-  end
-end