actionmcp 0.102.0 → 0.103.0

data/lib/action_mcp/client/toolbox.rb

@@ -1,199 +0,0 @@
-# frozen_string_literal: true
-
-module ActionMCP
-  module Client
-    # Toolbox
-    #
-    # A collection that manages and provides access to tools from the server.
-    # This class stores tool definitions along with their input schemas and
-    # provides methods for retrieving, filtering, and accessing tools.
-    #
-    # Example usage:
-    #   tools_data = client.list_tools # Returns array of tool definitions
-    #   toolbox = Toolbox.new(tools_data)
-    #
-    #   # Access a specific tool by name
-    #   weather_tool = toolbox.find("weather_forecast")
-    #
-    #   # Get all tools matching a criteria
-    #   calculation_tools = toolbox.filter { |t| t.name.include?("calculate") }
-    #
-    class Toolbox < Collection
-      # Initialize a new Toolbox with tool definitions
-      #
-      # @param tools [Array<Hash>] Array of tool definition hashes, each containing
-      #   name, description, and inputSchema keys
-      def initialize(tools, client)
-        super(tools, client)
-        self.tools = @collection_data
-        @load_method = :list_tools
-      end
-
-      # Find a tool by name
-      #
-      # @param name [String] Name of the tool to find
-      # @return [Tool, nil] The tool with the given name, or nil if not found
-      def find(name)
-        all.find { |tool| tool.name == name }
-      end
-
-      # Filter tools based on a given block
-      #
-      # @yield [tool] Block that determines whether to include a tool
-      # @yieldparam tool [Tool] A tool from the collection
-      # @yieldreturn [Boolean] true to include the tool, false to exclude it
-      # @return [Array<Tool>] Tools that match the filter criteria
-      def filter(&block)
-        all.select(&block)
-      end
-
-      # Get a list of all tool names
-      #
-      # @return [Array<String>] Names of all tools in the collection
-      def names
-        all.map(&:name)
-      end
-
-      # Number of tools in the collection
-      #
-      # @return [Integer] The number of tools
-      def size
-        all.size
-      end
-
-      # Check if the collection contains a tool with the given name
-      #
-      # @param name [String] The tool name to check for
-      # @return [Boolean] true if a tool with the name exists
-      def contains?(name)
-        all.any? { |tool| tool.name == name }
-      end
-
-      # Get tools by category or type
-      #
-      # @param keyword [String] Keyword to search for in tool names and descriptions
-      # @return [Array<Tool>] Tools containing the keyword
-      def search(keyword)
-        all.select do |tool|
-          tool.name.include?(keyword) ||
-            tool.description&.downcase&.include?(keyword.downcase)
-        end
-      end
-
-      # Generate a hash representation of all tools in the collection based on provider format
-      #
-      # @param provider [Symbol] The provider format to use (:claude, :openai, or :default)
-      # @return [Hash] Hash containing all tools formatted for the specified provider
-      def to_h(provider = :default)
-        case provider
-        when :claude
-          # Claude format
-          { "tools" => all.map(&:to_claude_h) }
-        when :openai
-          # OpenAI format
-          { "tools" => all.map(&:to_openai_h) }
-        else
-          # Default format (same as original)
-          { "tools" => all.map(&:to_h) }
-        end
-      end
-
-      def tools=(tools)
-        @collection_data = tools.map { |tool_data| Tool.new(tool_data) }
-      end
-
-      # Internal Tool class to represent individual tools
-      class Tool
-        attr_reader :name, :description, :input_schema, :annotations
-
-        # Initialize a new Tool instance
-        #
-        # @param data [Hash] Tool definition hash containing name, description, and inputSchema
-        #  and optionally annotations
-        def initialize(data)
-          @name = data["name"]
-          @description = data["description"]
-          @input_schema = data["inputSchema"] || {}
-          @annotations = data["annotations"] || {}
-        end
-
-        # Get all required properties for this tool
-        #
-        # @return [Array<String>] Array of required property names
-        def required_properties
-          @input_schema["required"] || []
-        end
-
-        # Get all properties for this tool
-        #
-        # @return [Hash] Hash of property definitions
-        def properties
-          @input_schema["properties"] || {}
-        end
-
-        # Check if the tool requires a specific property
-        #
-        # @param name [String] Name of the property to check
-        # @return [Boolean] true if the property is required
-        def requires?(name)
-          required_properties.include?(name)
-        end
-
-        # Check if the tool has a specific property
-        #
-        # @param name [String] Name of the property to check
-        # @return [Boolean] true if the property exists
-        def has_property?(name)
-          properties.key?(name)
-        end
-
-        # Get property details by name
-        #
-        # @param name [String] Name of the property
-        # @return [Hash, nil] Property details or nil if not found
-        def property(name)
-          properties[name]
-        end
-
-        # Generate a hash representation of the tool (default format)
-        #
-        # @return [Hash] Hash containing tool details
-        def to_h
-          {
-            "name" => @name,
-            "description" => @description,
-            "inputSchema" => @input_schema,
-            "annotations" => @annotations
-          }
-        end
-
-        # Generate a hash representation of the tool in Claude format
-        #
-        # @return [Hash] Hash containing tool details formatted for Claude
-        def to_claude_h
-          {
-            "name" => @name,
-            "description" => @description,
-            "input_schema" => @input_schema.transform_keys { |k| k == "inputSchema" ? "input_schema" : k },
-            "annotations" => @annotations
-          }
-        end
-
-        # Generate a hash representation of the tool in OpenAI format
-        #
-        # @return [Hash] Hash containing tool details formatted for OpenAI
-        def to_openai_h
-          {
-            "type" => "function",
-            "function" => {
-              "name" => @name,
-              "description" => @description,
-              "parameters" => @input_schema,
-              "annotations" => @annotations
-            }
-          }
-        end
-      end
-    end
-  end
-end

