actionmcp 0.2.0 → 0.2.3

data/lib/action_mcp/tool.rb

@@ -5,49 +5,16 @@ module ActionMCP
   #
   # Provides a DSL for specifying metadata, properties, and nested collection schemas.
   # Tools are registered automatically in the ToolsRegistry unless marked as abstract.
-  class Tool
-    include ActiveModel::Model
-    include ActiveModel::Attributes
-    include Renderable
-
+  class Tool < Capability
     # --------------------------------------------------------------------------
     # Class Attributes for Tool Metadata and Schema
     # --------------------------------------------------------------------------
-    class_attribute :_tool_name, instance_accessor: false
-    class_attribute :_description, instance_accessor: false, default: ""
+    # @!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
-
-    # --------------------------------------------------------------------------
-    # Subclass Registration
-    # --------------------------------------------------------------------------
-    # Automatically registers non-abstract subclasses in the ToolsRegistry.
-    #
-    # @param subclass [Class] the subclass inheriting from Tool.
-    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
-
-    # Marks this tool as abstract so that it won’t be available for use.
-    # If the tool is registered in ToolsRegistry, it is unregistered.
-    def self.abstract!
-      self.abstract_tool = true
-      ToolsRegistry.unregister(tool_name) if ToolsRegistry.items.key?(tool_name)
-    end
-
-    # Returns whether this tool is abstract.
-    #
-    # @return [Boolean] true if abstract, false otherwise.
-    def self.abstract?
-      abstract_tool
-    end
 
     # --------------------------------------------------------------------------
     # Tool Name and Description DSL
@@ -58,9 +25,9 @@ module ActionMCP
     # @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
 
@@ -68,19 +35,11 @@ module ActionMCP
     #
     # @return [String] The default tool name.
     def self.default_tool_name
-      name.demodulize.underscore.dasherize.sub(/-tool$/, "")
+      name.demodulize.underscore.sub(/_tool$/, "")
     end
 
-    # Sets or retrieves the tool's description.
-    #
-    # @param text [String, nil] Optional. The description text to set.
-    # @return [String] The current description.
-    def self.description(text = nil)
-      if text
-        self._description = text
-      else
-        _description
-      end
+    class << self
+      alias default_capability_name default_tool_name
     end
 
     # --------------------------------------------------------------------------
@@ -97,6 +56,7 @@ module ActionMCP
     # @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 the JSON Schema definition.
       prop_definition = { type: type }
@@ -127,6 +87,7 @@ module ActionMCP
     # @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?
 
@@ -166,6 +127,7 @@ module ActionMCP
     # 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)
@@ -184,13 +146,14 @@ module ActionMCP
     # @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 "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
+      else :string
       end
     end
+
     private_class_method :map_json_type_to_active_model_type
   end
 end

data/lib/action_mcp/tools_registry.rb

@@ -1,11 +1,20 @@
 # 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)
@@ -19,6 +28,10 @@ module ActionMCP
           }
         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

data/lib/action_mcp/transport/stdio_client.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+require "open3"
+module ActionMCP
+  module Transport
+    class StdioClient < TransportBase
+      attr_reader :received_server_message
+
+      def initialize(command, **options)
+        super(**options)
+        @stdin, @stdout, @stderr, @wait_thr = Open3.popen3(command)
+        @threads_started = false
+        @received_server_message = false
+        @capabilities_sent = false
+      end
+
+      def start
+        start_output_threads
+
+        # Just log that connection is established but don't send capabilities yet
+        if @threads_started && @wait_thr.alive?
+          log_info("STDIO connection established")
+        else
+          log_error("Failed to start STDIO threads or process is not alive")
+        end
+      end
+
+      def send_message(json)
+        log_debug("\e[34m--> #{json}\e[0m")
+        @stdin.puts("#{json}\n\n")
+      end
+
+      def stop
+        cleanup_resources
+      end
+
+      def ready?
+        true
+      end
+
+      # Check if we've received any message from the server
+      def received_server_message?
+        @received_server_message
+      end
+
+      # Mark the client as ready and send initial capabilities if not already sent
+      def mark_ready_and_send_capabilities
+        unless @received_server_message
+          @received_server_message = true
+          log_info("Received first server message")
+
+          # Send initial capabilities if not already sent
+          unless @capabilities_sent
+            log_info("Server is ready, sending initial capabilities...")
+            send_initial_capabilities
+            @capabilities_sent = true
+          end
+        end
+      end
+
+      private
+
+      def start_output_threads
+        @stdout_thread = Thread.new do
+          @stdout.each_line do |line|
+            line = line.chomp
+            # Mark ready and send capabilities when we get any stdout
+            mark_ready_and_send_capabilities
+
+            # Continue with normal message handling
+            handle_raw_message(line)
+          end
+        end
+
+        @stderr_thread = Thread.new do
+          @stderr.each_line do |line|
+            line = line.chomp
+            log_info(line)
+
+            # Check stderr for server messages
+            if line.include?("MCP Server") || line.include?("running on stdio")
+              mark_ready_and_send_capabilities
+            end
+          end
+        end
+
+        @threads_started = true
+      end
+
+      def cleanup_resources
+        @stdin.close
+        wait_for_server_exit
+        cleanup_threads
+      end
+
+      def wait_for_server_exit
+        @wait_thr.join(0.5)
+        kill_server if @wait_thr.alive?
+      end
+
+      def kill_server
+        Process.kill("TERM", @wait_thr.pid)
+      rescue StandardError => e
+        log_error("Failed to kill server process: #{e}")
+      end
+
+      def cleanup_threads
+        @stdout_thread&.kill
+        @stderr_thread&.kill
+      end
+
+      def user_agent
+        "ActionMCP-stdio-client"
+      end
+    end
+  end
+end

data/lib/action_mcp/transport/tools.rb

@@ -0,0 +1,20 @@
+module ActionMCP
+  module Transport
+    module Tools
+      def send_tools_list(request_id)
+        tools = format_registry_items(ToolsRegistry.non_abstract)
+        send_jsonrpc_response(request_id, result: { tools: tools })
+      end
+
+      def send_tools_call(request_id, tool_name, arguments, _meta = {})
+        result = ToolsRegistry.tool_call(tool_name, arguments, _meta)
+        send_jsonrpc_response(request_id, result: result)
+      rescue RegistryBase::NotFound
+        send_jsonrpc_response(request_id, error: JsonRpc::JsonRpcError.new(
+          :method_not_found,
+          message: "Tool not found: #{tool_name}"
+        ).as_json)
+      end
+    end
+  end
+end