actionmcp 0.1.2 → 0.2.3

data/lib/action_mcp/tool.rb

@@ -1,141 +1,114 @@
-# lib/action_mcp/tool.rb
 # frozen_string_literal: true
 
 module ActionMCP
-  class Tool
-    include ActiveModel::Model
-    include ActiveModel::Attributes
-
-    class_attribute :_tool_name, instance_accessor: false
-    class_attribute :_description, instance_accessor: false, default: ""
+  # Base class for defining tools.
+  #
+  # Provides a DSL for specifying metadata, properties, and nested collection schemas.
+  # Tools are registered automatically in the ToolsRegistry unless marked as abstract.
+  class Tool < Capability
+    # --------------------------------------------------------------------------
+    # Class Attributes for Tool Metadata and Schema
+    # --------------------------------------------------------------------------
+    # @!attribute _schema_properties
+    #   @return [Hash] The schema properties of the tool.
+    # @!attribute _required_properties
+    #   @return [Array<String>] The required properties of the tool.
     class_attribute :_schema_properties, instance_accessor: false, default: {}
     class_attribute :_required_properties, instance_accessor: false, default: []
-    class_attribute :abstract_tool, instance_accessor: false, default: false
-
-    # Register each non-abstract subclass in ToolsRegistry
-    def self.inherited(subclass)
-      super
-      return if subclass == Tool
-
-      subclass.abstract_tool = false
-      return if subclass.name == "ApplicationTool"
-
-      ToolsRegistry.register(subclass.tool_name, subclass)
-    end
 
-    # Mark this tool as abstract so it won’t be available for use.
-    def self.abstract!
-      self.abstract_tool = true
-      ToolsRegistry.unregister(tool_name) if ToolsRegistry.items.key?(tool_name)
-    end
-
-    def self.abstract?
-      abstract_tool
-    end
-
-    # ---------------------------------------------------
-    # Tool Name & Description
-    # ---------------------------------------------------
+    # --------------------------------------------------------------------------
+    # Tool Name and Description DSL
+    # --------------------------------------------------------------------------
+    # Sets or retrieves the tool's name.
+    #
+    # @param name [String, nil] Optional. The name to set for the tool.
+    # @return [String] The current tool name.
     def self.tool_name(name = nil)
       if name
-        self._tool_name = name
+        self._capability_name = name
       else
-        _tool_name || default_tool_name
+        _capability_name || default_tool_name
       end
     end
 
+    # Returns a default tool name based on the class name.
+    #
+    # @return [String] The default tool name.
     def self.default_tool_name
-      name.demodulize.underscore.dasherize.sub(/-tool$/, "")
+      name.demodulize.underscore.sub(/_tool$/, "")
     end
 
-    def self.description(text = nil)
-      if text
-        self._description = text
-      else
-        _description
-      end
+    class << self
+      alias default_capability_name default_tool_name
     end
 
-    # ---------------------------------------------------
+    # --------------------------------------------------------------------------
     # Property DSL (Direct Declaration)
-    # ---------------------------------------------------
+    # --------------------------------------------------------------------------
+    # Defines a property for the tool.
+    #
+    # This method builds a JSON Schema definition for the property, registers it
+    # in the tool's schema, and creates an ActiveModel attribute for it.
+    #
+    # @param prop_name [Symbol, String] The property name.
+    # @param type [String] The JSON Schema type (default: "string").
+    # @param description [String, nil] Optional description for the property.
+    # @param required [Boolean] Whether the property is required (default: false).
+    # @param default [Object, nil] The default value for the property.
+    # @param opts [Hash] Additional options for the JSON Schema.
+    # @return [void]
     def self.property(prop_name, type: "string", description: nil, required: false, default: nil, **opts)
-      # Build JSON Schema definition for the property.
+      # Build the JSON Schema definition.
       prop_definition = { type: type }
       prop_definition[:description] = description if description && !description.empty?
       prop_definition.merge!(opts) if opts.any?
 
       self._schema_properties = _schema_properties.merge(prop_name.to_s => prop_definition)
-      self._required_properties = _required_properties.dup
-      _required_properties << prop_name.to_s if required
-
-      # Map our DSL type to an ActiveModel attribute type.
-      am_type = case type.to_s
-      when "number" then :float
-      when "integer" then :integer
-      when "array"   then :string
-      else
-                  :string
+      self._required_properties = _required_properties.dup.tap do |req|
+        req << prop_name.to_s if required
       end