data/lib/action_mcp/client/tools.rb

@@ -1,47 +0,0 @@
-# frozen_string_literal: true
-
-module ActionMCP
-  module Client
-    module Tools
-      # List all available tools 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_tools(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("tools/list",
-                             params: request_params.empty? ? nil : request_params,
-                             id: request_id)
-
-        # Return request ID for timeout tracking
-        request_id
-      end
-
-      # Call a specific tool on the server
-      # @param name [String] Name of the tool to call
-      # @param arguments [Hash] Arguments to pass to the tool
-      # @return [String] Request ID for tracking the request
-      def call_tool(name, arguments)
-        request_id = SecureRandom.uuid_v7
-
-        # Send request
-        send_jsonrpc_request("tools/call",
-                             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/transport.rb

@@ -1,137 +0,0 @@
-# frozen_string_literal: true
-
-module ActionMCP
-  module Client
-    # Base transport interface for MCP client connections
-    module Transport
-      # Called when transport should establish connection
-      def connect
-        raise NotImplementedError, "#{self.class} must implement #connect"
-      end
-
-      # Called when transport should close connection
-      def disconnect
-        raise NotImplementedError, "#{self.class} must implement #disconnect"
-      end
-
-      # Send a message through the transport
-      def send_message(message)
-        raise NotImplementedError, "#{self.class} must implement #send_message"
-      end
-
-      # Check if transport is ready to send/receive
-      def ready?
-        raise NotImplementedError, "#{self.class} must implement #ready?"
-      end
-
-      # Check if transport is connected
-      def connected?
-        raise NotImplementedError, "#{self.class} must implement #connected?"
-      end
-
-      # Set callback for received messages
-      def on_message(&block)
-        @message_callback = block
-      end
-
-      # Set callback for errors
-      def on_error(&block)
-        @error_callback = block
-      end
-
-      # Set callback for connection events
-      def on_connect(&block)
-        @connect_callback = block
-      end
-
-      # Set callback for disconnection events
-      def on_disconnect(&block)
-        @disconnect_callback = block
-      end
-
-      protected
-
-      def handle_message(message)
-        @message_callback&.call(message)
-      end
-
-      def handle_error(error)
-        @error_callback&.call(error)
-      end
-
-      def handle_connect
-        @connect_callback&.call
-      end
-
-      def handle_disconnect
-        @disconnect_callback&.call
-      end
-    end
-
-    # Base class for transport implementations
-    class TransportBase
-      include Transport
-
-      attr_reader :url, :options, :session_store
-
-      def initialize(url, session_store:, logger: ActionMCP.logger, **options)
-        @url = url
-        @session_store = session_store
-        @logger = logger
-        @options = options
-        @connected = false
-        @ready = false
-      end
-
-      def connected?
-        @connected
-      end
-
-      def ready?
-        @ready
-      end
-
-      protected
-
-      def set_connected(state)
-        @connected = state
-        state ? handle_connect : handle_disconnect
-      end
-
-      def set_ready(state)
-        @ready = state
-      end
-
-      # Logging methods for transport classes
-      def log_debug(message)
-        @logger.debug("[ActionMCP::#{self.class.name.split('::').last}] #{message}")
-      end
-
-      def log_info(message)
-        @logger.info("[ActionMCP::#{self.class.name.split('::').last}] #{message}")
-      end
-
-      def log_error(message)
-        @logger.error("[ActionMCP::#{self.class.name.split('::').last}] #{message}")
-      end
-
-      private
-
-      def handle_connect
-        @connect_callback&.call
-      end
-
-      def handle_disconnect
-        @disconnect_callback&.call
-      end
-
-      def handle_error(error)
-        @error_callback&.call(error)
-      end
-
-      def handle_message(message)
-        @message_callback&.call(message)
-      end
-    end
-  end
-end

data/lib/action_mcp/client/volatile_session_store.rb

@@ -1,38 +0,0 @@
-# frozen_string_literal: true
-
-module ActionMCP
-  module Client
-    # Volatile session store for development (data lost on restart)
-    class VolatileSessionStore
-      include SessionStore
-
-      def initialize
-        @sessions = Concurrent::Hash.new
-      end
-
-      def load_session(session_id)
-        @sessions[session_id]
-      end
-
-      def save_session(session_id, session_data)
-        @sessions[session_id] = session_data.dup
-      end
-
-      def delete_session(session_id)
-        @sessions.delete(session_id)
-      end
-
-      def session_exists?(session_id)
-        @sessions.key?(session_id)
-      end
-
-      def clear_all
-        @sessions.clear
-      end
-
-      def session_count
-        @sessions.size
-      end
-    end
-  end
-end

data/lib/action_mcp/client.rb

@@ -1,71 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "client/transport"
-require_relative "client/session_store"
-require_relative "client/streamable_http_transport"
-
-module ActionMCP
-  # Creates a client appropriate for the given endpoint.
-  #
-  # @param endpoint [String] The endpoint to connect to (URL).
-  # @param transport [Symbol] The transport type to use (:streamable_http, :sse for legacy)
-  # @param session_store [Symbol] The session store type (:memory, :active_record)
-  # @param session_id [String] Optional session ID for resuming connections
-  # @param protocol_version [String] The MCP protocol version to use (defaults to ActionMCP::DEFAULT_PROTOCOL_VERSION)
-  # @param logger [Logger] The logger to use. Default is Logger.new($stdout).
-  # @param options [Hash] Additional options to pass to the client constructor.
-  #
-  # @return [Client::Base] An instance of the appropriate client.
-  #
-  # @example Basic usage
-  #   client = ActionMCP.create_client("http://127.0.0.1:3001/action_mcp")
-  #   client.connect
-  #
-  # @example With specific transport and session store
-  #   client = ActionMCP.create_client(
-  #     "http://127.0.0.1:3001/action_mcp",
-  #     transport: :streamable_http,
-  #     session_store: :active_record,
-  #     session_id: "existing-session-123"
-  #   )
-  #
-  # @example Memory-based for development
-  #   client = ActionMCP.create_client(
-  #     "http://127.0.0.1:3001/action_mcp",
-  #     session_store: :memory
-  #   )
-  #
-  def self.create_client(endpoint, transport: :streamable_http, session_store: nil, session_id: nil,
-                         protocol_version: nil, logger: Logger.new($stdout), **options)
-    unless endpoint =~ %r{\Ahttps?://}
-      raise ArgumentError, "Only HTTP(S) endpoints are supported. STDIO and other transports are not supported."
-    end
-
-    # Create session store
-    store = Client::SessionStoreFactory.create(session_store, **options)
-
-    # Create transport
-    transport_instance = create_transport(transport, endpoint, session_store: store, session_id: session_id,
-                                                               protocol_version: protocol_version, logger: logger, **options)
-
-    logger.info("Creating #{transport} client for endpoint: #{endpoint}")
-    # Pass session_id and protocol_version to the client
-    Client::Base.new(transport: transport_instance, logger: logger, session_id: session_id,
-                     protocol_version: protocol_version, **options)
-  end
-
-  private_class_method def self.create_transport(type, endpoint, **options)
-    case type.to_sym
-    when :streamable_http
-      Client::StreamableHttpTransport.new(endpoint, **options)
-    when :sse
-      # Legacy SSE transport (wrapped for compatibility)
-      Client::StreamableClient.new(endpoint, **options)
-    else
-      raise ArgumentError, "Unknown transport type: #{type}"
-    end
-  end
-
-  module Client
-  end
-end