-      attribute prop_name, am_type, default: default
+
+      # Map the JSON Schema type to an ActiveModel attribute type.
+      attribute prop_name, map_json_type_to_active_model_type(type), default: default
+      validates prop_name, presence: true, if: -> { required }
+
+      return unless %w[number integer].include?(type)
+
+      validates prop_name, numericality: true
     end
 
-    # ---------------------------------------------------
+    # --------------------------------------------------------------------------
     # Collection DSL
-    # ---------------------------------------------------
-    # Supports two forms:
-    #
-    # 1. Without a block:
-    #    collection :args, type: "string", description: "Command arguments"
+    # --------------------------------------------------------------------------
+    # Defines a collection property for the tool.
     #
-    # 2. With a block (defining a nested object):
-    #    collection :files, description: "List of Files" do
-    #      property :file, required: true, description: 'file uri'
-    #      property :checksum, required: true, description: 'checksum to verify'
-    #    end
-    def self.collection(prop_name, type: nil, description: nil, required: false, default: nil, **_opts, &block)
-      if block_given?
-        # Build nested schema for an object.
-        nested_schema = { type: "object", properties: {}, required: [] }
-        dsl = CollectionDSL.new(nested_schema)
-        dsl.instance_eval(&block)
-        collection_definition = { type: "array", description: description, items: nested_schema }
-      else
-        raise ArgumentError, "Type is required for a collection without a block" if type.nil?
+    # @param prop_name [Symbol, String] The collection property name.
+    # @param type [String] The type for collection items.
+    # @param description [String, nil] Optional description for the collection.
+    # @param required [Boolean] Whether the collection is required (default: false).
+    # @param default [Array, nil] The default value for the collection.
+    # @return [void]
+    def self.collection(prop_name, type:, description: nil, required: false, default: [])
+      raise ArgumentError, "Type is required for a collection" if type.nil?
 
-        collection_definition = { type: "array", description: description, items: { type: type } }
-      end
+      collection_definition = { type: "array", description: description, items: { type: type } }
 
       self._schema_properties = _schema_properties.merge(prop_name.to_s => collection_definition)
-      self._required_properties = _required_properties.dup
-      _required_properties << prop_name.to_s if required
-
-      # Register the property as an attribute.
-      # (Mapping for a collection can be customized; here we use :string to mimic previous behavior.)
-      attribute prop_name, :string, default: default
-    end
-
-    # DSL for building a nested schema within a collection block.
-    class CollectionDSL
-      attr_reader :schema
-
-      def initialize(schema)
-        @schema = schema
+      self._required_properties = _required_properties.dup.tap do |req|
+        req << prop_name.to_s if required
       end
 
-      def property(prop_name, type: "string", description: nil, required: false, default: nil, **opts)
-        prop_definition = { type: type }
-        prop_definition[:description] = description if description && !description.empty?
-        prop_definition.merge!(opts) if opts.any?
-
-        @schema[:properties][prop_name.to_s] = prop_definition
-        @schema[:required] << prop_name.to_s if required
-      end
+      type = map_json_type_to_active_model_type("array_#{type}")
+      attribute prop_name, type, default: default
+      validates prop_name, presence: true, if: -> { required }
     end
 
-    # ---------------------------------------------------
-    # Convert Tool Definition to Hash
-    # ---------------------------------------------------
+    # --------------------------------------------------------------------------
+    # Tool Definition Serialization
+    # --------------------------------------------------------------------------
+    # Returns a hash representation of the tool definition including its JSON Schema.
+    #
+    # @return [Hash] The tool definition.
     def self.to_h
       schema = { type: "object", properties: _schema_properties }
       schema[:required] = _required_properties if _required_properties.any?
@@ -145,5 +118,42 @@ module ActionMCP
         inputSchema: schema
       }.compact
     end
+
+    # --------------------------------------------------------------------------
+    # Instance Methods
+    # --------------------------------------------------------------------------
+    # Abstract method to perform the tool's action.
+    #
+    # Subclasses must implement this method.
+    #
+    # @raise [NotImplementedError] Always raised if not implemented in a subclass.
+    # @return [Array<Content>] Array of Content objects is expected as return value
+    def call
+      raise NotImplementedError, "Subclasses must implement the call method"
+      # Default implementation (no-op)
+      # In a real subclass, you might do:
+      #   def call
+      #     # Perform logic, e.g. analyze code, etc.
+      #     # Array of Content objects is expected as return value
+      #   end
+    end
+
+    private
+
+    # Maps a JSON Schema type to an ActiveModel attribute type.
+    #
+    # @param type [String] The JSON Schema type.
+    # @return [Symbol] The corresponding ActiveModel attribute type.
+    def self.map_json_type_to_active_model_type(type)
+      case type.to_s
+      when "number" then :float # JSON Schema "number" is a float in Ruby, the spec doesn't have an integer type yet.
+      when "array_number" then :integer_array
+      when "array_integer" then :string_array
+      when "array_string" then :string_array
+      else :string
+      end
+    end
+
+    private_class_method :map_json_type_to_active_model_type
   end
 end

data/lib/action_mcp/tools_registry.rb

@@ -1,12 +1,37 @@
 # frozen_string_literal: true
 
-# frozen_string_literal: true
-
 module ActionMCP
+  # Registry for managing tools.
   class ToolsRegistry < RegistryBase
     class << self
+      # @!method tools
+      #   Returns all registered tools.
+      #   @return [Hash] A hash of registered tools.
       alias tools items
-      alias available_tools enabled
+
+      # Calls a tool with the given name and arguments.
+      #
+      # @param tool_name [String] The name of the tool to call.
+      # @param arguments [Hash] The arguments to pass to the tool.
+      # @param _metadata [Hash] Optional metadata.
+      # @return [Hash] A hash containing the tool's response.
+      def tool_call(tool_name, arguments, _metadata = {})
+        tool = find(tool_name)
+        tool = tool.new(arguments)
+        tool.validate
+        if tool.valid?
+          { content: [ tool.call ] }
+        else
+          {
+            content: tool.errors.full_messages.map { |msg| Content::Text.new(msg) },
+            isError: true
+          }
+        end
+      end
+
+      def item_klass
+        Tool
+      end
     end
   end
 end

data/lib/action_mcp/transport/capabilities.rb

@@ -0,0 +1,21 @@
+module ActionMCP
+  module Transport
+    module Capabilities
+      def send_capabilities(request_id, params = {})
+        @protocol_version = params["protocolVersion"]
+        @client_info = params["clientInfo"]
+        @client_capabilities = params["capabilities"]
+        capabilities = ActionMCP.configuration.capabilities
+
+        payload = {
+          protocolVersion: PROTOCOL_VERSION,
+          serverInfo: {
+            name: ActionMCP.configuration.name,
+            version: ActionMCP.configuration.version
+          }
+        }.merge(capabilities)
+        send_jsonrpc_response(request_id, result: payload)
+      end
+    end
+  end
+end

data/lib/action_mcp/transport/messaging.rb

@@ -0,0 +1,20 @@
+module ActionMCP
+  module Transport
+    module Messaging
+      def send_jsonrpc_request(method, params: nil, id: SecureRandom.uuid_v7)
+        request = JsonRpc::Request.new(id: id, method: method, params: params)
+        write_message(request.to_json)
+      end
+
+      def send_jsonrpc_response(request_id, result: nil, error: nil)
+        response = JsonRpc::Response.new(id: request_id, result: result, error: error)
+        write_message(response.to_json)
+      end
+
+      def send_jsonrpc_notification(method, params = nil)
+        notification = JsonRpc::Notification.new(method: method, params: params)
+        write_message(notification.to_json)
+      end
+    end
+  end
+end

data/lib/action_mcp/transport/prompts.rb

@@ -0,0 +1,19 @@
+module ActionMCP
+  module Transport
+    module Prompts
+      def send_prompts_list(request_id)
+        prompts = format_registry_items(PromptsRegistry.non_abstract)
+        send_jsonrpc_response(request_id, result: { prompts: prompts })
+      end
+
+      def send_prompts_get(request_id, prompt_name, params)
+        send_jsonrpc_response(request_id, result: PromptsRegistry.prompt_call(prompt_name.to_s, params))
+      rescue RegistryBase::NotFound
+        send_jsonrpc_response(request_id, error: JsonRpc::JsonRpcError.new(
+          :method_not_found,
+          message: "Prompt not found: #{prompt_name}"
+        ).as_json)
+      end
+    end
+  end
+end

data/lib/action_mcp/transport/sse_client.rb

@@ -0,0 +1,309 @@
+require "faraday"
+require "uri"
+
+module ActionMCP
+  module Transport
+    class SSEClient < TransportBase
+      TIMEOUT = 10 # Increased from 1 second
+      ENDPOINT_TIMEOUT = 5 # Seconds
+
+      # Define a custom error class for connection issues
+      class ConnectionError < StandardError; end
+
+      def initialize(url, **options)
+        super(**options)
+        setup_connection(url)
+        @buffer = ""
+        @stop_requested = false
+        @endpoint_received = false
+        @endpoint_mutex = Mutex.new
+        @endpoint_condition = ConditionVariable.new
+
+        # Add connection state management
+        @connection_mutex = Mutex.new
+        @connection_condition = ConditionVariable.new
+        @connection_error = nil
+        @connected = false
+      end
+
+      def start(initialize_request_id)
+        log_info("Connecting to #{@base_url}#{@sse_path}...")
+        @stop_requested = false
+        @initialize_request_id = initialize_request_id
+
+        # Reset connection state before starting
+        @connection_mutex.synchronize do
+          @connected = false
+          @connection_error = nil
+        end
+
+        # Start connection thread
+        @sse_thread = Thread.new { listen_sse }
+
+        # Wait for endpoint instead of connection completion
+        wait_for_endpoint
+      end
+
+      def wait_for_endpoint
+        success = false
+        error = nil
+
+        @endpoint_mutex.synchronize do
+          unless @endpoint_received
+            # Wait with timeout for endpoint
+            timeout = @endpoint_condition.wait(@endpoint_mutex, ENDPOINT_TIMEOUT)
+
+            # Handle timeout
+            unless timeout || @endpoint_received
+              error = "Timeout waiting for MCP endpoint (#{ENDPOINT_TIMEOUT} seconds)"
+            end
+          end
+
+          success = @endpoint_received
+        end
+
+        if error
+          log_error(error)
+          raise ConnectionError.new(error)
+        end
+
+        # If we have the endpoint, consider the connection successful
+        if success
+          @connection_mutex.synchronize do
+            @connected = true
+            @connection_condition.broadcast
+          end
+        end
+
+        success
+      end
+
+      def send_message(json_rpc)
+        # Wait for endpoint if not yet received
+        unless endpoint_ready?
+          log_info("Waiting for endpoint before sending message...")
+          wait_for_endpoint
+        end
+
+        validate_post_endpoint
+        log_debug("\e[34m" + "--> #{json_rpc}" + "\e[0m")
+        send_http_request(json_rpc)
+      end
+
+      def stop
+        log_info("Stopping SSE connection...")
+        @stop_requested = true
+        cleanup_sse_thread
+      end
+
+      def ready?
+        endpoint_ready?
+      end
+
+      private
+
+      def setup_connection(url)
+        uri = URI.parse(url)
+        @base_url = "#{uri.scheme}://#{uri.host}:#{uri.port}"
+        @sse_path = uri.path
+
+        @conn = Faraday.new(url: @base_url) do |f|
+          f.headers["User-Agent"] = user_agent
+
+          f.options.timeout = nil        # No read timeout
+          f.options.open_timeout = 10    # Connection timeout
+
+          # Use Net::HTTP adapter explicitly as it works well with streaming
+          f.adapter :net_http do |http|
+            # Configure the adapter directly
+            http.read_timeout = nil      # No read timeout at adapter level too
+            http.open_timeout = 10       # Connection timeout
+          end
+
+          # Add logger middleware
+          # f.response :logger, @logger, headers: true, bodies: true
+        end
+
+        @post_url = nil
+      end
+
+      def endpoint_ready?
+        @endpoint_mutex.synchronize { @endpoint_received }
+      end
+
+      private
+
+      # The listen_sse method should NOT mark connection as successful at the end
+      def listen_sse
+        log_info("Starting SSE listener...")
+
+        begin
+          @conn.get(@sse_path) do |req|
+            req.headers["Accept"] = "text/event-stream"
+            req.headers["Cache-Control"] = "no-cache"
+
+            req.options.on_data = Proc.new do |chunk, bytes|
+              handle_sse_data(chunk, bytes)
+            end
+          end
+
+          # This should never be reached during normal operation
+          # as the SSE connection stays open
+        rescue Faraday::ConnectionFailed => e
+          handle_connection_error(format_connection_error(e))
+        rescue => e
+          handle_connection_error("Unexpected error: #{e.message}")
+        end
+      end
+
+      def format_connection_error(error)
+        if error.message.include?("Connection refused")
+          "Connection refused - server at #{@base_url} is not running or not accepting connections"
+        else
+          "Connection failed: #{error.message}"
+        end
+      end
+
+      def handle_connection_error(message)
+        log_error("SSE connection failed: #{message}")
+
+        # Set error and notify waiting threads
+        @connection_mutex.synchronize do
+          @connection_error = message
+          @connection_condition.broadcast
+        end
+
+        @on_error&.call(StandardError.new(message))
+      end
+
+      # Send the initialized notification to the server
+      def send_initialized_notification
+        notification = JsonRpc::Notification.new(
+          method: "notifications/initialized"
+        )
+
+        logger.info("Sent initialized notification to server")
+        send_message(notification.to_json)
+      end
+
+      def handle_sse_data(chunk, _overall_bytes)
+        process_chunk(chunk)
+        throw :halt if @stop_requested
+      end
+
+      def process_chunk(chunk)
+        @buffer << chunk
+        # If the buffer does not contain a newline but appears to be a complete JSON object,
+        # flush it as a complete event.
+        if @buffer.strip.start_with?("{") && @buffer.strip.end_with?("}")
+          (@current_event ||= []) << @buffer.strip
+          @buffer = ""
+          return handle_complete_event
+        end
+        process_buffer while @buffer.include?("\n")
+      end
+
+
+      def process_buffer
+        line, _sep, rest = @buffer.partition("\n")
+        @buffer = rest
+
+        if line.strip.empty?
+          handle_complete_event
+        else
+          (@current_event ||= []) << line.strip
+        end
+      end
+
+      def handle_complete_event
+        return unless @current_event
+
+        handle_event(@current_event)
+        @current_event = nil
+      end
+
+      def handle_event(lines)
+        event_data = parse_event(lines)
+        process_event(event_data)
+      end
+
+      def parse_event(lines)
+        event_data = { type: "message", data: "" }
+        has_data_prefix = false
+
+        lines.each do |line|
+          if line.start_with?("event:")
+            event_data[:type] = line.split(":", 2)[1].strip
+          elsif line.start_with?("data:")
+            has_data_prefix = true
+            event_data[:data] << line.split(":", 2)[1].strip
+          end
+        end
+
+        # If no "data:" prefix was found, treat the entire event as data
+        unless has_data_prefix
+          event_data[:data] = lines.join("\n")
+        end
+        event_data
+      end
+
+      def process_event(event_data)
+        case event_data[:type]
+        when "endpoint" then set_post_endpoint(event_data[:data])
+        when "message" then handle_raw_message(event_data[:data])
+        when "ping" then log_debug("Received ping")
+        else log_error("Unknown event type: #{event_data[:type]}")
+        end
+      end
+
+      # Modify set_post_endpoint to mark connection as ready
+      def set_post_endpoint(endpoint_path)
+        @post_url = build_post_url(endpoint_path)
+        log_info("Received POST endpoint: #{@post_url}")
+
+        # Signal that we have received the endpoint
+        @endpoint_mutex.synchronize do
+          @endpoint_received = true
+          @endpoint_condition.broadcast
+        end
+
+        # Now that we have the endpoint, send initial capabilities
+        send_initial_capabilities
+      end
+
+      def build_post_url(endpoint_path)
+        URI.join(@base_url, endpoint_path).to_s
+      rescue StandardError
+        "#{@base_url}#{endpoint_path}"
+      end
+
+      def validate_post_endpoint
+        raise "MCP endpoint not set (no 'endpoint' event received)" unless @post_url
+      end
+
+      def send_http_request(json_rpc)
+        response = @conn.post(@post_url,
+                              json_rpc,
+                              { "Content-Type" => "application/json" }
+        )
+        handle_http_response(response)
+      end
+
+      def handle_http_response(response)
+        unless response.success?
+          log_error("HTTP POST failed: #{response.status} - #{response.body}")
+        end
+      end
+
+      def cleanup_sse_thread
+        return unless @sse_thread
+
+        @sse_thread.join(TIMEOUT) || @sse_thread.kill
+      end
+
+      def user_agent
+        "ActionMCP-sse-client"
+      end
+    end
+  end
+end